drive: Pass through AboutResouce from server among callbacks in 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 162 matching lines @@
 }
 
 void ChangeListLoader::LoadFromServerIfNeededAfterGetAbout(
     const DirectoryFetchInfo& directory_fetch_info,
     const FileOperationCallback& callback,
     google_apis::GDataErrorCode status,
     scoped_ptr<google_apis::AboutResource> about_resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(refreshing_);
+  DCHECK_EQ(util::GDataToDriveFileError(status) == DRIVE_FILE_OK,
+            about_resource.get() != NULL);
 
   int64 remote_changestamp = 0;
   if (util::GDataToDriveFileError(status) == DRIVE_FILE_OK) {
     DCHECK(about_resource);
     remote_changestamp = about_resource->largest_change_id();
     last_known_remote_changestamp_ = remote_changestamp;
   }
 
   resource_metadata_->GetLargestChangestamp(
       base::Bind(&ChangeListLoader::CompareChangestampsAndLoadIfNeeded,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_fetch_info,
                  callback,
-                 remote_changestamp));
+                 base::Passed(&about_resource)));
 }
 
 void ChangeListLoader::CompareChangestampsAndLoadIfNeeded(
     const DirectoryFetchInfo& directory_fetch_info,
     const FileOperationCallback& callback,
-    int64 remote_changestamp,
+    scoped_ptr<google_apis::AboutResource> about_resource,
     int64 local_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(refreshing_);
 
+  int64 remote_changestamp =
+      about_resource ? about_resource->largest_change_id() : 0;
   if (remote_changestamp > 0 && local_changestamp >= remote_changestamp) {
     if (local_changestamp > remote_changestamp) {
       LOG(WARNING) << "Cached client feed is fresher than server, client = "
                    << local_changestamp
                    << ", server = "
                    << remote_changestamp;
     }
 
     // No changes detected, tell the client that the loading was successful.
     OnChangeListLoadComplete(callback, DRIVE_FILE_OK);
     return;
   }
 
   int64 start_changestamp = local_changestamp > 0 ? local_changestamp + 1 : 0;
+  if (start_changestamp == 0 && !about_resource.get()) {
+    // Full update needs AboutResource. If this is a full update, we should just
+    // give up.
+    callback.Run(DRIVE_FILE_ERROR_FAILED);
+    return;
+  }
 
   if (directory_fetch_info.empty()) {
     // If the caller is not interested in a particular directory, just start
     // loading the change list.
-    LoadChangeListFromServer(start_changestamp,
-                             remote_changestamp,
+    LoadChangeListFromServer(about_resource.Pass(),
+                             start_changestamp,
                              callback);
   } else if (directory_fetch_info.changestamp() < remote_changestamp) {
     // If the caller is interested in a particular directory, and the
     // directory changestamp is older than server's, start loading the
     // directory first.
     DVLOG(1) << "Fast-fetching directory: " << directory_fetch_info.ToString()
              << "; remote_changestamp: " << remote_changestamp;
     const DirectoryFetchInfo new_directory_fetch_info(
         directory_fetch_info.resource_id(), remote_changestamp);
     DoLoadDirectoryFromServer(
         new_directory_fetch_info,
         base::Bind(&ChangeListLoader::StartLoadChangeListFromServer,
                    weak_ptr_factory_.GetWeakPtr(),
                    directory_fetch_info,
+                   base::Passed(&about_resource),
                    start_changestamp,
-                   remote_changestamp,
                    callback));
   } else {
     // The directory is up-to-date, hence there is no need to load.
     OnChangeListLoadComplete(callback, DRIVE_FILE_OK);
   }
 }
 
 void ChangeListLoader::LoadChangeListFromServer(
+    scoped_ptr<google_apis::AboutResource> about_resource,
     int64 start_changestamp,
-    int64 remote_changestamp,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(refreshing_);
 
   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(),
+                 base::Passed(&about_resource),
                  start_changestamp != 0,  // is_delta_feed
-                 remote_changestamp,
                  callback));
 }
 
 void ChangeListLoader::StartLoadChangeListFromServer(
     const DirectoryFetchInfo& directory_fetch_info,
+    scoped_ptr<google_apis::AboutResource> about_resource,
     int64 start_changestamp,
-    int64 remote_changestamp,
     const FileOperationCallback& callback,
     DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(refreshing_);
 
   if (error == DRIVE_FILE_OK) {
     callback.Run(DRIVE_FILE_OK);
     DVLOG(1) << "Fast-fetch was successful: " << directory_fetch_info.ToString()
              << "; Start loading the change list";
     // Stop passing |callback| as it's just consumed.
     LoadChangeListFromServer(
+        about_resource.Pass(),
         start_changestamp,
-        remote_changestamp,
         base::Bind(&util::EmptyFileOperationCallback));
   } else {
     // The directory fast-fetch failed, but the change list loading may
     // succeed. Keep passing |callback| so it's run after the change list
     // loading is complete.
-    LoadChangeListFromServer(start_changestamp, remote_changestamp, callback);
+    LoadChangeListFromServer(
+        about_resource.Pass(), start_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;
@@ skipping 134 matching lines @@
 
   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(), feed_load_callback);
 }
 
 void ChangeListLoader::UpdateMetadataFromFeedAfterLoadFromServer(
+    scoped_ptr<google_apis::AboutResource> about_resource,
     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(!callback.is_null());
   DCHECK(refreshing_);
 
   if (error != DRIVE_FILE_OK) {
     OnChangeListLoadComplete(callback, error);
     return;
   }
 
-  UpdateFromFeed(feed_list,
+  UpdateFromFeed(about_resource.Pass(),
+                 feed_list,
                  is_delta_feed,
-                 feed_changestamp,
                  base::Bind(&ChangeListLoader::OnUpdateFromFeed,
                             weak_ptr_factory_.GetWeakPtr(),
                             !loaded(),  // is_initial_load
                             callback));
 }
 
 void ChangeListLoader::LoadFromServerAfterGetResourceList(
     scoped_ptr<LoadFeedParams> params,
     const LoadFeedListCallback& callback,
     base::TimeTicks start_time,
@@ skipping 212 matching lines @@
 }
 
 void ChangeListLoader::SaveFileSystem() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   resource_metadata_->MaybeSave(
       cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_META));
 }
 
 void ChangeListLoader::UpdateFromFeed(
+    scoped_ptr<google_apis::AboutResource> about_resource,
     const ScopedVector<google_apis::ResourceList>& feed_list,
     bool is_delta_feed,
-    int64 root_feed_changestamp,
     const base::Closure& update_finished_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!update_finished_callback.is_null());
   DVLOG(1) << "Updating directory with a feed";
 
   change_list_processor_.reset(new ChangeListProcessor(resource_metadata_));
   // Don't send directory content change notification while performing
   // the initial content retrieval.
   const bool should_notify_changed_directories = is_delta_feed;
 
   change_list_processor_->ApplyFeeds(
+      about_resource.Pass(),
       feed_list,
       is_delta_feed,
-      root_feed_changestamp,
       base::Bind(&ChangeListLoader::NotifyDirectoryChangedAfterApplyFeed,
                  weak_ptr_factory_.GetWeakPtr(),
                  should_notify_changed_directories,
                  update_finished_callback));
 }
 
 void ChangeListLoader::ScheduleRun(
     const DirectoryFetchInfo& directory_fetch_info,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 130 matching lines @@
     for (size_t i = 0; i < callbacks.size(); ++i) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE,
           base::Bind(callbacks[i], error));
     }
     pending_load_callback_.erase(it);
   }
 }
 
 }  // namespace drive