Suppress sequence checks in SyncFileSystem on the shutdown phase

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 146 matching lines @@
 namespace {
 
 void DidRegisterOrigin(const base::TimeTicks& start_time,
                        const SyncStatusCallback& callback,
                        SyncStatusCode status) {
   base::TimeDelta delta(base::TimeTicks::Now() - start_time);
   LOCAL_HISTOGRAM_TIMES("SyncFileSystem.RegisterOriginTime", delta);
   callback.Run(status);
 }
 
-template <typename T>
-void DeleteSoonHelper(scoped_ptr<T>) {}
-
-template <typename T>
-void DeleteSoon(const tracked_objects::Location& from_here,
-                base::TaskRunner* task_runner,
-                scoped_ptr<T> obj) {
-  if (!obj)
-    return;
-
-  T* obj_ptr = obj.get();
-  base::Closure deleter =
-      base::Bind(&DeleteSoonHelper<T>, base::Passed(&obj));
-  if (!task_runner->PostTask(from_here, deleter)) {
-    obj_ptr->DetachFromSequence();
-    deleter.Run();
-  }
-}
-
 }  // namespace
 
 scoped_ptr<SyncEngine> SyncEngine::CreateForBrowserContext(
     content::BrowserContext* context,
     TaskLogger* task_logger) {
   scoped_refptr<base::SequencedWorkerPool> worker_pool =
       content::BrowserThread::GetBlockingPool();
 
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner =
       base::ThreadTaskRunnerHandle::Get();
@@ skipping 15 matching lines @@
       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.get(),
                      worker_task_runner.get(),
                      drive_task_runner.get(),
+                     worker_pool.get(),
                      GetSyncFileSystemDir(context->GetPath()),
                      task_logger,
                      notification_manager,
                      extension_service,
                      signin_manager,
                      token_service,
                      request_context.get(),
                      make_scoped_ptr(new DriveServiceFactory()),
                      nullptr /* env_override */));
 
@@ skipping 18 matching lines @@
   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_.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());
+  worker_task_runner_->DeleteSoon(FROM_HERE, sync_worker_.release());
+  worker_task_runner_->DeleteSoon(FROM_HERE, worker_observer_.release());
+  worker_task_runner_->DeleteSoon(FROM_HERE,
+                                  remote_change_processor_on_worker_.release());
 
   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() {
@@ skipping 45 matching lines @@
                                worker_task_runner_.get()));
   scoped_ptr<drive::DriveUploaderInterface> drive_uploader_on_worker(
       new DriveUploaderOnWorker(drive_uploader_wrapper_->AsWeakPtr(),
                                 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_.get(),
-                            worker_task_runner_.get()));
+                            worker_task_runner_.get(),
+                            worker_pool_.get()));
 
   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(
@@ skipping 389 matching lines @@
                                  const std::string& username) {
   Reset();
   UpdateServiceState(REMOTE_SERVICE_AUTHENTICATION_REQUIRED,
                      "User signed out.");
 }
 
 SyncEngine::SyncEngine(
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& drive_task_runner,
+    const scoped_refptr<base::SequencedWorkerPool>& worker_pool,
     const base::FilePath& sync_file_system_dir,
     TaskLogger* task_logger,
     drive::DriveNotificationManager* notification_manager,
     ExtensionServiceInterface* extension_service,
     SigninManagerBase* signin_manager,
     OAuth2TokenService* token_service,
     net::URLRequestContextGetter* request_context,
     scoped_ptr<DriveServiceFactory> drive_service_factory,
     leveldb::Env* env_override)
     : ui_task_runner_(ui_task_runner),
       worker_task_runner_(worker_task_runner),
       drive_task_runner_(drive_task_runner),
+      worker_pool_(worker_pool),
       sync_file_system_dir_(sync_file_system_dir),
       task_logger_(task_logger),
       notification_manager_(notification_manager),
       extension_service_(extension_service),
       signin_manager_(signin_manager),
       token_service_(token_service),
       request_context_(request_context),
       drive_service_factory_(drive_service_factory.Pass()),
       remote_change_processor_(nullptr),
       service_state_(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE),
@@ skipping 39 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