Implement SyncEngine::UpdateRegisteredApps()

chrome/browser/sync_file_system/drive_backend/sync_engine.cc

 // Copyright 2013 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_backend/sync_engine.h"
 
 #include "base/bind.h"
 #include "base/values.h"
 #include "chrome/browser/drive/drive_api_service.h"
 #include "chrome/browser/drive/drive_notification_manager.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/list_changes_task.h"
 #include "chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/register_app_task.h"
 #include "chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h"
 #include "chrome/browser/sync_file_system/drive_backend/uninstall_app_task.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "chrome/browser/sync_file_system/sync_task.h"
+#include "extensions/common/extension.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
+namespace {
+
+void EmptyStatusCallback(SyncStatusCode status) {}
+
+}  // namespace
+
 SyncEngine::SyncEngine(
     const base::FilePath& base_dir,
     base::SequencedTaskRunner* task_runner,
     scoped_ptr<drive::DriveServiceInterface> drive_service,
     drive::DriveNotificationManager* notification_manager,
-    ExtensionService* extension_service)
+    ExtensionServiceInterface* extension_service)
     : base_dir_(base_dir),
       task_runner_(task_runner),
       drive_service_(drive_service.Pass()),
       notification_manager_(notification_manager),
       extension_service_(extension_service),
       remote_change_processor_(NULL),
       service_state_(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE),
       should_check_remote_change_(true),
       sync_enabled_(false),
       conflict_resolution_policy_(CONFLICT_RESOLUTION_POLICY_LAST_WRITE_WIN),
@@ skipping 240 matching lines @@
 }
 
 void SyncEngine::DoEnableApp(const std::string& app_id,
                              const SyncStatusCallback& callback) {
   metadata_database_->EnableApp(app_id, callback);
 }
 
 void SyncEngine::DidInitialize(SyncEngineInitializer* initializer,
                                SyncStatusCode status) {
   metadata_database_ = initializer->PassMetadataDatabase();
+  UpdateRegisteredApps();
 }
 
 void SyncEngine::DidProcessRemoteChange(RemoteToLocalSyncer* syncer,
                                         const SyncFileCallback& callback,
                                         SyncStatusCode status) {
   NOTIMPLEMENTED();
 }
 
 void SyncEngine::DidApplyLocalChange(LocalToRemoteSyncer* syncer,
                                      const SyncStatusCallback& callback,
@@ skipping 33 matching lines @@
     return;
 
   util::Log(logging::LOG_INFO, FROM_HERE,
             "Service state changed: %d->%d: %s",
             old_state, GetCurrentState(), description.c_str());
   FOR_EACH_OBSERVER(
       Observer, service_observers_,
       OnRemoteServiceStateUpdated(GetCurrentState(), description));
 }
 
+void SyncEngine::UpdateRegisteredApps() {
+  if (!extension_service_)
+    return;
+
+  std::vector<std::string> app_ids;
+  metadata_database_->GetRegisteredAppIDs(&app_ids);
+
+  // Update the status of every origin using status from ExtensionService.
+  for (std::vector<std::string>::const_iterator itr = app_ids.begin();
+       itr != app_ids.end(); ++itr) {
+    const std::string& app_id = *itr;
+    GURL origin =
+        extensions::Extension::GetBaseURLFromExtensionId(app_id);
+    if (!extension_service_->GetInstalledExtension(app_id)) {
+      // Extension has been uninstalled.
+      // (At this stage we can't know if it was unpacked extension or not,
+      // so just purge the remote folder.)
+      UninstallOrigin(origin,
+                      RemoteFileSyncService::UNINSTALL_AND_PURGE_REMOTE,
+                      base::Bind(&EmptyStatusCallback));
+      continue;
+    }
+    FileTracker tracker;
+    if (!metadata_database_->FindAppRootTracker(app_id, &tracker)) {
+      // App will register itself on first run.
+      return;

[nhiroki, 2013/11/18 09:09:52]

Probably we need to do "continue" here.

[keishi, 2013/11/18 09:15:32]

Done.

+    }
+    bool is_app_enabled = extension_service_->IsExtensionEnabled(app_id);
+    bool is_app_root_tracker_enabled =
+        tracker.tracker_kind() == TRACKER_KIND_APP_ROOT;
+    if (is_app_enabled && !is_app_root_tracker_enabled)
+      EnableOrigin(origin, base::Bind(&EmptyStatusCallback));
+    else if (!is_app_enabled && is_app_root_tracker_enabled)
+      DisableOrigin(origin, base::Bind(&EmptyStatusCallback));
+  }
+}
+
 }  // namespace drive_backend
 }  // namespace sync_file_system