Refactor drive::ChangeListLoader.

chrome/browser/chromeos/drive/change_list_loader.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CHROME_BROWSER_CHROMEOS_DRIVE_CHANGE_LIST_LOADER_H_
 #define CHROME_BROWSER_CHROMEOS_DRIVE_CHANGE_LIST_LOADER_H_
 
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 86 matching lines @@
   //
   // See comments at ChangeListProcessor::ApplyFeeds() for
   // |about_resource| and |is_delta_feed|.
   // |update_finished_callback| must not be null.
   void UpdateFromFeed(scoped_ptr<google_apis::AboutResource> about_resource,
                       ScopedVector<ChangeList> change_lists,
                       bool is_delta_feed,
                       const base::Closure& update_finished_callback);
 
   // Indicates whether there is a feed refreshing server request is in flight.
-  bool refreshing() const { return refreshing_; }
+  bool IsRefreshing() const;
 
  private:
-  // Initiates the change list loading from the server if the local
-  // changestamp is older than the server changestamp.
-  // See the comment at Load() for |directory_fetch_info| parameter.
-  // |callback| must not be null.
+  // Implementation of LoadIfNeeded and CheckForUpdates. Start metadata loading
+  // of |directory_fetch_info|, and calls |callback| when it's done. If there is
+  // already a loading job in-flight for |directory_fetch_info|, just append
+  // the |callback| to the callback queue of the already running job.
+  void Load(const DirectoryFetchInfo& directory_fetch_info,
+            const FileOperationCallback& callback);
+
+  // Part of Load(). DoInitialLoad() is called if it is the first time to Load.
+  // Otherwise DoUpdateLoad() is used. The difference of two cases are:
+  // - When we could load from cache, DoInitialLoad runs callback immediately
+  //   and further operations (check changestamp and load from server if needed)
+  //   in background.
+  // - Even when |directory_fetch_info| is set, DoInitialLoad runs change list
+  //   loading after directory loading is finished.
+  void DoInitialLoad(const DirectoryFetchInfo& directory_fetch_info,
+                     int64 local_changestamp);
+  void DoUpdateLoad(const DirectoryFetchInfo& directory_fetch_info,
+                    int64 local_changestamp);
+
+  // Part of Load().
+  // Initiates the change list loading from the server when |local_changestamp|
+  // is older than the server changestamp. If |directory_fetch_info| is set,
+  // do directory loading before change list loading.
   void LoadFromServerIfNeeded(const DirectoryFetchInfo& directory_fetch_info,
-                              const FileOperationCallback& callback);
+                              int64 local_changestamp);
 
-  // Checks the local changestamp. |callback| must not be null.
-  void CheckLocalChangestamp(const GetChangestampCallback& callback);
+  // Part of Load().
+  // Checks the directory's changestamp and |last_known_remote_changestamp_|,
+  // and load the feed from server if it is old. Runs |callback| when it's done.
+  void CheckChangestampAndLoadDirectoryIfNeeed(
+      const DirectoryFetchInfo& directory_fetch_info,
+      int64 local_changestamp,
+      const FileOperationCallback& callback);
 
-  // Part of Load(). Called after checking the local changestamp completes.
-  void LoadAfterCheckLocalChangestamp(
-      const DirectoryFetchInfo& directory_fetch_info,
-      const FileOperationCallback& callback,
-      int64 local_changestamp);
-
+  // Part of LoadChangeListFromServer().
   // Callback to fetch all the resource list response from the server.
   // After all the resource list are fetched, |callback|
   // will be invoked with the collected change lists.
   // |callback| must not be null.
   void OnGetResourceList(
       ScopedVector<ChangeList> change_lists,
       const LoadFeedListCallback& callback,
       base::TimeTicks start_time,
       google_apis::GDataErrorCode status,
       scoped_ptr<google_apis::ResourceList> data);
@@ skipping 41 matching lines @@
       DriveFileError error);
 
   // Part of DoLoadDirectoryFromServer(). Called after
   // DriveResourceMetadata::RefreshDirectory() is complete.
   void DoLoadDirectoryFromServerAfterRefresh(
       const DirectoryFetchInfo& directory_fetch_info,
       const FileOperationCallback& callback,
       DriveFileError error,
       const base::FilePath& directory_path);
 
-  // Part of LoadFromServerIfNeeded(). Called when
-  // DriveScheduler::GetAboutResource() is complete. This method calls
-  // CompareChangestampsAndLoadIfNeeded() to make a decision about whether or
-  // not to fetch the change list.
+  // Part of LoadFromServerIfNeeded(). Called when GetAboutResource is complete.
   void LoadFromServerIfNeededAfterGetAbout(
       const DirectoryFetchInfo& directory_fetch_info,
-      const FileOperationCallback& callback,
+      int64 local_changestamp,
       google_apis::GDataErrorCode status,
       scoped_ptr<google_apis::AboutResource> about_resource);
 
-  // Compares the largetst_change_id in |about_resource| and |local_changestamp|
-  // and triggers LoadFromServer if necessary.
-  void CompareChangestampsAndLoadIfNeeded(
-      const DirectoryFetchInfo& directory_fetch_info,
-      const FileOperationCallback& callback,
-      scoped_ptr<google_apis::AboutResource> about_resource,
-      int64 local_changestamp);
-
+  // Part of LoadFromServerIfNeeded().
   // Starts loading the change list since |start_changestamp|, or the full
   // resource list if |start_changestamp| is zero. For full update, the
   // largest_change_id and root_folder_id from |about_resource| will be used.
-  // |callback| must not be null.
   void LoadChangeListFromServer(
       scoped_ptr<google_apis::AboutResource> about_resource,
-      int64 start_changestamp,
-      const FileOperationCallback& callback);
+      int64 start_changestamp);
 
+  // Part of LoadFromServerIfNeeded().
   // Starts loading the change list from the server. Called after the
   // directory contents are "fast-fetch"ed.
-  void StartLoadChangeListFromServer(
+  void LoadChangeListFromServerAfterLoadDirectory(
     const DirectoryFetchInfo& directory_fetch_info,
     scoped_ptr<google_apis::AboutResource> about_resource,
     int64 start_changestamp,
-    const FileOperationCallback& callback,
     DriveFileError error);
 
   // Callback for handling response from |DriveAPIService::GetAppList|.
   // If the application list is successfully parsed, passes the list to
   // Drive webapps registry.
   void OnGetAppList(google_apis::GDataErrorCode status,
                     scoped_ptr<google_apis::AppList> app_list);
 
   // Part of SearchFromServer. Called when ResourceList is fetched from the
   // server.
   // |callback| must not be null.
   void SearchFromServerAfterGetResourceList(
       const LoadFeedListCallback& callback,
       google_apis::GDataErrorCode status,
       scoped_ptr<google_apis::ResourceList> resource_list);
 
-  // Callback for handling feed content fetching while searching for file info.
-  // This callback is invoked after async feed fetch operation that was
-  // invoked by StartDirectoryRefresh() completes. This callback will update
-  // the content of the refreshed directory object and continue initially
-  // started FindEntryByPath() request.
+  // Part of LoadChangeListFromServer().
+  // Applies the change list loaded from the server to local metadata storage.
   void UpdateMetadataFromFeedAfterLoadFromServer(
       scoped_ptr<google_apis::AboutResource> about_resource,
       bool is_delta_feed,
-      const FileOperationCallback& callback,
       ScopedVector<ChangeList> change_lists,
       DriveFileError error);
 
   // Callback for ChangeListProcessor::ApplyFeeds.
   void NotifyDirectoryChangedAfterApplyFeed(
       bool should_notify,
       const base::Closure& update_finished_callback);
 
-  // Callback for UpdateFromFeed.
-  void OnUpdateFromFeed(bool is_initial_load,
-                        const FileOperationCallback& load_finished_callback);
+  // Part of LoadChangeListFromServer().
+  // Called when UpdateMetadataFromFeedAfterLoadFromServer is finished.
+  void OnUpdateFromFeed();
 
   // This function should be called when the change list load is complete.
-  // Runs |callback| with |error|, and flushes the pending callbacks.
-  void OnChangeListLoadComplete(const FileOperationCallback& callback,
-                                DriveFileError error);
+  // Flushes the callbacks for change list loading and all directory loading.
+  void OnChangeListLoadComplete(DriveFileError error);
 
-  // This function should be called when the change list load is complete.
-  // Runs |callback| with |error|, and flushes the pending callbacks.
+  // This function should be called when the directory load is complete.
+  // Flushes the callbacks waiting for the directory to be loaded.
   void OnDirectoryLoadComplete(const DirectoryFetchInfo& directory_fetch_info,
-                               const FileOperationCallback& callback,
                                DriveFileError error);
 
-  // Schedules |callback| to run when it's ready (i.e. the change list
-  // loading is complete or the directory specified by |directory_fetch_info|
-  // is loaded). |directory_fetch_info| can be empty if the callback is not
-  // interested in a particular directory.
-  // |callback| must not be null.
-  void ScheduleRun(const DirectoryFetchInfo& directory_fetch_info,
-                   const FileOperationCallback& callback);
-
-  // Flushes the feed loading callbacks added via ScheduleRun(), by scheduling
-  // to run all of them with the given error code.
-  void FlushPendingLoadCallback(DriveFileError error);
-
-  // Processes tasks that match the resource ID.
-  void ProcessPendingLoadCallbackForDirectory(const std::string& resource_id,
-                                              DriveFileError error);
-
   DriveResourceMetadata* resource_metadata_;  // Not owned.
   DriveScheduler* scheduler_;  // Not owned.
   DriveWebAppsRegistry* webapps_registry_;  // Not owned.
   ObserverList<ChangeListLoaderObserver> observers_;
   scoped_ptr<ChangeListProcessor> change_list_processor_;
   typedef std::map<std::string, std::vector<FileOperationCallback> >
       LoadCallbackMap;
   LoadCallbackMap pending_load_callback_;
 
   // Indicates whether there is a feed refreshing server request is in flight.
-  bool refreshing_;
   int64 last_known_remote_changestamp_;
 
   // True if the file system feed is loaded from the cache or from the server.
   bool loaded_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<ChangeListLoader> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(ChangeListLoader);
 };
 
 }  // namespace drive
 
 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_CHANGE_LIST_LOADER_H_