Sync FileSystem: Update polling delay when remote change-list did not update change_queue.

chrome/browser/sync_file_system/drive_file_sync_service.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/sync_file_system/drive_file_sync_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 1291 matching lines @@
   NotifyTaskDone(status, param->token.Pass());
   if (status == fileapi::SYNC_STATUS_OK) {
     param->callback.Run(status, param->remote_change.url,
                         param->operation_type);
   } else {
     param->callback.Run(status, param->remote_change.url,
                         fileapi::SYNC_OPERATION_NONE);
   }
 }
 
-void DriveFileSyncService::AppendNewRemoteChange(
+bool DriveFileSyncService::AppendNewRemoteChange(
     const GURL& origin,
     const google_apis::DocumentEntry& entry,
     int64 changestamp,
     RemoteSyncType sync_type) {
   // TODO(tzik): Normalize the path here.
   FilePath path = FilePath::FromUTF8Unsafe(UTF16ToUTF8(entry.title()));
 
   PathToChange* path_to_change = &url_to_change_[origin];
   PathToChange::iterator found = path_to_change->find(path);
   if (found != path_to_change->end()) {
     if (found->second.changestamp >= changestamp)
-      return;
+      return false;
     pending_changes_.erase(found->second.position_in_queue);
   }
 
   fileapi::FileSystemURL url(
       fileapi::CreateSyncableFileSystemURL(origin, kServiceName, path));
 
   fileapi::FileChange::ChangeType change_type;
   fileapi::SyncFileType file_type;
   if (entry.deleted()) {
     change_type = fileapi::FileChange::FILE_CHANGE_DELETE;
     file_type = fileapi::SYNC_FILE_TYPE_UNKNOWN;
   } else {
     change_type = fileapi::FileChange::FILE_CHANGE_ADD_OR_UPDATE;
     if (entry.is_folder())
       file_type = fileapi::SYNC_FILE_TYPE_DIRECTORY;
     else
       file_type = fileapi::SYNC_FILE_TYPE_FILE;
   }
 
   fileapi::FileChange file_change(change_type, file_type);
 
   std::pair<PendingChangeQueue::iterator, bool> inserted_to_queue =
       pending_changes_.insert(ChangeQueueItem(changestamp, sync_type, url));
   DCHECK(inserted_to_queue.second);
 
   (*path_to_change)[path] = RemoteChange(
       changestamp, entry.resource_id(), url, file_change,
       inserted_to_queue.first);
+  return true;
 }
 
 void DriveFileSyncService::RemoveRemoteChange(
     const fileapi::FileSystemURL& url) {
   URLToChange::iterator found_origin = url_to_change_.find(url.origin());
   if (found_origin == url_to_change_.end())
     return;
 
   PathToChange* path_to_change = &found_origin->second;
   PathToChange::iterator found_change = path_to_change->find(url.path());
@@ skipping 39 matching lines @@
   token->set_completion_callback(base::Bind(&EnablePolling, &polling_enabled_));
 
   if (metadata_store_->incremental_sync_origins().empty()) {
     NotifyTaskDone(fileapi::SYNC_STATUS_OK, token.Pass());
     return;
   }
 
   sync_client_->ListChanges(
       largest_fetched_changestamp_ + 1,
       base::Bind(&DriveFileSyncService::DidFetchChangesForIncrementalSync,
-                 AsWeakPtr(), base::Passed(&token)));
+                 AsWeakPtr(), base::Passed(&token), false));
 }
 
 void DriveFileSyncService::DidFetchChangesForIncrementalSync(
     scoped_ptr<TaskToken> token,
+    bool queue_was_updated,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::DocumentFeed> changes) {
   if (error != google_apis::HTTP_SUCCESS) {
     NotifyTaskDone(GDataErrorCodeToSyncStatusCodeWrapper(error), token.Pass());
     return;
   }
 
   typedef ScopedVector<google_apis::DocumentEntry>::const_iterator iterator;
   for (iterator itr = changes->entries().begin();
        itr != changes->entries().end(); ++itr) {
     const google_apis::DocumentEntry& entry = **itr;
     GURL origin;
     if (!GetOriginForEntry(entry, &origin))
       continue;
 
-    AppendNewRemoteChange(origin, entry, entry.changestamp(),
-                          REMOTE_SYNC_TYPE_INCREMENTAL);
+    queue_was_updated = queue_was_updated ||
+        AppendNewRemoteChange(origin, entry, entry.changestamp(),
+                              REMOTE_SYNC_TYPE_INCREMENTAL);
   }
 
   GURL next_feed;
   if (changes->GetNextFeedURL(&next_feed)) {
     sync_client_->ContinueListing(
         next_feed,
         base::Bind(&DriveFileSyncService::DidFetchChangesForIncrementalSync,
-                   AsWeakPtr(), base::Passed(&token)));
+                   AsWeakPtr(), base::Passed(&token), queue_was_updated));
     return;
   }
 
   largest_fetched_changestamp_ = changes->largest_changestamp();
 
-  if (changes->start_index() == 0 && changes->entries().empty()) {
-    // If this set of changes is the first feed and it's empty, update
-    // the polling delay to wait longer.
+  if (queue_was_updated) {
+    polling_delay_seconds_ = kMinimumPollingDelaySeconds;
+  } else {
+    // If the change_queue_ was not updated, update the polling delay to wait
+    // longer.
     polling_delay_seconds_ = std::min(
         static_cast<int64>(kDelayMultiplier * polling_delay_seconds_),
         kMaximumPollingDelaySeconds);
-  } else {
-    polling_delay_seconds_ = kMinimumPollingDelaySeconds;
   }
 
   NotifyTaskDone(fileapi::SYNC_STATUS_OK, token.Pass());
 }
 
 bool DriveFileSyncService::GetOriginForEntry(
     const google_apis::DocumentEntry& entry,
     GURL* origin_out) {
   typedef ScopedVector<google_apis::Link>::const_iterator iterator;
   for (iterator itr = entry.links().begin();
@@ skipping 46 matching lines @@
 fileapi::SyncStatusCode
 DriveFileSyncService::GDataErrorCodeToSyncStatusCodeWrapper(
     google_apis::GDataErrorCode error) const {
   fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != fileapi::SYNC_STATUS_OK && !sync_client_->IsAuthenticated())
     return fileapi::SYNC_STATUS_AUTHENTICATION_FAILED;
   return status;
 }
 
 }  // namespace sync_file_system