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 char kResourceLinkPrefix[] =
+    "https://docs.google.com/feeds/default/private/full/";

[kinuko, 2012/11/29 11:40:46]

Can we use GDataWapiUrlGenerator::GenerateDocumentListRootUrl()?

(And I think the URL should be given by DriveFileSyncClient and use the same
base URL?)

[tzik, 2012/12/03 10:00:08]

Done

+const int64 kMinimumPollingDelaySeconds = 10;
+const int64 kMaximumPollingDelaySeconds = 60 * 60;  // 1 hour
+const int64 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) {}
 
+

[kinuko, 2012/11/29 11:40:46]

nit: extra empty line

[tzik, 2012/12/03 10:00:08]

Done.

+GURL ResourceIdToResourceLink(const std::string& resource_id) {
+  return GURL(kResourceLinkPrefix + net::EscapePath(resource_id));
+}
+
 }  // 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) {
   }
@@ skipping 122 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_synced_changestamp_(0),

[kinuko, 2012/11/29 11:47:43]

We're not using this?

[tzik, 2012/12/03 10:00:08]

Done. Removed.

+      largest_fetched_changestamp_(0),
+      polling_delay_(base::TimeDelta::FromSeconds(kMinimumPollingDelaySeconds)),
       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));
 
   metadata_store_.reset(new DriveMetadataStore(
       profile->GetPath().Append(kSyncFileSystemDir),
       content::BrowserThread::GetMessageLoopProxyForThread(
@@ skipping 280 matching lines @@
                       callback, fileapi::SYNC_STATUS_FAILED);
 }
 
 // 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_synced_changestamp_(0),
+      largest_fetched_changestamp_(0),
       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()));
     }
   }
 
   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_)
+  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;
   }
+
+  FOR_EACH_OBSERVER(Observer, observers_,

[kinuko, 2012/11/29 11:40:46]

Can you comment why we do this here?

[tzik, 2012/12/03 10:00:08]

Done.

+                    OnRemoteChangeAvailable(pending_changes_.size()));
+
+  if (pending_changes_.empty())
+    SchedulePolling();
 }
 
 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_NOT_A_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_synced_changestamp_ = metadata_store_->GetLargestChangeStamp();
+  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 114 matching lines @@
   if (error != google_apis::HTTP_SUCCESS) {
     pending_batch_sync_origins_.insert(origin);
     // TODO(tzik): Refine this error code.
     NotifyTaskDone(GDataErrorCodeToSyncStatusCode(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 218 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 = GDataErrorCodeToSyncStatusCode(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);
 
   GURL origin = param->remote_change.url.origin();
   if (metadata_store_->IsIncrementalSyncOrigin(origin)) {
     int64 changestamp = param->remote_change.changestamp;
+    largest_synced_changestamp_ = changestamp;
+    DCHECK_GE(largest_fetched_changestamp_, largest_synced_changestamp_);
+
     metadata_store_->SetLargestChangeStamp(
         changestamp,
         base::Bind(&DriveFileSyncService::FinalizeRemoteSync,
                    AsWeakPtr(), base::Passed(&param)));
     return;
   }
 
   if (param->drive_metadata.conflicted())
     status = fileapi::SYNC_STATUS_HAS_CONFLICT;
   FinalizeRemoteSync(param.Pass(), status);
@@ skipping 16 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.kind() == google_apis::ENTRY_KIND_FOLDER)

[nhiroki, 2012/11/30 06:23:53]

You may want to use "entry.is_folder()".

[tzik, 2012/12/03 10:00:08]

Done.

       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(

[kinuko, 2012/11/29 11:40:46]

Well I think we definitely need to change this method name.

Maybe... at least Cancel -> Remove?

[tzik, 2012/12/03 10:00:08]

Done.

     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;
 
+  int64 changestamp = found_change->second.changestamp;
   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())) {
+    if (metadata_store_->incremental_sync_origins().empty()) {
+      largest_synced_changestamp_ = changestamp;
+      largest_fetched_changestamp_ = changestamp;
+      metadata_store_->SetLargestChangeStamp(changestamp,
+                                             base::Bind(&EmptyStatusCallback));

[kinuko, 2012/11/29 11:40:46]

Let's change this part per discussion!

[tzik, 2012/12/03 10:00:08]

Done.

+    }
+    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;
+  }
+
+  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) {
+  GURL next_feed;
+
+  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);
+  }
+
+  if (changes->GetNextFeedURL(&next_feed)) {
+    sync_client_->ContinueListing(
+        next_feed,
+        base::Bind(&DriveFileSyncService::DidFetchChangesForIncrementalSync,
+                   AsWeakPtr(), base::Passed(&token)));
+  } else {
+    largest_fetched_changestamp_ = changes->largest_changestamp();
+
+    if (changes->start_index() == 0 && changes->entries().empty()) {

[kinuko, 2012/11/29 11:47:43]

nit: can you add a comment: 'If this set of changes is the first feed and its
empty, update the polling delay to wait longer.'

[tzik, 2012/12/03 10:00:08]

Done.

+      base::TimeDelta max_delay(
+          base::TimeDelta::FromSeconds(kMaximumPollingDelaySeconds));
+
+      polling_delay_ *= kDelayMultiplier;
+      if (polling_delay_ >= max_delay)
+        polling_delay_ = max_delay;
+    } else {
+      polling_delay_ = base::TimeDelta::FromSeconds(
+          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));
+    if ((*itr)->href() != ResourceIdToResourceLink(resource_id))
+      continue;
+
+    *origin_out = origin;
+    return true;
+  }
+  return false;
+}
+
+void DriveFileSyncService::SchedulePolling() {
+  if (!polling_timer_.IsRunning())
+    polling_timer_.Start(
+        FROM_HERE, polling_delay_,
+        base::Bind(&DriveFileSyncService::FetchChangesForIncrementalSync,
+                   AsWeakPtr()));
+}
+
 }  // namespace sync_file_system