drive: Some cleanup for ChangeListLoader

chrome/browser/chromeos/drive/change_list_loader.cc

 // 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.
 
 #include "chrome/browser/chromeos/drive/change_list_loader.h"
 
 #include <set>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 110 matching lines @@
 // Loaded feed may be partial due to size limit on a single feed. In that case,
 // the loaded feed will have next feed url set. Iff |load_subsequent_feeds|
 // parameter is set, feed loader will load all subsequent feeds.
 //
 // If invoked as a part of content search, query will be set in |search_query|.
 // If |feed_to_load| is set, this is feed url that will be used to load feed.
 //
 // When all feeds are loaded, |feed_load_callback| is invoked with the retrieved
 // feeds. |feed_load_callback| must not be null.
 struct ChangeListLoader::LoadFeedParams {
-  explicit LoadFeedParams(const LoadFeedListCallback& feed_load_callback)
+  LoadFeedParams()
       : start_changestamp(0),
         shared_with_me(false),
-        load_subsequent_feeds(true),
-        feed_load_callback(feed_load_callback) {}
-
-  // Runs this->feed_load_callback with |error|.
-  void RunFeedLoadCallback(DriveFileError error) {
-    feed_load_callback.Run(feed_list, error);
-  }
+        load_subsequent_feeds(true) {}
 
   // Changestamps are positive numbers in increasing order. The difference
   // between two changestamps is proportional equal to number of items in
   // delta feed between them - bigger the difference, more likely bigger
   // number of items in delta feeds.
   int64 start_changestamp;
   std::string search_query;
   bool shared_with_me;
   std::string directory_resource_id;
   GURL feed_to_load;
   bool load_subsequent_feeds;
-  const LoadFeedListCallback feed_load_callback;
   ScopedVector<google_apis::ResourceList> feed_list;
   scoped_ptr<GetResourceListUiState> ui_state;
 };
 
 // Defines set of parameters sent to callback OnProtoLoaded().
 struct ChangeListLoader::LoadRootFeedParams {
   explicit LoadRootFeedParams(const FileOperationCallback& callback)
       : load_start_time(base::Time::Now()),
         callback(callback) {}
 
   std::string proto;
   base::Time last_modified;
   // Time when filesystem began to be loaded from disk.
   base::Time load_start_time;
   const FileOperationCallback callback;
 };
 
-// Defines parameters sent to UpdateMetadataFromFeedAfterLoadFromServer().
-//
-// In the case of loading the root feed we use |root_feed_changestamp| as its
-// initial changestamp value since it does not come with that info.
-//
-// On initial feed load for Drive API, remember root ID for
-// DriveResourceData initialization later in UpdateFromFeed().
-struct ChangeListLoader::UpdateMetadataParams {
-  UpdateMetadataParams(bool is_delta_feed,
-                       int64 feed_changestamp,
-                       const FileOperationCallback& callback)
-      : is_delta_feed(is_delta_feed),
-        feed_changestamp(feed_changestamp),
-        callback(callback) {}
-
-  const bool is_delta_feed;
-  const int64 feed_changestamp;
-  const FileOperationCallback callback;
-};
-
 // Defines set of parameters sent to callback OnNotifyResourceListFetched().
 // This is a trick to update the number of fetched documents frequently on
 // UI. Due to performance reason, we need to fetch a number of files at
 // a time. However, it'll take long time, and a user has no way to know
 // the current update state. In order to make users comfortable,
 // we increment the number of fetched documents with more frequent but smaller
 // steps than actual fetching.
 struct ChangeListLoader::GetResourceListUiState {
   explicit GetResourceListUiState(base::TimeTicks start_time)
       : num_fetched_documents(0),
@@ skipping 121 matching lines @@
                    << local_changestamp
                    << ", server = "
                    << remote_changestamp;
     }
 
     // No changes detected, tell the client that the loading was successful.
     OnChangeListLoadComplete(callback, DRIVE_FILE_OK);
     return;
   }
 
-  // Load changes from the server.
   int64 start_changestamp = local_changestamp > 0 ? local_changestamp + 1 : 0;
-  scoped_ptr<LoadFeedParams> load_params(new LoadFeedParams(
+
+  // TODO(satorux): Use directory_fetch_info to start "fast-fetch" here.
+  LoadChangeListFromServer(start_changestamp,
+                           remote_changestamp,
+                           callback);
+}
+
+void ChangeListLoader::LoadChangeListFromServer(
+    int64 start_changestamp,
+    int64 remote_changestamp,
+    const FileOperationCallback& callback) {
+  scoped_ptr<LoadFeedParams> load_params(new LoadFeedParams);
+  load_params->start_changestamp = start_changestamp;
+  LoadFromServer(
+      load_params.Pass(),
       base::Bind(&ChangeListLoader::UpdateMetadataFromFeedAfterLoadFromServer,
                  weak_ptr_factory_.GetWeakPtr(),
-                 UpdateMetadataParams(start_changestamp != 0,  // is_delta_feed
-                                      remote_changestamp,
-                                      callback))));
-  load_params->start_changestamp = start_changestamp;
-
-  // TODO(satorux): Use directory_fetch_info to start "fast-fetch" here.
-  LoadFromServer(load_params.Pass());
+                 start_changestamp != 0,  // is_delta_feed
+                 remote_changestamp,
+                 callback));
 }
 
 void ChangeListLoader::OnGetAppList(google_apis::GDataErrorCode status,
                                    scoped_ptr<google_apis::AppList> app_list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK)
     return;
 
   if (app_list.get()) {
     webapps_registry_->UpdateFromAppList(*app_list);
   }
 }
 
-void ChangeListLoader::LoadFromServer(scoped_ptr<LoadFeedParams> params) {
+void ChangeListLoader::LoadFromServer(scoped_ptr<LoadFeedParams> params,
+                                      const LoadFeedListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   const base::TimeTicks start_time = base::TimeTicks::Now();
 
   // base::Passed() may get evaluated first, so get a pointer to params.
   LoadFeedParams* params_ptr = params.get();
   scheduler_->GetResourceList(
       params_ptr->feed_to_load,
       params_ptr->start_changestamp,
       params_ptr->search_query,
       params_ptr->shared_with_me,
       params_ptr->directory_resource_id,
-      base::Bind(&ChangeListLoader::OnGetResourceList,
+      base::Bind(&ChangeListLoader::LoadFromServerAfterGetResourceList,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&params),
+                 callback,
                  start_time));
 }
 
 void ChangeListLoader::LoadDirectoryFromServer(
     const std::string& directory_resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // First fetch the latest changestamp to see if this directory needs to be
@@ skipping 25 matching lines @@
   DoLoadDirectoryFromServer(directory_fetch_info, callback);
 }
 
 void ChangeListLoader::DoLoadDirectoryFromServer(
     const DirectoryFetchInfo& directory_fetch_info,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(!directory_fetch_info.empty());
 
-  scoped_ptr<LoadFeedParams> params(new LoadFeedParams(
+  scoped_ptr<LoadFeedParams> params(new LoadFeedParams);
+  params->directory_resource_id = directory_fetch_info.resource_id();
+  LoadFromServer(
+      params.Pass(),
       base::Bind(&ChangeListLoader::DoLoadDirectoryFromServerAfterLoad,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_fetch_info,
-                 callback)));
-  params->directory_resource_id = directory_fetch_info.resource_id();
-  LoadFromServer(params.Pass());
+                 callback));
 }
 
 void ChangeListLoader::DoLoadDirectoryFromServerAfterLoad(
     const DirectoryFetchInfo& directory_fetch_info,
     const FileOperationCallback& callback,
     const ScopedVector<google_apis::ResourceList>& resource_list,
     DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(!directory_fetch_info.empty());
@@ skipping 33 matching lines @@
   }
 }
 
 void ChangeListLoader::SearchFromServer(
     const std::string& search_query,
     bool shared_with_me,
     const GURL& next_feed,
     const LoadFeedListCallback& feed_load_callback) {
   DCHECK(!feed_load_callback.is_null());
 
-  scoped_ptr<LoadFeedParams> params(new LoadFeedParams(feed_load_callback));
+  scoped_ptr<LoadFeedParams> params(new LoadFeedParams);
   params->search_query = search_query;
   params->shared_with_me = shared_with_me;
   params->feed_to_load = next_feed;
   params->load_subsequent_feeds = false;
-  LoadFromServer(params.Pass());
+  LoadFromServer(params.Pass(), feed_load_callback);
 }
 
 void ChangeListLoader::UpdateMetadataFromFeedAfterLoadFromServer(
-    const UpdateMetadataParams& params,
+    bool is_delta_feed,
+    int64 feed_changestamp,
+    const FileOperationCallback& callback,
     const ScopedVector<google_apis::ResourceList>& feed_list,
     DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!params.callback.is_null());
+  DCHECK(!callback.is_null());
   DCHECK(refreshing_);
 
   if (error != DRIVE_FILE_OK) {
-    OnChangeListLoadComplete(params.callback, error);
+    OnChangeListLoadComplete(callback, error);
     return;
   }
 
   UpdateFromFeed(feed_list,
-                 params.is_delta_feed,
-                 params.feed_changestamp,
+                 is_delta_feed,
+                 feed_changestamp,
                  base::Bind(&ChangeListLoader::OnUpdateFromFeed,
                             weak_ptr_factory_.GetWeakPtr(),
-                            params.callback));
+                            callback));
 }
 
-void ChangeListLoader::OnGetResourceList(
+void ChangeListLoader::LoadFromServerAfterGetResourceList(
     scoped_ptr<LoadFeedParams> params,
+    const LoadFeedListCallback& callback,
     base::TimeTicks start_time,
     google_apis::GDataErrorCode status,
     scoped_ptr<google_apis::ResourceList> resource_list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   if (params->feed_list.empty()) {
     UMA_HISTOGRAM_TIMES("Drive.InitialFeedLoadTime",
                         base::TimeTicks::Now() - start_time);
   }
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
-    params->RunFeedLoadCallback(error);
+    callback.Run(params->feed_list, error);
     return;
   }
   DCHECK(resource_list);
 
   GURL next_feed_url;
   const bool has_next_feed_url =
       params->load_subsequent_feeds &&
       resource_list->GetNextFeedURL(&next_feed_url);
 
   // Add the current feed to the list of collected feeds for this directory.
@@ skipping 29 matching lines @@
     // |params| will be passed to the callback and thus nulled. Extract the
     // pointer so we can use it bellow.
     LoadFeedParams* params_ptr = params.get();
     // Kick off the remaining part of the feeds.
     scheduler_->GetResourceList(
         next_feed_url,
         params_ptr->start_changestamp,
         params_ptr->search_query,
         params_ptr->shared_with_me,
         params_ptr->directory_resource_id,
-        base::Bind(&ChangeListLoader::OnGetResourceList,
+        base::Bind(&ChangeListLoader::LoadFromServerAfterGetResourceList,
                    weak_ptr_factory_.GetWeakPtr(),
                    base::Passed(&params),
+                   callback,
                    start_time));
     return;
   }
 
   // Notify the observers that all document feeds are fetched.
   FOR_EACH_OBSERVER(ChangeListLoaderObserver, observers_,
                     OnResourceListFetched(num_accumulated_entries));
 
   UMA_HISTOGRAM_TIMES("Drive.EntireFeedLoadTime",
                       base::TimeTicks::Now() - start_time);
 
   // Run the callback so the client can process the retrieved feeds.
-  params->RunFeedLoadCallback(DRIVE_FILE_OK);
+  callback.Run(params->feed_list, DRIVE_FILE_OK);
 }
 
 void ChangeListLoader::OnNotifyResourceListFetched(
     base::WeakPtr<GetResourceListUiState> ui_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!ui_state) {
     // The ui state instance is already released, which means the fetching
     // is done and we don't need to update any more.
     return;
@@ skipping 234 matching lines @@
     QueuedCallbackInfo info  = queue_.front();
     const FileOperationCallback& callback = info.second;
     queue_.pop();
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, error));
   }
 }
 
 }  // namespace drive