SyncFS: store disabled origins in DriveMetadataStore

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 404 matching lines @@
   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);
     origin_to_changes_map_.erase(found);
   }
   pending_batch_sync_origins_.erase(origin);
 
   metadata_store_->RemoveOrigin(origin, base::Bind(
-      &DriveFileSyncService::DidRemoveOriginOnMetadataStore,
+      &DriveFileSyncService::DidChangeOriginOnMetadataStore,
       AsWeakPtr(), base::Passed(&token), callback));
 }
 
+void DriveFileSyncService::EnableOriginForTrackingChanges(
+    const GURL& origin,
+    const SyncStatusCallback& callback) {
+  if (!metadata_store_->IsOriginDisabled(origin))
+    return;
+
+  scoped_ptr<TaskToken> token(GetToken(FROM_HERE, TASK_TYPE_DATABASE, ""));
+  if (!token) {
+    pending_tasks_.push_back(base::Bind(
+        &DriveFileSyncService::EnableOriginForTrackingChanges,
+        AsWeakPtr(), origin, callback));
+    return;
+  }
+
+  metadata_store_->EnableOrigin(origin, base::Bind(
+      &DriveFileSyncService::DidChangeOriginOnMetadataStore,
+      AsWeakPtr(), base::Passed(&token), callback));
+  pending_batch_sync_origins_.insert(origin);
+}
+
+void DriveFileSyncService::DisableOriginForTrackingChanges(
+    const GURL& origin,
+    const SyncStatusCallback& callback) {
+  if (!metadata_store_->IsBatchSyncOrigin(origin) &&
+      !metadata_store_->IsIncrementalSyncOrigin(origin))
+    return;
+
+  scoped_ptr<TaskToken> token(GetToken(FROM_HERE, TASK_TYPE_DATABASE, ""));
+  if (!token) {
+    pending_tasks_.push_back(base::Bind(
+        &DriveFileSyncService::DisableOriginForTrackingChanges,
+        AsWeakPtr(), origin, callback));
+    return;
+  }
+
+  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);
+    origin_to_changes_map_.erase(found);
+  }

[kinuko, 2013/03/19 04:01:49]

nit: it may look nicer if we define a sub method (like
ForgetRemoteChangesForOrigin) to do this and call the method here and in
UnregsterOriginForTrackingChanges.

[nhiroki, 2013/03/19 09:36:13]

Added TODO comment.

+  pending_batch_sync_origins_.erase(origin);
+
+  metadata_store_->DisableOrigin(origin, base::Bind(
+      &DriveFileSyncService::DidChangeOriginOnMetadataStore,
+      AsWeakPtr(), base::Passed(&token), callback));
+}
+
 void DriveFileSyncService::DeleteOriginDirectory(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   scoped_ptr<TaskToken> token(GetToken(
       FROM_HERE, TASK_TYPE_DATABASE, "Delete Origin Directory"));
   if (!token) {
     pending_tasks_.push_back(base::Bind(
         &DriveFileSyncService::DeleteOriginDirectory,
         AsWeakPtr(), origin, callback));
     return;
@@ skipping 409 matching lines @@
 
 void DriveFileSyncService::DidInitializeMetadataStore(
     scoped_ptr<TaskToken> token,
     SyncStatusCode status,
     bool created) {
   if (status != SYNC_STATUS_OK) {
     NotifyTaskDone(status, token.Pass());
     return;
   }
 
-  // Remove any origins that are not installed or enabled.
-  UnregisterInactiveExtensionsIds();
+  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.
   DCHECK(pending_batch_sync_origins_.empty());
   for (std::map<GURL, std::string>::const_iterator itr =
           metadata_store_->batch_sync_origins().begin();
         itr != metadata_store_->batch_sync_origins().end();
         ++itr) {
@@ skipping 11 matching lines @@
     const std::string& resource_id = itr->second;
     AppendFetchChange(url.origin(), url.path(), resource_id);
   }
 
   // It's ok to fail, so we pass EmptyResourceIdCallback here.
   GetSyncRootDirectory(token.Pass(), base::Bind(&EmptyResourceIdCallback));
 
   RegisterDriveNotifications();
 }
 
-void DriveFileSyncService::UnregisterInactiveExtensionsIds() {
+void DriveFileSyncService::UpdateRegisteredOrigins() {
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   if (!extension_service)
     return;
-  std::vector<GURL> tracked_origins;
-  metadata_store_->GetAllOrigins(&tracked_origins);
 
-  for (std::vector<GURL>::const_iterator itr = tracked_origins.begin();
-       itr != tracked_origins.end();
-       ++itr) {
-    // Make sure the registered extension is installed and enabled.
+  // TODO(nhiroki): clean up these loops with similar bodies.
+  // http://crbug.com/211600
+
+  std::vector<GURL> disabled_origins;
+  metadata_store_->GetDisabledOrigins(&disabled_origins);
+  for (std::vector<GURL>::const_iterator itr = disabled_origins.begin();
+       itr != disabled_origins.end(); ++itr) {
     std::string extension_id = itr->host();
-    const extensions::Extension* installed_extension =
-        extension_service->GetExtensionById(extension_id,
-                                            false /* include_disabled */);
-    if (installed_extension != NULL)
+    GURL origin =
+        extensions::Extension::GetBaseURLFromExtensionId(extension_id);
+
+    if (extension_service->GetInstalledExtension(extension_id) == NULL) {
+      // Extension is uninstalled. Unregister origin.
+      metadata_store_->RemoveOrigin(
+          origin, base::Bind(&DidRemoveOrigin, origin));
       continue;
+    }
 
-    // Extension is either disabled or uninstalled. Unregister origin.
-    GURL origin = extensions::Extension::GetBaseURLFromExtensionId(
-        extension_id);
-    metadata_store_->RemoveOrigin(origin, base::Bind(&DidRemoveOrigin, origin));
+    if (extension_service->IsExtensionEnabled(extension_id)) {
+      // Extension is enabled. Enable origin.
+      metadata_store_->EnableOrigin(
+          origin, base::Bind(&EmptyStatusCallback));
+      pending_batch_sync_origins_.insert(origin);
+      continue;
+    }
+
+    // Extension is still disabled.
+  }
+
+  std::vector<GURL> enabled_origins;
+  metadata_store_->GetEnabledOrigins(&enabled_origins);
+  for (std::vector<GURL>::const_iterator itr = enabled_origins.begin();
+       itr != enabled_origins.end(); ++itr) {
+    std::string extension_id = itr->host();
+    GURL origin =
+        extensions::Extension::GetBaseURLFromExtensionId(extension_id);
+
+    if (extension_service->GetInstalledExtension(extension_id) == NULL) {
+      // Extension is uninstalled. Unregister origin.
+      metadata_store_->RemoveOrigin(
+          origin, base::Bind(&DidRemoveOrigin, origin));
+      continue;
+    }
+
+    if (!extension_service->IsExtensionEnabled(extension_id)) {
+      // Extension is disabled. Disable origin.
+      metadata_store_->DisableOrigin(
+          origin, base::Bind(&EmptyStatusCallback));
+      continue;
+    }
+
+    // Extension is still enabled.
   }
 }
 
 void DriveFileSyncService::GetSyncRootDirectory(
     scoped_ptr<TaskToken> token,
     const ResourceIdCallback& callback) {
   token->UpdateTask(FROM_HERE, TASK_TYPE_DRIVE, "Retrieving drive root");
   sync_client_->GetDriveDirectoryForSyncRoot(
       base::Bind(&DriveFileSyncService::DidGetSyncRootDirectory,
                  AsWeakPtr(), base::Passed(&token), callback));
@@ skipping 35 matching lines @@
   GetDriveDirectoryForOrigin(origin, callback, sync_root_resource_id);
 }
 
 void DriveFileSyncService::StartBatchSyncForOrigin(
     const GURL& origin,
     const std::string& resource_id) {
   scoped_ptr<TaskToken> token(
       GetToken(FROM_HERE, TASK_TYPE_DRIVE, "Retrieving largest changestamp"));
   DCHECK(token);
   DCHECK(GetCurrentState() == REMOTE_SERVICE_OK || may_have_unfetched_changes_);
+  DCHECK(!metadata_store_->IsOriginDisabled(origin));
 
   DVLOG(1) << "Start batch sync for:" << origin.spec();
 
   sync_client_->GetLargestChangeStamp(
       base::Bind(&DriveFileSyncService::DidGetLargestChangeStampForBatchSync,
                  AsWeakPtr(), base::Passed(&token), origin, resource_id));
 
   may_have_unfetched_changes_ = false;
 }
 
 void DriveFileSyncService::GetDriveDirectoryForOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback,
     const std::string& sync_root_resource_id) {
   scoped_ptr<TaskToken> token(GetToken(
       FROM_HERE, TASK_TYPE_DRIVE, "Retrieving origin metadata"));
   if (!token) {
     pending_tasks_.push_back(base::Bind(
         &DriveFileSyncService::GetDriveDirectoryForOrigin,
         AsWeakPtr(), origin, callback, sync_root_resource_id));
     return;
   }
 
   if (metadata_store_->IsIncrementalSyncOrigin(origin) ||
-      metadata_store_->IsBatchSyncOrigin(origin)) {
+      metadata_store_->IsBatchSyncOrigin(origin) ||
+      metadata_store_->IsOriginDisabled(origin)) {
     token->ResetTask(FROM_HERE);
     NotifyTaskDone(SYNC_STATUS_OK, token.Pass());
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   DCHECK(!sync_root_resource_id.empty());
   sync_client_->GetDriveDirectoryForOrigin(
       sync_root_resource_id, origin,
       base::Bind(&DriveFileSyncService::DidGetDriveDirectoryForOrigin,
@@ skipping 100 matching lines @@
   // (indicates that we may have longer polling cycle), trigger the first
   // incremental sync on next task cycle.
   if (pending_batch_sync_origins_.empty() &&
       push_notification_enabled_) {
     may_have_unfetched_changes_ = true;
   }
 
   NotifyTaskDone(SYNC_STATUS_OK, token.Pass());
 }
 
-void DriveFileSyncService::DidRemoveOriginOnMetadataStore(
+void DriveFileSyncService::DidChangeOriginOnMetadataStore(
     scoped_ptr<TaskToken> token,
     const SyncStatusCallback& callback,
     SyncStatusCode status) {
   NotifyTaskDone(status, token.Pass());
   callback.Run(status);
 }
 
 void DriveFileSyncService::DidGetRemoteFileMetadata(
     const SyncFileMetadataCallback& callback,
     google_apis::GDataErrorCode error,
@@ skipping 1155 matching lines @@
     DCHECK_EQ(SYNC_ACTION_NONE, action_taken);
     DCHECK_EQ(SYNC_DIRECTION_NONE, direction);
   }
 
   FOR_EACH_OBSERVER(
       FileStatusObserver, file_status_observers_,
       OnFileStatusChanged(url, sync_status, action_taken, direction));
 }
 
 }  // namespace sync_file_system