drive: Trigger "fast fetch" if remote update came during full loading.

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/callback_helpers.h"
@@ skipping 309 matching lines @@
 
 void ChangeListLoader::RemoveObserver(ChangeListLoaderObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.RemoveObserver(observer);
 }
 
 void ChangeListLoader::CheckForUpdates(const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
+  // If the metadata is not yet loaded, CheckForUpdates does nothing.
+  if (!loaded_ && !IsRefreshing())
+    return;
+
+  // For each CheckForUpdates() request, always refresh the changestamp info.
+  about_resource_loader_->UpdateAboutResource(
+      base::Bind(&ChangeListLoader::OnAboutResourceUpdated,
+                 weak_ptr_factory_.GetWeakPtr()));
+
   if (IsRefreshing()) {
     // There is in-flight loading. So keep the callback here, and check for
     // updates when the in-flight loading is completed.
     pending_update_check_callback_ = callback;
     return;
   }
 
   if (loaded_) {

[hashimoto, 2014/08/06 05:55:43]

nit: Can't we replace this "if" with DCHECK?

[kinaba, 2014/08/06 06:16:54]

Done.

     // We only start to check for updates iff the load is done.
     // I.e., we ignore checking updates if not loaded to avoid starting the
     // load without user's explicit interaction (such as opening Drive).
     logger_->Log(logging::LOG_INFO, "Checking for updates");
     Load(callback);
   }
 }
 
 void ChangeListLoader::LoadIfNeeded(const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // If the metadata is not yet loaded, start loading.
-  if (!loaded_)
+  if (!loaded_ && !IsRefreshing()) {
+    about_resource_loader_->UpdateAboutResource(

[hashimoto, 2014/08/06 05:55:43]

GetAboutResource() requests the resource if not available.
Why should we call UpdateAboutResource() here?

[kinaba, 2014/08/06 06:16:54]

Good point. Done.

+        base::Bind(&ChangeListLoader::OnAboutResourceUpdated,
+                   weak_ptr_factory_.GetWeakPtr()));
     Load(callback);
+  }
 }
 
 void ChangeListLoader::Load(const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Check if this is the first time this ChangeListLoader do loading.
   // Note: IsRefreshing() depends on pending_load_callback_ so check in advance.
   const bool is_initial_load = (!loaded_ && !IsRefreshing());
 
@@ skipping 32 matching lines @@
   if (is_initial_load && *local_changestamp > 0) {
     // The local data is usable. Flush callbacks to tell loading was successful.
     OnChangeListLoadComplete(FILE_ERROR_OK);
 
     // Continues to load from server in background.
     // Put dummy callbacks to indicate that fetching is still continuing.
     pending_load_callback_.push_back(
         base::Bind(&util::EmptyFileOperationCallback));
   }
 
-  about_resource_loader_->UpdateAboutResource(
+  about_resource_loader_->GetAboutResource(
       base::Bind(&ChangeListLoader::LoadAfterGetAboutResource,
                  weak_ptr_factory_.GetWeakPtr(),
                  *local_changestamp));
 }
 
 void ChangeListLoader::LoadAfterGetAboutResource(
     int64 local_changestamp,
     google_apis::GDataErrorCode status,
     scoped_ptr<google_apis::AboutResource> about_resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 40 matching lines @@
   }
   pending_load_callback_.clear();
 
   // If there is pending update check, try to load the change from the server
   // again, because there may exist an update during the completed loading.
   if (!pending_update_check_callback_.is_null()) {
     Load(base::ResetAndReturn(&pending_update_check_callback_));
   }
 }
 
+void ChangeListLoader::OnAboutResourceUpdated(
+    google_apis::GDataErrorCode error,
+    scoped_ptr<google_apis::AboutResource> resource) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (drive::GDataToFileError(error) != drive::FILE_ERROR_OK) {
+    logger_->Log(logging::LOG_ERROR,
+                 "Failed to update the about resource: %s",
+                 google_apis::GDataErrorCodeToString(error).c_str());
+    return;
+  }
+  logger_->Log(logging::LOG_INFO,
+               "About resource updated to: %s",
+               base::Int64ToString(resource->largest_change_id()).c_str());
+}
+
 void ChangeListLoader::LoadChangeListFromServer(int64 start_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!change_feed_fetcher_);
   DCHECK(about_resource_loader_->cached_about_resource());
 
   bool is_delta_update = start_changestamp != 0;
 
   // Set up feed fetcher.
   if (is_delta_update) {
     change_feed_fetcher_.reset(
@@ skipping 74 matching lines @@
 
   OnChangeListLoadComplete(error);
 
   FOR_EACH_OBSERVER(ChangeListLoaderObserver,
                     observers_,
                     OnLoadFromServerComplete());
 }
 
 }  // namespace internal
 }  // namespace drive