[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 196 matching lines @@
 SyncEngine::~SyncEngine() {
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
   GetDriveService()->RemoveObserver(this);
   if (notification_manager_)
     notification_manager_->RemoveObserver(this);
 
   WorkerObserver* worker_observer = worker_observer_.release();
   if (!worker_task_runner_->DeleteSoon(FROM_HERE, worker_observer))
     delete worker_observer;
 
-  SyncWorker* sync_worker = sync_worker_.release();
+  SyncWorkerInterface* sync_worker = sync_worker_.release();
   if (!worker_task_runner_->DeleteSoon(FROM_HERE, sync_worker)) {
     sync_worker->DetachFromSequence();
     delete sync_worker;
   }
 }
 
 void SyncEngine::Initialize(const base::FilePath& base_dir,
                             TaskLogger* task_logger,
                             base::SequencedTaskRunner* file_task_runner,
                             leveldb::Env* env_override) {
@@ skipping 16 matching lines @@
                             file_task_runner));
 
   worker_observer_.reset(
       new WorkerObserver(base::MessageLoopProxy::current(),
                          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(
       base_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>();
   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);
   GetDriveService()->AddObserver(this);
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
 }
 
 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(),
       base::MessageLoopProxy::current(), /* 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 enabled) {
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorker::SetSyncEnabled,
+      base::Bind(&SyncWorkerInterface::SetSyncEnabled,
                  base::Unretained(sync_worker_.get()),
                  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));
 }
 
 drive::DriveServiceInterface* SyncEngine::GetDriveService() {
   return drive_service_.get();
 }
 
 drive::DriveUploaderInterface* SyncEngine::GetDriveUploader() {
   return drive_uploader_.get();
@@ skipping 84 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