[SyncFS] Migrate SyncWorker::Observer to SyncWorkerInterface

chrome/browser/sync_file_system/drive_backend/sync_worker.cc

 // Copyright 2014 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_worker.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "chrome/browser/drive/drive_service_interface.h"
@@ skipping 18 matching lines @@
 namespace sync_file_system {
 
 class RemoteChangeProcessor;
 
 namespace drive_backend {
 
 namespace {
 
 void EmptyStatusCallback(SyncStatusCode status) {}
 
-void QueryAppStatusOnUIThread(
-    const base::WeakPtr<ExtensionServiceInterface>& extension_service_ptr,
-    const std::vector<std::string>* app_ids,
-    SyncWorker::AppStatusMap* status,
-    const base::Closure& callback) {
-  ExtensionServiceInterface* extension_service = extension_service_ptr.get();
-  if (!extension_service) {
-    callback.Run();
-    return;
-  }
-
-  for (std::vector<std::string>::const_iterator itr = app_ids->begin();
-       itr != app_ids->end(); ++itr) {
-    const std::string& app_id = *itr;
-    if (!extension_service->GetInstalledExtension(app_id))
-      (*status)[app_id] = SyncWorker::APP_STATUS_UNINSTALLED;
-    else if (!extension_service->IsExtensionEnabled(app_id))
-      (*status)[app_id] = SyncWorker::APP_STATUS_DISABLED;
-    else
-      (*status)[app_id] = SyncWorker::APP_STATUS_ENABLED;
-  }
-
-  callback.Run();
-}
-
 }  // namespace
 
 SyncWorker::SyncWorker(
     const base::FilePath& base_dir,
     const base::WeakPtr<ExtensionServiceInterface>& extension_service,
     scoped_ptr<SyncEngineContext> sync_engine_context,
     leveldb::Env* env_override)
     : base_dir_(base_dir),
       env_override_(env_override),
       service_state_(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE),
       should_check_conflict_(true),
       should_check_remote_change_(true),
       listing_remote_changes_(false),
       sync_enabled_(false),
       default_conflict_resolution_policy_(
           CONFLICT_RESOLUTION_POLICY_LAST_WRITE_WIN),
       network_available_(false),
       extension_service_(extension_service),
       context_(sync_engine_context.Pass()),
       has_refresh_token_(false),
       weak_ptr_factory_(this) {
   sequence_checker_.DetachFromSequence();
   DCHECK(base_dir_.IsAbsolute());
 }
 
-SyncWorker::~SyncWorker() {}
+SyncWorker::~SyncWorker() {
+  observers_.Clear();
+}
 
 void SyncWorker::Initialize() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!task_manager_);
 
   task_manager_.reset(new SyncTaskManager(
       weak_ptr_factory_.GetWeakPtr(), 0 /* maximum_background_task */));
   task_manager_->Initialize(SYNC_STATUS_OK);
 
   PostInitializeTask();
@@ skipping 391 matching lines @@
   metadata_db->GetRegisteredAppIDs(app_ids.get());
 
   AppStatusMap* app_status = new AppStatusMap;
   base::Closure callback =
       base::Bind(&SyncWorker::DidQueryAppStatus,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(app_status));
 
   context_->GetUITaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&QueryAppStatusOnUIThread,
+      base::Bind(&SyncWorker::QueryAppStatusOnUIThread,
                  extension_service_,
                  base::Owned(app_ids.release()),
                  app_status,
                  RelayCallbackToTaskRunner(
                      context_->GetWorkerTaskRunner(),
                      FROM_HERE, callback)));
 }
 
+void SyncWorker::QueryAppStatusOnUIThread(
+    const base::WeakPtr<ExtensionServiceInterface>& extension_service_ptr,
+    const std::vector<std::string>* app_ids,
+    AppStatusMap* status,
+    const base::Closure& callback) {
+  ExtensionServiceInterface* extension_service = extension_service_ptr.get();
+  if (!extension_service) {
+    callback.Run();
+    return;
+  }
+
+  for (std::vector<std::string>::const_iterator itr = app_ids->begin();
+       itr != app_ids->end(); ++itr) {
+    const std::string& app_id = *itr;
+    if (!extension_service->GetInstalledExtension(app_id))
+      (*status)[app_id] = APP_STATUS_UNINSTALLED;
+    else if (!extension_service->IsExtensionEnabled(app_id))
+      (*status)[app_id] = APP_STATUS_DISABLED;
+    else
+      (*status)[app_id] = APP_STATUS_ENABLED;
+  }
+
+  callback.Run();
+}
+
 void SyncWorker::DidQueryAppStatus(const AppStatusMap* app_status) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   MetadataDatabase* metadata_db = GetMetadataDatabase();
   DCHECK(metadata_db);
 
   // Update the status of every origin using status from ExtensionService.
   for (AppStatusMap::const_iterator itr = app_status->begin();
        itr != app_status->end(); ++itr) {
     const std::string& app_id = itr->first;
@@ skipping 223 matching lines @@
             "Service state changed: %d->%d: %s",
             old_state, GetCurrentState(), description.c_str());
 
   FOR_EACH_OBSERVER(
       Observer, observers_,
       UpdateServiceState(GetCurrentState(), description));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system