Remove implicit conversions from scoped_refptr to T* in chrome/browser/sync_file_system/

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 198 matching lines @@
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(context)->extension_service();
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile);
   OAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   scoped_refptr<net::URLRequestContextGetter> request_context =
       context->GetRequestContext();
 
   scoped_ptr<drive_backend::SyncEngine> sync_engine(
-      new SyncEngine(ui_task_runner,
-                     worker_task_runner,
-                     drive_task_runner,
+      new SyncEngine(ui_task_runner.get(),
+                     worker_task_runner.get(),
+                     drive_task_runner.get(),
                      GetSyncFileSystemDir(context->GetPath()),
                      task_logger,
                      notification_manager,
                      extension_service,
                      signin_manager,
                      token_service,
-                     request_context,
+                     request_context.get(),
                      make_scoped_ptr(new DriveServiceFactory()),
-                     NULL  /* env_override */));
+                     NULL /* env_override */));
 
   sync_engine->Initialize();
   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());
   factories->insert(ProfileOAuth2TokenServiceFactory::GetInstance());
 }
 
 SyncEngine::~SyncEngine() {
   Reset();
 
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
   if (signin_manager_)
     signin_manager_->RemoveObserver(this);
   if (notification_manager_)
     notification_manager_->RemoveObserver(this);
 }
 
 void SyncEngine::Reset() {
   if (drive_service_)
     drive_service_->RemoveObserver(this);
 
-  DeleteSoon(FROM_HERE, worker_task_runner_, sync_worker_.Pass());
-  DeleteSoon(FROM_HERE, worker_task_runner_, worker_observer_.Pass());
-  DeleteSoon(FROM_HERE, worker_task_runner_,
+  DeleteSoon(FROM_HERE, worker_task_runner_.get(), sync_worker_.Pass());
+  DeleteSoon(FROM_HERE, worker_task_runner_.get(), worker_observer_.Pass());
+  DeleteSoon(FROM_HERE,
+             worker_task_runner_.get(),
              remote_change_processor_on_worker_.Pass());
 
   drive_service_wrapper_.reset();
   drive_service_.reset();
   drive_uploader_wrapper_.reset();
   drive_uploader_.reset();
   remote_change_processor_wrapper_.reset();
   callback_tracker_.AbortAll();
 }
 
 void SyncEngine::Initialize() {
   Reset();
 
   if (!signin_manager_ ||
       signin_manager_->GetAuthenticatedAccountId().empty())
     return;
 
   DCHECK(drive_service_factory_);
   scoped_ptr<drive::DriveServiceInterface> drive_service =
       drive_service_factory_->CreateDriveService(
-          token_service_, request_context_, drive_task_runner_);
+          token_service_, request_context_.get(), drive_task_runner_.get());
   scoped_ptr<drive::DriveUploaderInterface> drive_uploader(
-      new drive::DriveUploader(drive_service.get(), drive_task_runner_));
+      new drive::DriveUploader(drive_service.get(), drive_task_runner_.get()));
 
   InitializeInternal(drive_service.Pass(), drive_uploader.Pass(),
                      scoped_ptr<SyncWorkerInterface>());
 }
 
 void SyncEngine::InitializeForTesting(
     scoped_ptr<drive::DriveServiceInterface> drive_service,
     scoped_ptr<drive::DriveUploaderInterface> drive_uploader,
     scoped_ptr<SyncWorkerInterface> sync_worker) {
   Reset();
@@ skipping 14 matching lines @@
   drive_service_->Initialize(account_id);
 
   drive_uploader_ = drive_uploader.Pass();
   drive_uploader_wrapper_.reset(
       new DriveUploaderWrapper(drive_uploader_.get()));
 
   // DriveServiceWrapper and DriveServiceOnWorker relay communications
   // between DriveService and syncers in SyncWorker.
   scoped_ptr<drive::DriveServiceInterface> drive_service_on_worker(
       new DriveServiceOnWorker(drive_service_wrapper_->AsWeakPtr(),
-                               ui_task_runner_,
-                               worker_task_runner_));
+                               ui_task_runner_.get(),
+                               worker_task_runner_.get()));
   scoped_ptr<drive::DriveUploaderInterface> drive_uploader_on_worker(
       new DriveUploaderOnWorker(drive_uploader_wrapper_->AsWeakPtr(),
-                                ui_task_runner_,
-                                worker_task_runner_));
+                                ui_task_runner_.get(),
+                                worker_task_runner_.get()));
   scoped_ptr<SyncEngineContext> sync_engine_context(
       new SyncEngineContext(drive_service_on_worker.Pass(),
                             drive_uploader_on_worker.Pass(),
                             task_logger_,
-                            ui_task_runner_,
-                            worker_task_runner_));
+                            ui_task_runner_.get(),
+                            worker_task_runner_.get()));
 
-  worker_observer_.reset(
-      new WorkerObserver(ui_task_runner_, weak_ptr_factory_.GetWeakPtr()));
+  worker_observer_.reset(new WorkerObserver(ui_task_runner_.get(),
+                                            weak_ptr_factory_.GetWeakPtr()));
 
   base::WeakPtr<ExtensionServiceInterface> extension_service_weak_ptr;
   if (extension_service_)
     extension_service_weak_ptr = extension_service_->AsWeakPtr();
 
   if (!sync_worker) {
     sync_worker.reset(new SyncWorker(
         sync_file_system_dir_,
         extension_service_weak_ptr,
         env_override_));
@@ skipping 141 matching lines @@
   remote_change_processor_ = processor;
 
   if (!sync_worker_)
     return;
 
   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_));
+      ui_task_runner_.get(),
+      worker_task_runner_.get()));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::SetRemoteChangeProcessor,
                  base::Unretained(sync_worker_.get()),
                  remote_change_processor_on_worker_.get()));
 }
 
 LocalChangeProcessor* SyncEngine::GetLocalChangeProcessor() {
   return this;
@@ skipping 34 matching lines @@
       base::Bind(callback, base::Passed(scoped_ptr<base::ListValue>()));
 
   if (!sync_worker_) {
     abort_closure.Run();
     return;
   }
 
   ListCallback tracked_callback =
       callback_tracker_.Register(abort_closure, callback);
 
-  PostTaskAndReplyWithResult(
-      worker_task_runner_,
-      FROM_HERE,
-      base::Bind(&SyncWorkerInterface::DumpFiles,
-                 base::Unretained(sync_worker_.get()),
-                 origin),
-      tracked_callback);
+  PostTaskAndReplyWithResult(worker_task_runner_.get(),
+                             FROM_HERE,
+                             base::Bind(&SyncWorkerInterface::DumpFiles,
+                                        base::Unretained(sync_worker_.get()),
+                                        origin),
+                             tracked_callback);
 }
 
 void SyncEngine::DumpDatabase(const ListCallback& callback) {
   base::Closure abort_closure =
       base::Bind(callback, base::Passed(scoped_ptr<base::ListValue>()));
 
   if (!sync_worker_) {
     abort_closure.Run();
     return;
   }
 
   ListCallback tracked_callback =
       callback_tracker_.Register(abort_closure, callback);
 
-  PostTaskAndReplyWithResult(
-      worker_task_runner_,
-      FROM_HERE,
-      base::Bind(&SyncWorkerInterface::DumpDatabase,
-                 base::Unretained(sync_worker_.get())),
-      tracked_callback);
+  PostTaskAndReplyWithResult(worker_task_runner_.get(),
+                             FROM_HERE,
+                             base::Bind(&SyncWorkerInterface::DumpDatabase,
+                                        base::Unretained(sync_worker_.get())),
+                             tracked_callback);
 }
 
 void SyncEngine::SetSyncEnabled(bool sync_enabled) {
   sync_enabled_ = sync_enabled;
 
   if (!sync_worker_)
     return;
 
   worker_task_runner_->PostTask(
       FROM_HERE,
@@ skipping 194 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