[NOCOMMIT] Make DriveService{Wrapper|Messenger} class

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/memory/weak_ptr.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/drive/drive_api_service.h"
 #include "chrome/browser/drive/drive_notification_manager.h"
 #include "chrome/browser/drive/drive_notification_manager_factory.h"
 #include "chrome/browser/drive/drive_service_interface.h"
 #include "chrome/browser/drive/drive_uploader.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync_file_system/drive_backend/conflict_resolver.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
+#include "chrome/browser/sync_file_system/drive_backend/drive_service_messenger.h"
+#include "chrome/browser/sync_file_system/drive_backend/drive_service_wrapper.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_context.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_worker.h"
 #include "chrome/browser/sync_file_system/drive_backend/uninstall_app_task.h"
@@ skipping 50 matching lines @@
   drive_service->Initialize(signin_manager->GetAuthenticatedAccountId());
 
   scoped_ptr<drive::DriveUploaderInterface> drive_uploader(
       new drive::DriveUploader(drive_service.get(), drive_task_runner.get()));
 
   drive::DriveNotificationManager* notification_manager =
       drive::DriveNotificationManagerFactory::GetForBrowserContext(context);
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(context)->extension_service();
 
-  scoped_refptr<base::SequencedTaskRunner> file_task_runner(
-      worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
-          worker_pool->GetSequenceToken(),
-          base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
-
   // TODO(peria): Create another task runner to manage SyncWorker.
   scoped_refptr<base::SingleThreadTaskRunner>
       worker_task_runner = base::MessageLoopProxy::current();
 
   scoped_ptr<drive_backend::SyncEngine> sync_engine(
       new SyncEngine(drive_service.Pass(),
                      drive_uploader.Pass(),
                      worker_task_runner,
                      notification_manager,
                      extension_service,
                      signin_manager));
+
+  scoped_refptr<base::SequencedTaskRunner> file_task_runner(
+      worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
+          worker_pool->GetSequenceToken(),
+          base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
+
   sync_engine->Initialize(
       GetSyncFileSystemDir(context->GetPath()),
       file_task_runner.get(),
-      NULL);
+      false,
+      NULL /* env_override */);
 
   return sync_engine.Pass();
 }
 
 void SyncEngine::AppendDependsOnFactories(
     std::set<BrowserContextKeyedServiceFactory*>* factories) {
   DCHECK(factories);
   factories->insert(drive::DriveNotificationManagerFactory::GetInstance());
   factories->insert(SigninManagerFactory::GetInstance());
   factories->insert(
       extensions::ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
 }
 
 SyncEngine::~SyncEngine() {
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
   GetDriveService()->RemoveObserver(this);
   if (notification_manager_)
     notification_manager_->RemoveObserver(this);
 }
 
 void SyncEngine::Initialize(const base::FilePath& base_dir,

[peria, 2014/04/24 04:08:38]

It may be good to make InitializeForTesting().
In product code, |pass_service_to_worker| must be false and |env_override| must
be NULL.
And we are planning to remove |pass_service_to_worker| argument in the near
future.

                             base::SequencedTaskRunner* file_task_runner,
+                            bool pass_service_to_worker,
                             leveldb::Env* env_override) {
-  scoped_ptr<SyncEngineContext> sync_engine_context(
-      new SyncEngineContext(drive_service_.get(),
-                            drive_uploader_.get(),
-                            base::MessageLoopProxy::current(),
-                            file_task_runner));
+  scoped_ptr<SyncEngineContext> sync_engine_context;
+  if (pass_service_to_worker) {
+    sync_engine_context.reset(
+        new SyncEngineContext(drive_service_.Pass(),
+                              drive_uploader_.get(),
+                              base::MessageLoopProxy::current(),
+                              file_task_runner));
+  } else {
+    scoped_ptr<drive::DriveServiceInterface> drive_service_messenger(
+        new DriveServiceMessenger(drive_service_wrapper_->AsWeakPtr()));
+    sync_engine_context.reset(
+        new SyncEngineContext(drive_service_messenger.Pass(),
+                              drive_uploader_.get(),
+                              base::MessageLoopProxy::current(),
+                              file_task_runner));
+  }
   // TODO(peria): Use PostTask on |worker_task_runner_| to call this function.
   sync_worker_ = SyncWorker::CreateOnWorker(weak_ptr_factory_.GetWeakPtr(),
                                             base_dir,
                                             sync_engine_context.Pass(),
                                             env_override);
 
   if (notification_manager_)
     notification_manager_->AddObserver(this);
   GetDriveService()->AddObserver(this);
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
@@ skipping 208 matching lines @@
 void SyncEngine::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorker::OnNetworkChanged,
                  base::Unretained(sync_worker_.get()),
                  type));
 }
 
 drive::DriveServiceInterface* SyncEngine::GetDriveService() {
-  return drive_service_.get();
+  return sync_worker_->GetDriveService();
 }
 
 drive::DriveUploaderInterface* SyncEngine::GetDriveUploader() {
-  return drive_uploader_.get();
+  return sync_worker_->GetDriveUploader();
 }
 
 MetadataDatabase* SyncEngine::GetMetadataDatabase() {
   // TODO(peria): Post task
   return sync_worker_->GetMetadataDatabase();
 }
 
 SyncEngine::SyncEngine(
     scoped_ptr<drive::DriveServiceInterface> drive_service,
     scoped_ptr<drive::DriveUploaderInterface> drive_uploader,
     base::SequencedTaskRunner* worker_task_runner,
     drive::DriveNotificationManager* notification_manager,
     ExtensionServiceInterface* extension_service,
     SigninManagerBase* signin_manager)
     : drive_service_(drive_service.Pass()),
+      drive_service_wrapper_(new DriveServiceWrapper(drive_service_.get())),
       drive_uploader_(drive_uploader.Pass()),
       notification_manager_(notification_manager),
       extension_service_(extension_service),
       signin_manager_(signin_manager),
       worker_task_runner_(worker_task_runner),
       weak_ptr_factory_(this) {}
 
 void SyncEngine::DidProcessRemoteChange(
     sync_file_system::SyncAction sync_action,
     const fileapi::FileSystemURL& url) {
@@ skipping 75 matching lines @@
 void SyncEngine::NotifyLastOperationStatus() {
   FOR_EACH_OBSERVER(
       Observer,
       service_observers_,
       OnRemoteChangeQueueUpdated(
           GetMetadataDatabase()->CountDirtyTracker()));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system