drive: Update directory changestamp after "fast fetch" for the content.

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/metrics/histogram.h"
@@ skipping 336 matching lines @@
       const FileOperationCallback& callback,
       google_apis::GDataErrorCode status,
       scoped_ptr<google_apis::AboutResource> about_resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_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;
   }
 
   const DirectoryFetchInfo directory_fetch_info(directory_resource_id,
                                                 remote_changestamp);
   DoLoadDirectoryFromServer(directory_fetch_info, callback);
 }
 
 void ChangeListLoader::DoLoadDirectoryFromServer(
     const DirectoryFetchInfo& directory_fetch_info,
     const FileOperationCallback& callback) {
@@ skipping 360 matching lines @@
   // If the directory of interest is already scheduled to be fetched, add the
   // callback to the pending list and return.
   LoadCallbackMap::iterator it = pending_load_callback_.find(resource_id);
   if (it != pending_load_callback_.end()) {
     it->second.push_back(callback);
     return;
   }
 
   // If the directory's changestamp is up-to-date, just schedule to run the
   // callback, as there is no need to fetch the directory.
-  if (directory_fetch_info.changestamp() >= last_known_remote_changestamp_) {
+  // Note that |last_known_remote_changestamp_| is 0 when it is not received
+  // yet. In that case we conservatively assume that we need to fetch.
+  if (last_known_remote_changestamp_ > 0 &&
+      directory_fetch_info.changestamp() >= last_known_remote_changestamp_) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DRIVE_FILE_OK));
     return;
   }
 
   // The directory should be fetched. Add a dummy task to so ScheduleRun()
   // can check that the directory is being fetched.
   pending_load_callback_[resource_id].push_back(
       base::Bind(&util::EmptyFileOperationCallback));
+
+  // Start fetching the directory content, and mark it with the changestamp
+  // |last_known_remote_changestamp_|. To be precise, instead we need to call
+  // GetAboutResource() to get the latest changestamp. However,
+  // - It is costly to do GetAboutResource HTTP request every time.
+  // - The chance using an old value is small; it only happens when LoadIfNeeded
+  //   is called during one GetAboutResource roundtrip time of a feed fetching.
+  // - Even if the value is old, it just marks the directory as older. It may
+  //   trigger one future unnecessary re-fetch, but it'll never lose data, etc.
+  DirectoryFetchInfo new_directory_fetch_info(
+      directory_fetch_info.resource_id(),
+      std::max(directory_fetch_info.changestamp(),
+               last_known_remote_changestamp_));
   DoLoadDirectoryFromServer(
-      directory_fetch_info,
+      new_directory_fetch_info,
       base::Bind(&ChangeListLoader::OnDirectoryLoadComplete,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_fetch_info,
                  callback));
 }
 
 void ChangeListLoader::NotifyDirectoryChangedAfterApplyFeed(
     bool should_notify_changed_directories,
     const base::Closure& update_finished_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 90 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