Add to be fetched files instead of DriveMetadataStore.batch_sync_origins_

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 <string>
 #include <utility>
 
@@ skipping 416 matching lines @@
     callback.Run(status);
     return;
   }
 
   DCHECK(pending_batch_sync_origins_.empty());
 
   UpdateRegisteredOrigins();
 
   largest_fetched_changestamp_ = metadata_store_->GetLargestChangeStamp();
 
-  // Mark all the batch sync origins as 'pending' so that we can start
-  // batch sync when we're ready.
-  for (std::map<GURL, std::string>::const_iterator itr =
-           metadata_store_->batch_sync_origins().begin();
-       itr != metadata_store_->batch_sync_origins().end();
-       ++itr) {
-    pending_batch_sync_origins_.insert(itr->first);
-  }
-
   DriveMetadataStore::URLAndDriveMetadataList to_be_fetched_files;
   status = metadata_store_->GetToBeFetchedFiles(&to_be_fetched_files);
   DCHECK_EQ(SYNC_STATUS_OK, status);
   typedef DriveMetadataStore::URLAndDriveMetadataList::const_iterator iterator;
   for (iterator itr = to_be_fetched_files.begin();
        itr != to_be_fetched_files.end(); ++itr) {
     const FileSystemURL& url = itr->first;
     const DriveMetadata& metadata = itr->second;
     const std::string& resource_id = metadata.resource_id();
 
@@ skipping 247 matching lines @@
       // Extension has been re-enabled.
       metadata_store_->EnableOrigin(origin, base::Bind(&EmptyStatusCallback));
       pending_batch_sync_origins_.insert(origin);
     }
   }
 }
 
 void DriveFileSyncService::StartBatchSync(
     const SyncStatusCallback& callback) {
   DCHECK(GetCurrentState() == REMOTE_SERVICE_OK || may_have_unfetched_changes_);
-
-  if (pending_batch_sync_origins_.empty()) {
-    callback.Run(SYNC_STATUS_OK);
-    return;
-  }
+  DCHECK(!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);
   DCHECK(!resource_id.empty());
 
   DCHECK(!metadata_store_->IsOriginDisabled(origin));
 
   DVLOG(1) << "Start batch sync for:" << origin.spec();
 
@@ skipping 22 matching lines @@
             AsWeakPtr(), origin, callback));
     return;
   }
 
   if (status != SYNC_STATUS_OK) {
     callback.Run(status);
     return;
   }
 
   // Add this origin to batch sync origin if it hasn't been already.
+  // TODO(calvinlo): Added files to file metadata mapping, this can be removed
+  // next when batch_sync_origins is removed from DriveMetadataStore.
   if (!metadata_store_->IsKnownOrigin(origin)) {
     metadata_store_->AddBatchSyncOrigin(origin, resource_id);

[tzik, 2013/05/16 12:11:34]

could you move this around line 845?
I want register the origin as a incremental sync origin from first.

[calvinlo, 2013/05/17 04:40:58]

Done. As discussed, in order to facilitate this change I have updated
pending_batch_sync_origins_ to be a map so it can also hold the resource_id.

     pending_batch_sync_origins_.insert(origin);
   }
 
   callback.Run(SYNC_STATUS_OK);
 }
 
 void DriveFileSyncService::DidUninstallOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error) {
@@ skipping 44 matching lines @@
     scoped_ptr<google_apis::ResourceList> feed) {
   if (error != google_apis::HTTP_SUCCESS) {
     pending_batch_sync_origins_.insert(origin);
     callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
     return;
   }
 
   typedef ScopedVector<google_apis::ResourceEntry>::const_iterator iterator;
   for (iterator itr = feed->entries().begin();
        itr != feed->entries().end(); ++itr) {
-    AppendRemoteChange(origin, **itr, largest_changestamp,
+    const google_apis::ResourceEntry& entry = **itr;
+    AppendRemoteChange(origin, entry, largest_changestamp,
                        RemoteChangeHandler::REMOTE_SYNC_TYPE_BATCH);
+
+    // Save to be fetched file to DB for restore in case of crash.
+    DriveMetadata metadata;
+    metadata.set_resource_id(entry.resource_id());
+    metadata.set_md5_checksum(entry.file_md5());
+    metadata.set_conflicted(false);
+    metadata.set_to_be_fetched(true);
+
+    base::FilePath path = TitleToPath(entry.title());
+    fileapi::FileSystemURL url(CreateSyncableFileSystemURL(
+        origin, kServiceName, path));
+    metadata_store_->UpdateEntry(url, metadata,
+                                 base::Bind(&EmptyStatusCallback));
   }
 
   GURL next_feed_url;
   if (feed->GetNextFeedURL(&next_feed_url)) {
     api_util_->ContinueListing(
         next_feed_url,
         base::Bind(&DriveFileSyncService::DidGetDirectoryContentForBatchSync,
                    AsWeakPtr(),
                    callback,
                    origin,
                    largest_changestamp));
     return;
   }
 
   // Move |origin| to the incremental sync origin set if the origin has no file.
   if (metadata_store_->IsBatchSyncOrigin(origin) &&
       !remote_change_handler_.HasChangesForOrigin(origin)) {
     metadata_store_->MoveBatchSyncOriginToIncremental(origin);

[tzik, 2013/05/16 12:11:34]

could you do this unconditionally?

[calvinlo, 2013/05/17 04:40:58]

Done.

   }
 
   may_have_unfetched_changes_ = true;
   callback.Run(SYNC_STATUS_OK);
 }
 
 void DriveFileSyncService::ApplyLocalChangeInternal(
     scoped_ptr<ApplyLocalChangeParam> param,
     SyncStatusCode status,
     const std::string& origin_resource_id) {
@@ skipping 1083 matching lines @@
     return SYNC_STATUS_AUTHENTICATION_FAILED;
   return status;
 }
 
 void DriveFileSyncService::MaybeStartFetchChanges() {
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED)
     return;
 
   // If we have pending_batch_sync_origins, try starting the batch sync.
   if (!pending_batch_sync_origins_.empty()) {
-    if (GetCurrentState() == REMOTE_SERVICE_OK || may_have_unfetched_changes_) {
-      task_manager_->ScheduleTaskIfIdle(
-          base::Bind(&DriveFileSyncService::StartBatchSync, AsWeakPtr()));
-    }
-    return;
+    if (GetCurrentState() != REMOTE_SERVICE_OK && !may_have_unfetched_changes_)
+      return;
+
+    task_manager_->ScheduleTaskIfIdle(
+        base::Bind(&DriveFileSyncService::StartBatchSync, AsWeakPtr()));
   }
 
   if (may_have_unfetched_changes_ &&
       !metadata_store_->incremental_sync_origins().empty()) {
     task_manager_->ScheduleTaskIfIdle(
         base::Bind(&DriveFileSyncService::FetchChangesForIncrementalSync,
                    AsWeakPtr()));
   }
 }
 
@@ skipping 218 matching lines @@
       pending_batch_sync_origins_.insert(origin);
   }
   callback.Run(status, resource_id);
 }
 
 std::string DriveFileSyncService::sync_root_resource_id() {
   return metadata_store_->sync_root_directory();
 }
 
 }  // namespace sync_file_system