Implement polling part of DriveFileSyncService

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 17 matching lines @@
 #include "webkit/fileapi/syncable/sync_file_type.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 
 namespace sync_file_system {
 
 namespace {
 
 const FilePath::CharType kTempDirName[] = FILE_PATH_LITERAL("tmp");
 const FilePath::CharType kSyncFileSystemDir[] =
     FILE_PATH_LITERAL("Sync FileSystem");
+const int64 kMinimumPollingDelaySeconds = 10;
+const int64 kMaximumPollingDelaySeconds = 60 * 60;  // 1 hour
+const double kDelayMultiplier = 2;
 
 bool CreateTemporaryFile(const FilePath& dir_path, FilePath* temp_file) {
   return file_util::CreateDirectory(dir_path) &&
       file_util::CreateTemporaryFileInDir(dir_path, temp_file);
 }
 
 void DeleteTemporaryFile(const FilePath& file_path) {
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE)) {
     content::BrowserThread::PostTask(
         content::BrowserThread::FILE, FROM_HERE,
         base::Bind(&DeleteTemporaryFile, file_path));
     return;
   }
 
   if (!file_util::Delete(file_path, true))
     LOG(ERROR) << "Leaked temporary file for Sync FileSystem: "
                << file_path.value();
 }
 
 void DidUpdateConflictState(fileapi::SyncStatusCode status) {
   DCHECK_EQ(fileapi::SYNC_STATUS_OK, status);
 }
 
 void EmptyStatusCallback(fileapi::SyncStatusCode code) {}
 
+void EnablePolling(bool* polling_enabled) {
+  *polling_enabled = true;
+}
+
 }  // namespace
 
 const char DriveFileSyncService::kServiceName[] = "drive";
 
 class DriveFileSyncService::TaskToken {
  public:
   explicit TaskToken(const base::WeakPtr<DriveFileSyncService>& sync_service)
       : sync_service_(sync_service),
         task_type_(TASK_TYPE_NONE) {
   }
 
   void ResetTask(const tracked_objects::Location& location) {
     location_ = location;
     task_type_ = TASK_TYPE_NONE;
     description_.clear();
+    completion_callback_.Reset();
   }
 
   void UpdateTask(const tracked_objects::Location& location,
                   TaskType task_type,
                   const std::string& description) {
     location_ = location;
     task_type_ = task_type;
     description_ = description;
 
     DVLOG(1) << "Token updated: " << description_
              << " " << location_.ToString();
   }
 
   const tracked_objects::Location& location() const { return location_; }
   TaskType task_type() const { return task_type_; }
   const std::string& description() const { return description_; }
   std::string done_description() const { return description_ + " done"; }
 
+  void set_completion_callback(const base::Closure& callback) {
+    completion_callback_ = callback;
+  }
+
+  const base::Closure& completion_callback() {
+    return completion_callback_;
+  }
+
   ~TaskToken() {
     // All task on DriveFileSyncService must hold TaskToken instance to ensure
     // no other tasks are running. Also, as soon as a task finishes to work,
     // it must return the token to DriveFileSyncService.
     // Destroying a token with valid |sync_service_| indicates the token was
     // dropped by a task without returning.
-    DCHECK(!sync_service_);
     if (sync_service_) {
       LOG(ERROR) << "Unexpected TaskToken deletion from: "
                  << location_.ToString() << " while: " << description_;
     }
+    DCHECK(!sync_service_);
   }
 
  private:
   base::WeakPtr<DriveFileSyncService> sync_service_;
   tracked_objects::Location location_;
   TaskType task_type_;
   std::string description_;
+  base::Closure completion_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskToken);
 };
 
 struct DriveFileSyncService::ProcessRemoteChangeParam {
   scoped_ptr<TaskToken> token;
   RemoteChangeProcessor* processor;
   RemoteChange remote_change;
   fileapi::SyncOperationCallback callback;
 
@@ skipping 71 matching lines @@
   // Smaller changestamps have higher priorities (i.e. need to be processed
   // earlier).
   if (left.changestamp != right.changestamp)
     return left.changestamp > right.changestamp;
   return false;
 }
 
 DriveFileSyncService::DriveFileSyncService(Profile* profile)
     : last_operation_status_(fileapi::SYNC_STATUS_OK),
       state_(REMOTE_SERVICE_OK),
-      largest_changestamp_(0),
+      largest_fetched_changestamp_(0),
+      polling_delay_seconds_(kMinimumPollingDelaySeconds),
+      polling_enabled_(true),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   temporary_file_dir_ =
       profile->GetPath().Append(kSyncFileSystemDir).Append(kTempDirName);
   token_.reset(new TaskToken(AsWeakPtr()));
 
   sync_client_.reset(new DriveFileSyncClient(profile));
   sync_client_->AddObserver(this);
 
   metadata_store_.reset(new DriveMetadataStore(
       profile->GetPath().Append(kSyncFileSystemDir),
@@ skipping 305 matching lines @@
   }
 }
 
 // Called by CreateForTesting.
 DriveFileSyncService::DriveFileSyncService(
     const FilePath& base_dir,
     scoped_ptr<DriveFileSyncClient> sync_client,
     scoped_ptr<DriveMetadataStore> metadata_store)
     : last_operation_status_(fileapi::SYNC_STATUS_OK),
       state_(REMOTE_SERVICE_OK),
-      largest_changestamp_(0),
+      largest_fetched_changestamp_(0),
+      polling_enabled_(false),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   temporary_file_dir_ = base_dir.Append(kTempDirName);
 
   token_.reset(new TaskToken(AsWeakPtr()));
   sync_client_ = sync_client.Pass();
   metadata_store_ = metadata_store.Pass();
 
   DidInitializeMetadataStore(
       GetToken(FROM_HERE, TASK_TYPE_NONE, "Drive initialization for testing"),
       fileapi::SYNC_STATUS_OK, false);
 }
 
 scoped_ptr<DriveFileSyncService::TaskToken> DriveFileSyncService::GetToken(
     const tracked_objects::Location& from_here,
     TaskType task_type,
     const std::string& description) {
   if (!token_)
     return scoped_ptr<TaskToken>();
   token_->UpdateTask(from_here, task_type, description);
   return token_.Pass();
 }
 
 void DriveFileSyncService::NotifyTaskDone(fileapi::SyncStatusCode status,
                                           scoped_ptr<TaskToken> token) {
   DCHECK(token);
   last_operation_status_ = status;
   token_ = token.Pass();
 
-  RemoteServiceState old_state = state_;
   if (token_->task_type() != TASK_TYPE_NONE) {
     DVLOG(1) << "NotifyTaskDone: " << token_->description()
              << ": finished with status=" << status
              << " " << token_->location().ToString();
 
     RemoteServiceState old_state = state_;
     UpdateServiceState();
 
     // Notify remote sync service state if the state has been changed.
     if (!token_->description().empty() || old_state != state_) {
       FOR_EACH_OBSERVER(
           Observer, observers_,
           OnRemoteServiceStateUpdated(state_, token_->done_description()));
     }
   }
 
+  if (!token_->completion_callback().is_null())
+    token_->completion_callback().Run();
+
   token_->ResetTask(FROM_HERE);
   if (!pending_tasks_.empty()) {
     base::Closure closure = pending_tasks_.front();
     pending_tasks_.pop_front();
     closure.Run();
     return;
   }
 
-  if (state_ != REMOTE_SERVICE_OK || old_state == state_)
+  SchedulePolling();
+
+  if (state_ != REMOTE_SERVICE_OK)
     return;
 
   // If the state has become OK and we have any pending batch sync origins
   // restart batch sync for them.
   if (!pending_batch_sync_origins_.empty()) {
     GURL origin = *pending_batch_sync_origins_.begin();
     pending_batch_sync_origins_.erase(pending_batch_sync_origins_.begin());
     std::string resource_id = metadata_store_->GetResourceIdForOrigin(origin);
     StartBatchSyncForOrigin(origin, resource_id);
+    return;
   }
+
+  // Notify observer of the update of |pending_changes_|.
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    OnRemoteChangeQueueUpdated(pending_changes_.size()));
 }
 
 void DriveFileSyncService::UpdateServiceState() {
   switch (last_operation_status_) {
     // Possible regular operation errors.
     case fileapi::SYNC_STATUS_OK:
     case fileapi::SYNC_STATUS_FILE_BUSY:
     case fileapi::SYNC_STATUS_HAS_CONFLICT:
     case fileapi::SYNC_STATUS_NO_CONFLICT:
     case fileapi::SYNC_STATUS_NO_CHANGE_TO_SYNC:
@@ skipping 41 matching lines @@
 
 void DriveFileSyncService::DidInitializeMetadataStore(
     scoped_ptr<TaskToken> token,
     fileapi::SyncStatusCode status,
     bool created) {
   if (status != fileapi::SYNC_STATUS_OK) {
     NotifyTaskDone(status, token.Pass());
     return;
   }
 
+  largest_fetched_changestamp_ = metadata_store_->GetLargestChangeStamp();
+
   if (metadata_store_->sync_root_directory().empty()) {
     GetSyncRootDirectory(token.Pass(), base::Bind(&EmptyStatusCallback));
     return;
   }
 
   NotifyTaskDone(status, token.Pass());
 
   for (std::map<GURL, std::string>::const_iterator itr =
            metadata_store_->batch_sync_origins().begin();
        itr != metadata_store_->batch_sync_origins().end();
@@ skipping 90 matching lines @@
     const std::string& resource_id,
     google_apis::GDataErrorCode error,
     int64 largest_changestamp) {
   if (error != google_apis::HTTP_SUCCESS) {
     pending_batch_sync_origins_.insert(origin);
     // TODO(tzik): Refine this error code.
     NotifyTaskDone(GDataErrorCodeToSyncStatusCodeWrapper(error), token.Pass());
     return;
   }
 
+  if (metadata_store_->incremental_sync_origins().empty()) {
+    largest_fetched_changestamp_ = largest_changestamp;
+    metadata_store_->SetLargestChangeStamp(
+        largest_changestamp,
+        base::Bind(&EmptyStatusCallback));
+  }
+
   DCHECK(token);
   token->UpdateTask(FROM_HERE, TASK_TYPE_DRIVE, "Retrieving remote files");
   sync_client_->ListFiles(
       resource_id,
       base::Bind(
           &DriveFileSyncService::DidGetDirectoryContentForBatchSync,
           AsWeakPtr(), base::Passed(&token), origin, largest_changestamp));
 }
 
 void DriveFileSyncService::DidGetDirectoryContentForBatchSync(
     scoped_ptr<TaskToken> token,
     const GURL& origin,
     int64 largest_changestamp,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::DocumentFeed> feed) {
   if (error != google_apis::HTTP_SUCCESS) {
     pending_batch_sync_origins_.insert(origin);
     // TODO(tzik): Refine this error code.
     NotifyTaskDone(GDataErrorCodeToSyncStatusCodeWrapper(error), token.Pass());
     return;
   }
 
   typedef ScopedVector<google_apis::DocumentEntry>::const_iterator iterator;
   for (iterator itr = feed->entries().begin();
        itr != feed->entries().end(); ++itr) {
-    AppendNewRemoteChange(origin, *itr, largest_changestamp,
+    AppendNewRemoteChange(origin, **itr, largest_changestamp,
                           REMOTE_SYNC_TYPE_BATCH);
   }
 
   GURL next_feed_url;
   if (feed->GetNextFeedURL(&next_feed_url)) {
     sync_client_->ContinueListing(
         next_feed_url,
         base::Bind(
             &DriveFileSyncService::DidGetDirectoryContentForBatchSync,
             AsWeakPtr(), base::Passed(&token), origin, largest_changestamp));
@@ skipping 84 matching lines @@
   return SYNC_OPERATION_FAILED;
 }
 
 void DriveFileSyncService::DidApplyLocalChange(
     scoped_ptr<TaskToken> token,
     const fileapi::FileSystemURL& url,
     const google_apis::GDataErrorCode error,
     const fileapi::SyncStatusCallback& callback,
     fileapi::SyncStatusCode status) {
   if (status == fileapi::SYNC_STATUS_OK) {
-    CancelRemoteChange(url);
+    RemoveRemoteChange(url);
     NotifyTaskDone(GDataErrorCodeToSyncStatusCodeWrapper(error), token.Pass());
     callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
     return;
   }
   NotifyTaskDone(status, token.Pass());
   callback.Run(status);
 }
 
 void DriveFileSyncService::DidUploadNewFile(
     scoped_ptr<TaskToken> token,
@@ skipping 114 matching lines @@
   const DriveMetadata& drive_metadata = param->drive_metadata;
 
   status = metadata_store_->ReadEntry(param->remote_change.url,
                                       &param->drive_metadata);
   DCHECK(status == fileapi::SYNC_STATUS_OK ||
          status == fileapi::SYNC_DATABASE_ERROR_NOT_FOUND);
 
   bool missing_db_entry = (status != fileapi::SYNC_STATUS_OK);
   if (missing_db_entry) {
     param->drive_metadata.set_resource_id(param->remote_change.resource_id);
+    param->drive_metadata.set_md5_checksum(std::string());
     param->drive_metadata.set_conflicted(false);
   }
   bool missing_local_file =
       (metadata.file_type == fileapi::SYNC_FILE_TYPE_UNKNOWN);
 
   if (param->drive_metadata.conflicted()) {
     if (missing_local_file) {
       if (param->remote_change.change.IsAddOrUpdate()) {
         NOTIMPLEMENTED() << "ResolveToRemote()";
         AbortRemoteSync(param.Pass(), fileapi::SYNC_STATUS_FAILED);
@@ skipping 59 matching lines @@
 
   DCHECK(param->remote_change.change.IsDelete());
   if (local_changes.empty()) {
     if (missing_local_file) {
       param->operation_type = fileapi::SYNC_OPERATION_NONE;
       DeleteMetadataForRemoteSync(param.Pass());
       return;
     }
     DCHECK(!missing_local_file);
     param->operation_type = fileapi::SYNC_OPERATION_DELETE;
+
+    const fileapi::FileChange& file_change = param->remote_change.change;
     param->processor->ApplyRemoteChange(
-        param->remote_change.change, FilePath(), url,
+        file_change, FilePath(), url,
         base::Bind(&DriveFileSyncService::DidApplyRemoteChange, AsWeakPtr(),
                    base::Passed(&param)));
     return;
   }
 
   DCHECK(!local_changes.empty());
   if (local_changes.list().back().IsAddOrUpdate()) {
     param->operation_type = fileapi::SYNC_OPERATION_NONE;
     CompleteRemoteSync(param.Pass(), fileapi::SYNC_STATUS_OK);
     return;
@@ skipping 18 matching lines @@
 }
 
 void DriveFileSyncService::DidGetTemporaryFileForDownload(
     scoped_ptr<ProcessRemoteChangeParam> param,
     bool success) {
   if (!success) {
     AbortRemoteSync(param.Pass(), fileapi::SYNC_FILE_ERROR_FAILED);
     return;
   }
 
-  DriveMetadata metadata;
-  metadata_store_->ReadEntry(param->remote_change.url, &metadata);
-
   const FilePath& temporary_file_path = param->temporary_file_path;
   std::string resource_id = param->remote_change.resource_id;
+  const DriveMetadata& drive_metadata = param->drive_metadata;
   sync_client_->DownloadFile(
-      resource_id, metadata.md5_checksum(),
+      resource_id, drive_metadata.md5_checksum(),
       temporary_file_path,
       base::Bind(&DriveFileSyncService::DidDownloadFile,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 void DriveFileSyncService::DidDownloadFile(
     scoped_ptr<ProcessRemoteChangeParam> param,
     google_apis::GDataErrorCode error,
     const std::string& md5_checksum) {
   if (error == google_apis::HTTP_NOT_MODIFIED) {
     param->operation_type = fileapi::SYNC_OPERATION_NONE;
     CompleteRemoteSync(param.Pass(), fileapi::SYNC_STATUS_OK);
     return;
   }
 
   fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCodeWrapper(error);
   if (status != fileapi::SYNC_STATUS_OK) {
     AbortRemoteSync(param.Pass(), status);
     return;
   }
 
-  param->md5_checksum = md5_checksum;
+  param->drive_metadata.set_md5_checksum(md5_checksum);
   const fileapi::FileChange& change = param->remote_change.change;
   const FilePath& temporary_file_path = param->temporary_file_path;
   const fileapi::FileSystemURL& url = param->remote_change.url;
   param->processor->ApplyRemoteChange(
       change, temporary_file_path, url,
       base::Bind(&DriveFileSyncService::DidApplyRemoteChange,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 void DriveFileSyncService::DidApplyRemoteChange(
     scoped_ptr<ProcessRemoteChangeParam> param,
     fileapi::SyncStatusCode status) {
   if (status != fileapi::SYNC_STATUS_OK) {
     AbortRemoteSync(param.Pass(), status);
     return;
   }
 
   fileapi::FileSystemURL url = param->remote_change.url;
   if (param->remote_change.change.IsDelete()) {
     DeleteMetadataForRemoteSync(param.Pass());
     return;
   }
 
-  DriveMetadata metadata;
-  metadata.set_resource_id(param->remote_change.resource_id);
-  metadata.set_md5_checksum(param->md5_checksum);
-  metadata.set_conflicted(false);
+  const DriveMetadata& drive_metadata = param->drive_metadata;
+  param->drive_metadata.set_resource_id(param->remote_change.resource_id);
+  param->drive_metadata.set_conflicted(false);
 
   metadata_store_->UpdateEntry(
-      url, metadata,
+      url, drive_metadata,
       base::Bind(&DriveFileSyncService::CompleteRemoteSync,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 void DriveFileSyncService::DeleteMetadataForRemoteSync(
     scoped_ptr<ProcessRemoteChangeParam> param) {
   fileapi::FileSystemURL url = param->remote_change.url;
   metadata_store_->DeleteEntry(
       url,
       base::Bind(&DriveFileSyncService::CompleteRemoteSync,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 void DriveFileSyncService::CompleteRemoteSync(
     scoped_ptr<ProcessRemoteChangeParam> param,
     fileapi::SyncStatusCode status) {
   if (status != fileapi::SYNC_STATUS_OK) {
     AbortRemoteSync(param.Pass(), status);
     return;
   }
 
-  CancelRemoteChange(param->remote_change.url);
+  RemoveRemoteChange(param->remote_change.url);
 
   GURL origin = param->remote_change.url.origin();
   if (metadata_store_->IsIncrementalSyncOrigin(origin)) {
     int64 changestamp = param->remote_change.changestamp;
     metadata_store_->SetLargestChangeStamp(
         changestamp,
         base::Bind(&DriveFileSyncService::FinalizeRemoteSync,
                    AsWeakPtr(), base::Passed(&param)));
     return;
   }
@@ skipping 20 matching lines @@
     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(
     const GURL& origin,
-    google_apis::DocumentEntry* entry,
+    const google_apis::DocumentEntry& entry,
     int64 changestamp,
     RemoteSyncType sync_type) {
   // TODO(tzik): Normalize the path here.
-  FilePath path = FilePath::FromUTF8Unsafe(UTF16ToUTF8(entry->title()));
+  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;
     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()) {
+  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->kind() == google_apis::ENTRY_KIND_FOLDER)
+    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,
+      changestamp, entry.resource_id(), url, file_change,
       inserted_to_queue.first);
 }
 
-void DriveFileSyncService::CancelRemoteChange(
+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());
   if (found_change == path_to_change->end())
     return;
 
   pending_changes_.erase(found_change->second.position_in_queue);
   path_to_change->erase(found_change);
   if (path_to_change->empty())
     url_to_change_.erase(found_origin);
 
-  MaybeMarkAsIncrementalSyncOrigin(url.origin());
-}
-
-void DriveFileSyncService::MaybeMarkAsIncrementalSyncOrigin(
-    const GURL& origin) {
-  if (metadata_store_->IsBatchSyncOrigin(origin) &&
-      !ContainsKey(url_to_change_, origin))
-    metadata_store_->MoveBatchSyncOriginToIncremental(origin);
+  if (metadata_store_->IsBatchSyncOrigin(url.origin()) &&
+      !ContainsKey(url_to_change_, url.origin())) {
+    metadata_store_->MoveBatchSyncOriginToIncremental(url.origin());
+  }
 }
 
 bool DriveFileSyncService::GetPendingChangeForFileSystemURL(
     const fileapi::FileSystemURL& url,
     RemoteChange* change) const {
   DCHECK(change);
   URLToChange::const_iterator found_url = url_to_change_.find(url.origin());
   if (found_url == url_to_change_.end())
     return false;
   const PathToChange& path_to_change = found_url->second;
   PathToChange::const_iterator found_path = path_to_change.find(url.path());
   if (found_path == path_to_change.end())
     return false;
   *change = found_path->second;
   return true;
 }
 
+void DriveFileSyncService::FetchChangesForIncrementalSync() {
+  scoped_ptr<TaskToken> token(GetToken(FROM_HERE, TASK_TYPE_DRIVE,
+                                       "Fetching remote change list"));
+  if (!token) {
+    pending_tasks_.push_back(base::Bind(
+        &DriveFileSyncService::FetchChangesForIncrementalSync, AsWeakPtr()));
+    return;
+  }
+
+  polling_enabled_ = false;
+  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_,
+      base::Bind(&DriveFileSyncService::DidFetchChangesForIncrementalSync,
+                 AsWeakPtr(), base::Passed(&token)));
+}
+
+void DriveFileSyncService::DidFetchChangesForIncrementalSync(
+    scoped_ptr<TaskToken> token,
+    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);
+  }
+
+  GURL next_feed;
+  if (changes->GetNextFeedURL(&next_feed)) {
+    sync_client_->ContinueListing(
+        next_feed,
+        base::Bind(&DriveFileSyncService::DidFetchChangesForIncrementalSync,
+                   AsWeakPtr(), base::Passed(&token)));
+    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.
+    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();
+       itr != entry.links().end(); ++itr) {
+    if ((*itr)->type() != google_apis::Link::LINK_PARENT)
+      continue;
+    GURL origin(UTF16ToUTF8((*itr)->title()));
+    if (!origin.is_valid())
+      continue;
+
+    if (!metadata_store_->IsBatchSyncOrigin(origin) &&
+        !metadata_store_->IsIncrementalSyncOrigin(origin))
+      continue;
+    std::string resource_id(metadata_store_->GetResourceIdForOrigin(origin));
+    GURL resource_link(sync_client_->ResourceIdToResourceLink(resource_id));
+    if ((*itr)->href().GetOrigin() != resource_link.GetOrigin() ||
+        (*itr)->href().path() != resource_link.path())
+      continue;
+
+    *origin_out = origin;
+    return true;
+  }
+  return false;
+}
+
+void DriveFileSyncService::SchedulePolling() {
+  if (!pending_batch_sync_origins_.empty() ||
+      metadata_store_->incremental_sync_origins().empty() ||
+      !pending_changes_.empty() ||
+      !polling_enabled_ ||
+      polling_timer_.IsRunning())
+    return;
+
+  if (state_ != REMOTE_SERVICE_OK &&
+      state_ != REMOTE_SERVICE_TEMPORARY_UNAVAILABLE)
+    return;
+
+  if (state_ == REMOTE_SERVICE_TEMPORARY_UNAVAILABLE)
+    polling_delay_seconds_ = kMaximumPollingDelaySeconds;
+
+  DVLOG(1) << "Polling scheduled"
+           << " (delay:" << polling_delay_seconds_ << "s)";
+
+  polling_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(polling_delay_seconds_),
+      base::Bind(&DriveFileSyncService::FetchChangesForIncrementalSync,
+                 AsWeakPtr()));
+}
+
 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