[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 1 | // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
yawano | 3513e14 | 2016-04-20 00:42:42 | [diff] [blame] | 5 | #ifndef COMPONENTS_DRIVE_CHROMEOS_DIRECTORY_LOADER_H_ |
| 6 | #define COMPONENTS_DRIVE_CHROMEOS_DIRECTORY_LOADER_H_ |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 7 | |
avi | bc5337b | 2015-12-25 23:16:33 | [diff] [blame] | 8 | #include <stdint.h> |
| 9 | |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 10 | #include <map> |
dcheng | f4275023 | 2016-04-12 04:12:27 | [diff] [blame] | 11 | #include <memory> |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 12 | #include <set> |
| 13 | #include <string> |
| 14 | #include <vector> |
| 15 | |
| 16 | #include "base/callback.h" |
David Benjamin | 8048aac | 2019-04-08 01:33:46 | [diff] [blame] | 17 | #include "base/containers/unique_ptr_adapters.h" |
avi | bc5337b | 2015-12-25 23:16:33 | [diff] [blame] | 18 | #include "base/macros.h" |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 19 | #include "base/memory/ref_counted.h" |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 20 | #include "base/observer_list.h" |
lukasza | 037c10b1 | 2015-06-12 04:21:25 | [diff] [blame] | 21 | #include "base/threading/thread_checker.h" |
Stuart Langley | d2c0cb0 | 2018-09-27 02:07:00 | [diff] [blame] | 22 | #include "base/time/default_clock.h" |
yawano | 3513e14 | 2016-04-20 00:42:42 | [diff] [blame] | 23 | #include "components/drive/chromeos/file_system_interface.h" |
lukasza | 76b4a98 | 2015-08-08 00:36:39 | [diff] [blame] | 24 | #include "components/drive/file_errors.h" |
satorux | 1e04b42 | 2015-01-29 07:50:53 | [diff] [blame] | 25 | #include "google_apis/drive/drive_api_error_codes.h" |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 26 | #include "google_apis/drive/drive_common_callbacks.h" |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 27 | |
| 28 | namespace base { |
Stuart Langley | d2c0cb0 | 2018-09-27 02:07:00 | [diff] [blame] | 29 | class Clock; |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 30 | class SequencedTaskRunner; |
| 31 | } // namespace base |
| 32 | |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 33 | namespace drive { |
| 34 | |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 35 | class EventLogger; |
| 36 | class JobScheduler; |
| 37 | class ResourceEntry; |
| 38 | |
| 39 | namespace internal { |
| 40 | |
Stuart Langley | 24e4ff5 | 2018-05-25 00:29:19 | [diff] [blame] | 41 | class RootFolderIdLoader; |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 42 | class ChangeListLoaderObserver; |
| 43 | class DirectoryFetchInfo; |
| 44 | class LoaderController; |
| 45 | class ResourceMetadata; |
Stuart Langley | c92ed25 | 2018-05-16 08:38:34 | [diff] [blame] | 46 | class StartPageTokenLoader; |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 47 | |
| 48 | // DirectoryLoader is used to load directory contents. |
| 49 | class DirectoryLoader { |
| 50 | public: |
Stuart Langley | d2c0cb0 | 2018-09-27 02:07:00 | [diff] [blame] | 51 | // |clock| can be mocked for testing |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 52 | DirectoryLoader(EventLogger* logger, |
| 53 | base::SequencedTaskRunner* blocking_task_runner, |
| 54 | ResourceMetadata* resource_metadata, |
| 55 | JobScheduler* scheduler, |
Stuart Langley | 24e4ff5 | 2018-05-25 00:29:19 | [diff] [blame] | 56 | RootFolderIdLoader* root_folder_id_loader, |
Stuart Langley | c92ed25 | 2018-05-16 08:38:34 | [diff] [blame] | 57 | StartPageTokenLoader* start_page_token_loader, |
Stuart Langley | 95c2150 | 2018-05-25 04:21:29 | [diff] [blame] | 58 | LoaderController* apply_task_controller, |
Stuart Langley | d03e9be | 2018-09-06 23:42:52 | [diff] [blame] | 59 | const base::FilePath& root_entry_path, |
Stuart Langley | d2c0cb0 | 2018-09-27 02:07:00 | [diff] [blame] | 60 | const std::string& team_drive_id, |
| 61 | const base::Clock* clock = base::DefaultClock::GetInstance()); |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 62 | ~DirectoryLoader(); |
| 63 | |
| 64 | // Adds and removes the observer. |
| 65 | void AddObserver(ChangeListLoaderObserver* observer); |
| 66 | void RemoveObserver(ChangeListLoaderObserver* observer); |
| 67 | |
[email protected] | b71475f | 2014-03-03 08:09:11 | [diff] [blame] | 68 | // Reads the directory contents. |
[email protected] | f173c6d | 2014-04-14 10:49:50 | [diff] [blame] | 69 | // |entries_callback| can be null. |
| 70 | // |completion_callback| must not be null. |
[email protected] | b71475f | 2014-03-03 08:09:11 | [diff] [blame] | 71 | void ReadDirectory(const base::FilePath& directory_path, |
Stuart Langley | 4819fdb | 2018-08-27 00:12:28 | [diff] [blame] | 72 | ReadDirectoryEntriesCallback entries_callback, |
[email protected] | f173c6d | 2014-04-14 10:49:50 | [diff] [blame] | 73 | const FileOperationCallback& completion_callback); |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 74 | |
| 75 | private: |
| 76 | class FeedFetcher; |
[email protected] | bbf59f2 | 2014-03-24 13:55:26 | [diff] [blame] | 77 | struct ReadDirectoryCallbackState; |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 78 | |
[email protected] | b71475f | 2014-03-03 08:09:11 | [diff] [blame] | 79 | // Part of ReadDirectory(). |
[email protected] | f173c6d | 2014-04-14 10:49:50 | [diff] [blame] | 80 | void ReadDirectoryAfterGetEntry( |
| 81 | const base::FilePath& directory_path, |
Stuart Langley | 4819fdb | 2018-08-27 00:12:28 | [diff] [blame] | 82 | ReadDirectoryEntriesCallback entries_callback, |
[email protected] | f173c6d | 2014-04-14 10:49:50 | [diff] [blame] | 83 | const FileOperationCallback& completion_callback, |
| 84 | bool should_try_loading_parent, |
| 85 | const ResourceEntry* entry, |
| 86 | FileError error); |
| 87 | void ReadDirectoryAfterLoadParent( |
| 88 | const base::FilePath& directory_path, |
Stuart Langley | 4819fdb | 2018-08-27 00:12:28 | [diff] [blame] | 89 | ReadDirectoryEntriesCallback entries_callback, |
[email protected] | f173c6d | 2014-04-14 10:49:50 | [diff] [blame] | 90 | const FileOperationCallback& completion_callback, |
| 91 | FileError error); |
Stuart Langley | 24e4ff5 | 2018-05-25 00:29:19 | [diff] [blame] | 92 | void ReadDirectoryAfterGetRootFolderId( |
Stuart Langley | d2c0cb0 | 2018-09-27 02:07:00 | [diff] [blame] | 93 | const base::FilePath& directory_path, |
[email protected] | 8542d3c | 2014-03-19 05:57:22 | [diff] [blame] | 94 | const std::string& local_id, |
Stuart Langley | 24e4ff5 | 2018-05-25 00:29:19 | [diff] [blame] | 95 | FileError error, |
| 96 | base::Optional<std::string> root_folder_id); |
Stuart Langley | c92ed25 | 2018-05-16 08:38:34 | [diff] [blame] | 97 | void ReadDirectoryAfterGetStartPageToken( |
Stuart Langley | d2c0cb0 | 2018-09-27 02:07:00 | [diff] [blame] | 98 | const base::FilePath& directory_path, |
Stuart Langley | c92ed25 | 2018-05-16 08:38:34 | [diff] [blame] | 99 | const std::string& local_id, |
| 100 | const std::string& root_folder_id, |
| 101 | google_apis::DriveApiErrorCode status, |
| 102 | std::unique_ptr<google_apis::StartPageToken> start_page_token); |
| 103 | |
[email protected] | 8542d3c | 2014-03-19 05:57:22 | [diff] [blame] | 104 | void ReadDirectoryAfterCheckLocalState( |
Stuart Langley | d2c0cb0 | 2018-09-27 02:07:00 | [diff] [blame] | 105 | const base::FilePath& directory_path, |
Stuart Langley | c92ed25 | 2018-05-16 08:38:34 | [diff] [blame] | 106 | const std::string& remote_start_page_token, |
[email protected] | 8542d3c | 2014-03-19 05:57:22 | [diff] [blame] | 107 | const std::string& local_id, |
Stuart Langley | 24e4ff5 | 2018-05-25 00:29:19 | [diff] [blame] | 108 | const std::string& root_folder_id, |
[email protected] | 8542d3c | 2014-03-19 05:57:22 | [diff] [blame] | 109 | const ResourceEntry* entry, |
Stuart Langley | c92ed25 | 2018-05-16 08:38:34 | [diff] [blame] | 110 | const std::string* local_start_page_token, |
[email protected] | 8542d3c | 2014-03-19 05:57:22 | [diff] [blame] | 111 | FileError error); |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 112 | |
[email protected] | c8f46ab | 2014-03-12 17:54:30 | [diff] [blame] | 113 | // Part of ReadDirectory(). |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 114 | // This function should be called when the directory load is complete. |
| 115 | // Flushes the callbacks waiting for the directory to be loaded. |
[email protected] | 8542d3c | 2014-03-19 05:57:22 | [diff] [blame] | 116 | void OnDirectoryLoadComplete(const std::string& local_id, FileError error); |
[email protected] | bbf59f2 | 2014-03-24 13:55:26 | [diff] [blame] | 117 | void OnDirectoryLoadCompleteAfterRead(const std::string& local_id, |
| 118 | const ResourceEntryVector* entries, |
| 119 | FileError error); |
| 120 | |
| 121 | // Sends |entries| to the callbacks. |
| 122 | void SendEntries(const std::string& local_id, |
[email protected] | f173c6d | 2014-04-14 10:49:50 | [diff] [blame] | 123 | const ResourceEntryVector& entries); |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 124 | |
| 125 | // ================= Implementation for directory loading ================= |
| 126 | // Loads the directory contents from server, and updates the local metadata. |
| 127 | // Runs |callback| when it is finished. |
Stuart Langley | 24e4ff5 | 2018-05-25 00:29:19 | [diff] [blame] | 128 | void LoadDirectoryFromServer(const DirectoryFetchInfo& directory_fetch_info, |
| 129 | const std::string& root_folder_id); |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 130 | |
| 131 | // Part of LoadDirectoryFromServer() for a normal directory. |
| 132 | void LoadDirectoryFromServerAfterLoad( |
| 133 | const DirectoryFetchInfo& directory_fetch_info, |
| 134 | FeedFetcher* fetcher, |
[email protected] | bbf59f2 | 2014-03-24 13:55:26 | [diff] [blame] | 135 | FileError error); |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 136 | |
| 137 | // Part of LoadDirectoryFromServer(). |
Stuart Langley | c92ed25 | 2018-05-16 08:38:34 | [diff] [blame] | 138 | void LoadDirectoryFromServerAfterUpdateStartPageToken( |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 139 | const DirectoryFetchInfo& directory_fetch_info, |
| 140 | const base::FilePath* directory_path, |
| 141 | FileError error); |
| 142 | |
| 143 | EventLogger* logger_; // Not owned. |
| 144 | scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_; |
| 145 | ResourceMetadata* resource_metadata_; // Not owned. |
| 146 | JobScheduler* scheduler_; // Not owned. |
Stuart Langley | 24e4ff5 | 2018-05-25 00:29:19 | [diff] [blame] | 147 | RootFolderIdLoader* root_folder_id_loader_; // Not owned. |
Stuart Langley | c92ed25 | 2018-05-16 08:38:34 | [diff] [blame] | 148 | StartPageTokenLoader* start_page_token_loader_; // Not owned |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 149 | LoaderController* loader_controller_; // Not owned. |
Trent Apted | a250ec3ab | 2018-08-19 08:52:19 | [diff] [blame] | 150 | base::ObserverList<ChangeListLoaderObserver>::Unchecked observers_; |
[email protected] | bbf59f2 | 2014-03-24 13:55:26 | [diff] [blame] | 151 | typedef std::map<std::string, std::vector<ReadDirectoryCallbackState> > |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 152 | LoadCallbackMap; |
| 153 | LoadCallbackMap pending_load_callback_; |
| 154 | |
| 155 | // Set of the running feed fetcher for the fast fetch. |
David Benjamin | 8048aac | 2019-04-08 01:33:46 | [diff] [blame] | 156 | std::set<std::unique_ptr<FeedFetcher>, base::UniquePtrComparator> |
| 157 | fast_fetch_feed_fetcher_set_; |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 158 | |
Stuart Langley | 95c2150 | 2018-05-25 04:21:29 | [diff] [blame] | 159 | // The root entry path for changes being loaded by this directory loader. |
| 160 | // Can be a team drive root entry or for the users default corpus will be the |
| 161 | // drive root entry. |
| 162 | const base::FilePath root_entry_path_; |
| 163 | |
Stuart Langley | d03e9be | 2018-09-06 23:42:52 | [diff] [blame] | 164 | // The team drive id for this directory loader. Used to retrieve the start |
| 165 | // page token when performing a fast fetch. |
| 166 | const std::string team_drive_id_; |
| 167 | |
Stuart Langley | d2c0cb0 | 2018-09-27 02:07:00 | [diff] [blame] | 168 | const base::Clock* clock_; // Not Owned |
| 169 | |
Stuart Langley | be403574 | 2018-05-10 05:32:27 | [diff] [blame] | 170 | THREAD_CHECKER(thread_checker_); |
lukasza | 037c10b1 | 2015-06-12 04:21:25 | [diff] [blame] | 171 | |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 172 | // Note: This should remain the last member so it'll be destroyed and |
| 173 | // invalidate its weak pointers before any other members are destroyed. |
Jeremy Roman | 47d432e | 2019-08-20 14:24:00 | [diff] [blame] | 174 | base::WeakPtrFactory<DirectoryLoader> weak_ptr_factory_{this}; |
[email protected] | 54cb8e0 | 2014-02-24 09:29:19 | [diff] [blame] | 175 | DISALLOW_COPY_AND_ASSIGN(DirectoryLoader); |
| 176 | }; |
| 177 | |
| 178 | } // namespace internal |
| 179 | } // namespace drive |
| 180 | |
yawano | 3513e14 | 2016-04-20 00:42:42 | [diff] [blame] | 181 | #endif // COMPONENTS_DRIVE_CHROMEOS_DIRECTORY_LOADER_H_ |