[SyncFS] Create SyncWorkerInterface

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 <vector>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 299 matching lines @@
                             worker_task_runner_,
                             file_task_runner_));
 
   worker_observer_.reset(
       new WorkerObserver(ui_task_runner_, weak_ptr_factory_.GetWeakPtr()));
 
   base::WeakPtr<ExtensionServiceInterface> extension_service_weak_ptr;
   if (extension_service_)
     extension_service_weak_ptr = extension_service_->AsWeakPtr();
 
-  sync_worker_.reset(new SyncWorker(
+  scoped_ptr<SyncWorker> worker(new SyncWorker(
       sync_file_system_dir_,
       extension_service_weak_ptr,
       sync_engine_context.Pass(),
       env_override_));
 
-  sync_worker_->AddObserver(worker_observer_.get());
+  worker->AddObserver(worker_observer_.get());
+  sync_worker_ = worker.PassAs<SyncWorkerInterface>();
+
   if (remote_change_processor_)
     SetRemoteChangeProcessor(remote_change_processor_);
 
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::Initialize,
+      base::Bind(&SyncWorkerInterface::Initialize,
                  base::Unretained(sync_worker_.get())));
 
   if (notification_manager_)
     notification_manager_->AddObserver(this);
   drive_service_->AddObserver(this);
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
 
   service_state_ = REMOTE_SERVICE_TEMPORARY_UNAVAILABLE;
   SetSyncEnabled(sync_enabled_);
   OnNetworkChanged(net::NetworkChangeNotifier::GetConnectionType());
 }
 
 void SyncEngine::AddServiceObserver(SyncServiceObserver* observer) {
   service_observers_.AddObserver(observer);
 }
 
 void SyncEngine::AddFileStatusObserver(FileStatusObserver* observer) {
   file_status_observers_.AddObserver(observer);
 }
 
 void SyncEngine::RegisterOrigin(const GURL& origin,
                                 const SyncStatusCallback& callback) {
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, base::Bind(&DidRegisterOrigin, base::TimeTicks::Now(),
                             TrackCallback(callback)));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::RegisterOrigin,
+      base::Bind(&SyncWorkerInterface::RegisterOrigin,
                  base::Unretained(sync_worker_.get()),
                  origin, relayed_callback));
 }
 
 void SyncEngine::EnableOrigin(
     const GURL& origin, const SyncStatusCallback& callback) {
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::EnableOrigin,
+      base::Bind(&SyncWorkerInterface::EnableOrigin,
                  base::Unretained(sync_worker_.get()),
                  origin, relayed_callback));
 }
 
 void SyncEngine::DisableOrigin(
     const GURL& origin, const SyncStatusCallback& callback) {
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::DisableOrigin,
+      base::Bind(&SyncWorkerInterface::DisableOrigin,
                  base::Unretained(sync_worker_.get()),
                  origin,
                  relayed_callback));
 }
 
 void SyncEngine::UninstallOrigin(
     const GURL& origin,
     UninstallFlag flag,
     const SyncStatusCallback& callback) {
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::UninstallOrigin,
+      base::Bind(&SyncWorkerInterface::UninstallOrigin,
                  base::Unretained(sync_worker_.get()),
                  origin, flag, relayed_callback));
 }
 
 void SyncEngine::ProcessRemoteChange(const SyncFileCallback& callback) {
   SyncFileCallback tracked_callback = callback_tracker_.Register(
       base::Bind(callback, SYNC_STATUS_ABORT, fileapi::FileSystemURL()),
       callback);
   SyncFileCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, tracked_callback);
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::ProcessRemoteChange,
+      base::Bind(&SyncWorkerInterface::ProcessRemoteChange,
                  base::Unretained(sync_worker_.get()),
                  relayed_callback));
 }
 
 void SyncEngine::SetRemoteChangeProcessor(RemoteChangeProcessor* processor) {
   remote_change_processor_ = processor;
   remote_change_processor_wrapper_.reset(
       new RemoteChangeProcessorWrapper(processor));
 
   remote_change_processor_on_worker_.reset(new RemoteChangeProcessorOnWorker(
       remote_change_processor_wrapper_->AsWeakPtr(),
       ui_task_runner_, worker_task_runner_));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::SetRemoteChangeProcessor,
+      base::Bind(&SyncWorkerInterface::SetRemoteChangeProcessor,
                  base::Unretained(sync_worker_.get()),
                  remote_change_processor_on_worker_.get()));
 }
 
 LocalChangeProcessor* SyncEngine::GetLocalChangeProcessor() {
   return this;
 }
 
 RemoteServiceState SyncEngine::GetCurrentState() const {
   return service_state_;
 }
 
 void SyncEngine::GetOriginStatusMap(const StatusMapCallback& callback) {
   StatusMapCallback tracked_callback =
       callback_tracker_.Register(
           base::Bind(callback, base::Passed(scoped_ptr<OriginStatusMap>())),
           callback);
 
   StatusMapCallback relayed_callback =
       RelayCallbackToCurrentThread(FROM_HERE, tracked_callback);
 
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::GetOriginStatusMap,
+      base::Bind(&SyncWorkerInterface::GetOriginStatusMap,
                  base::Unretained(sync_worker_.get()),
                  relayed_callback));
 }
 
 void SyncEngine::DumpFiles(const GURL& origin,
                            const ListCallback& callback) {
   ListCallback tracked_callback =
       callback_tracker_.Register(
           base::Bind(callback, base::Passed(scoped_ptr<base::ListValue>())),
           callback);
 
   PostTaskAndReplyWithResult(
       worker_task_runner_,
       FROM_HERE,
-      base::Bind(&SyncWorker::DumpFiles,
+      base::Bind(&SyncWorkerInterface::DumpFiles,
                  base::Unretained(sync_worker_.get()),
                  origin),
       tracked_callback);
 }
 
 void SyncEngine::DumpDatabase(const ListCallback& callback) {
   ListCallback tracked_callback =
       callback_tracker_.Register(
           base::Bind(callback, base::Passed(scoped_ptr<base::ListValue>())),
           callback);
 
   PostTaskAndReplyWithResult(
       worker_task_runner_,
       FROM_HERE,
-      base::Bind(&SyncWorker::DumpDatabase,
+      base::Bind(&SyncWorkerInterface::DumpDatabase,
                  base::Unretained(sync_worker_.get())),
       tracked_callback);
 }
 
 void SyncEngine::SetSyncEnabled(bool sync_enabled) {
   sync_enabled_ = sync_enabled;
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::SetSyncEnabled,
+      base::Bind(&SyncWorkerInterface::SetSyncEnabled,
                  base::Unretained(sync_worker_.get()),
                  sync_enabled));
 }
 
 void SyncEngine::PromoteDemotedChanges() {
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::PromoteDemotedChanges,
+      base::Bind(&SyncWorkerInterface::PromoteDemotedChanges,
                  base::Unretained(sync_worker_.get())));
 }
 
 void SyncEngine::ApplyLocalChange(
     const FileChange& local_change,
     const base::FilePath& local_path,
     const SyncFileMetadata& local_metadata,
     const fileapi::FileSystemURL& url,
     const SyncStatusCallback& callback) {
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::ApplyLocalChange,
+      base::Bind(&SyncWorkerInterface::ApplyLocalChange,
                  base::Unretained(sync_worker_.get()),
                  local_change,
                  local_path,
                  local_metadata,
                  url,
                  relayed_callback));
 }
 
 void SyncEngine::OnNotificationReceived() {
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::OnNotificationReceived,
+      base::Bind(&SyncWorkerInterface::OnNotificationReceived,
                  base::Unretained(sync_worker_.get())));
 }
 
 void SyncEngine::OnPushNotificationEnabled(bool) {}
 
 void SyncEngine::OnReadyToSendRequests() {
   // TODO(tzik): Drop current Syncworker and replace with new one.
 
   const std::string account_id =
       signin_manager_ ? signin_manager_->GetAuthenticatedAccountId() : "";
 
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::OnReadyToSendRequests,
+      base::Bind(&SyncWorkerInterface::OnReadyToSendRequests,
                  base::Unretained(sync_worker_.get()),
                  account_id));
 }
 
 void SyncEngine::OnRefreshTokenInvalid() {
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::OnRefreshTokenInvalid,
+      base::Bind(&SyncWorkerInterface::OnRefreshTokenInvalid,
                  base::Unretained(sync_worker_.get())));
 }
 
 void SyncEngine::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::OnNetworkChanged,
+      base::Bind(&SyncWorkerInterface::OnNetworkChanged,
                  base::Unretained(sync_worker_.get()),
                  type));
 }
 
 SyncEngine::SyncEngine(
     base::SingleThreadTaskRunner* ui_task_runner,
     base::SequencedTaskRunner* worker_task_runner,
     base::SequencedTaskRunner* file_task_runner,
     base::SequencedTaskRunner* drive_task_runner,
     const base::FilePath& sync_file_system_dir,
@@ skipping 48 matching lines @@
 
 SyncStatusCallback SyncEngine::TrackCallback(
     const SyncStatusCallback& callback) {
   return callback_tracker_.Register(
       base::Bind(callback, SYNC_STATUS_ABORT),
       callback);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system