Sync FileSystem: Mark empty batch sync origin as incremental sync origin.

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 309 matching lines @@
     const GURL& origin,
     const fileapi::SyncStatusCallback& callback) {
   scoped_ptr<TaskToken> token(GetToken(FROM_HERE, TASK_TYPE_DATABASE, ""));
   if (!token) {
     pending_tasks_.push_back(base::Bind(
         &DriveFileSyncService::UnregisterOriginForTrackingChanges,
         AsWeakPtr(), origin, callback));
     return;
   }
 
-  URLToChange::iterator found = url_to_change_.find(origin);
-  if (found != url_to_change_.end()) {
-    for (PathToChange::iterator itr = found->second.begin();
+  OriginToChangesMap::iterator found = origin_to_changes_map_.find(origin);
+  if (found != origin_to_changes_map_.end()) {
+    for (PathToChangeMap::iterator itr = found->second.begin();
          itr != found->second.end(); ++itr)
       pending_changes_.erase(itr->second.position_in_queue);
-    url_to_change_.erase(found);
+    origin_to_changes_map_.erase(found);
   }
 
   metadata_store_->RemoveOrigin(origin, base::Bind(
       &DriveFileSyncService::DidRemoveOriginOnMetadataStore,
       AsWeakPtr(), base::Passed(&token), callback));
 }
 
 void DriveFileSyncService::ProcessRemoteChange(
     RemoteChangeProcessor* processor,
     const fileapi::SyncOperationCallback& callback) {
@@ skipping 18 matching lines @@
     NotifyTaskDone(fileapi::SYNC_STATUS_OK, token.Pass());
     callback.Run(fileapi::SYNC_STATUS_NO_CHANGE_TO_SYNC,
                  fileapi::FileSystemURL(),
                  fileapi::SYNC_OPERATION_NONE);
     return;
   }
 
   const fileapi::FileSystemURL& url = pending_changes_.begin()->url;
   const GURL& origin = url.origin();
   const FilePath& path = url.path();
-  DCHECK(ContainsKey(url_to_change_, origin));
-  PathToChange* path_to_change = &url_to_change_[origin];
+  DCHECK(ContainsKey(origin_to_changes_map_, origin));
+  PathToChangeMap* path_to_change = &origin_to_changes_map_[origin];
   DCHECK(ContainsKey(*path_to_change, path));
   const RemoteChange& remote_change = (*path_to_change)[path];
 
   DVLOG(1) << "ProcessRemoteChange for " << url.DebugString()
            << " remote_change:" << remote_change.change.DebugString();
 
   scoped_ptr<ProcessRemoteChangeParam> param(new ProcessRemoteChangeParam(
       token.Pass(), processor, remote_change, callback));
   processor->PrepareForProcessRemoteChange(
       remote_change.url,
@@ skipping 494 matching lines @@
   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));
     return;
   }
 
+  if (metadata_store_->IsBatchSyncOrigin(origin) &&

[kinuko, 2013/01/07 09:28:31]

nit: can you add a brief comment like: 'Move the origin to incremental sync if
it has no changes'

[tzik, 2013/01/07 11:16:14]

Done.

+      !ContainsKey(origin_to_changes_map_, origin)) {
+    metadata_store_->MoveBatchSyncOriginToIncremental(origin);
+  }
+
   NotifyTaskDone(fileapi::SYNC_STATUS_OK, token.Pass());
 }
 
 void DriveFileSyncService::DidRemoveOriginOnMetadataStore(
     scoped_ptr<TaskToken> token,
     const fileapi::SyncStatusCallback& callback,
     fileapi::SyncStatusCode status) {
   NotifyTaskDone(status, token.Pass());
   callback.Run(status);
 }
@@ skipping 581 matching lines @@
       REMOTE_SYNC_TYPE_FETCH);
 }
 
 bool DriveFileSyncService::AppendRemoteChangeInternal(
     const GURL& origin,
     const FilePath& path,
     bool is_deleted,
     const std::string& resource_id,
     int64 changestamp,
     RemoteSyncType sync_type) {
-  PathToChange* path_to_change = &url_to_change_[origin];
-  PathToChange::iterator found = path_to_change->find(path);
+  PathToChangeMap* path_to_change = &origin_to_changes_map_[origin];
+  PathToChangeMap::iterator found = path_to_change->find(path);
   if (found != path_to_change->end()) {
     if (found->second.changestamp >= changestamp)
       return false;
     pending_changes_.erase(found->second.position_in_queue);
   }
 
   fileapi::FileSystemURL url(
       fileapi::CreateSyncableFileSystemURL(origin, kServiceName, path));
 
   fileapi::FileChange::ChangeType change_type;
@@ skipping 17 matching lines @@
            << file_change.DebugString();
 
   (*path_to_change)[path] = RemoteChange(
       changestamp, resource_id, sync_type, 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())
+  OriginToChangesMap::iterator found_origin =
+      origin_to_changes_map_.find(url.origin());
+  if (found_origin == origin_to_changes_map_.end())
     return;
 
-  PathToChange* path_to_change = &found_origin->second;
-  PathToChange::iterator found_change = path_to_change->find(url.path());
+  PathToChangeMap* path_to_change = &found_origin->second;
+  PathToChangeMap::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);
+    origin_to_changes_map_.erase(found_origin);
 
   if (metadata_store_->IsBatchSyncOrigin(url.origin()) &&
-      !ContainsKey(url_to_change_, url.origin())) {
+      !ContainsKey(origin_to_changes_map_, 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())
+  OriginToChangesMap::const_iterator found_url =
+      origin_to_changes_map_.find(url.origin());
+  if (found_url == origin_to_changes_map_.end())
     return false;
-  const PathToChange& path_to_change = found_url->second;
-  PathToChange::const_iterator found_path = path_to_change.find(url.path());
+  const PathToChangeMap& path_to_change = found_url->second;
+  PathToChangeMap::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) {
@@ skipping 123 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