[content/browser/service_worker] Using ThreadTaskRunnerHandle in lieu of MessageLoopProxy

content/browser/service_worker/service_worker_storage.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 "content/browser/service_worker/service_worker_storage.h"
 
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_disk_cache.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace content {
 
 namespace {
 
 void RunSoon(const tracked_objects::Location& from_here,
              const base::Closure& closure) {
-  base::MessageLoop::current()->PostTask(from_here, closure);
+  base::ThreadTaskRunnerHandle::Get()->PostTask(from_here, closure);
 }
 
 void CompleteFindNow(
     const scoped_refptr<ServiceWorkerRegistration>& registration,
     ServiceWorkerStatusCode status,
     const ServiceWorkerStorage::FindRegistrationCallback& callback) {
   if (registration && registration->is_deleted()) {
     // It's past the point of no return and no longer findable.
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND, nullptr);
     return;
@@ skipping 256 matching lines @@
   TRACE_EVENT_ASYNC_BEGIN1(
       "ServiceWorker",
       "ServiceWorkerStorage::FindRegistrationForDocument",
       callback_id,
       "URL", document_url.spec());
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &FindForDocumentInDB,
           database_.get(),
-          base::MessageLoopProxy::current(),
+          base::ThreadTaskRunnerHandle::Get(),
           document_url,
           base::Bind(&ServiceWorkerStorage::DidFindRegistrationForDocument,
                      weak_factory_.GetWeakPtr(),
                      document_url,
                      callback,
                      callback_id)));
 }
 
 void ServiceWorkerStorage::FindRegistrationForPattern(
     const GURL& scope,
@@ skipping 21 matching lines @@
                          : SERVICE_WORKER_ERROR_NOT_FOUND,
                      callback);
     return;
   }
 
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &FindForPatternInDB,
           database_.get(),
-          base::MessageLoopProxy::current(),
+          base::ThreadTaskRunnerHandle::Get(),
           scope,
           base::Bind(&ServiceWorkerStorage::DidFindRegistrationForPattern,
-                     weak_factory_.GetWeakPtr(), scope, callback)));
+                     weak_factory_.GetWeakPtr(),
+                     scope,
+                     callback)));
 }
 
 ServiceWorkerRegistration* ServiceWorkerStorage::GetUninstallingRegistration(
     const GURL& scope) {
   if (state_ != INITIALIZED || !context_)
     return NULL;
   for (RegistrationRefsById::const_iterator it =
            uninstalling_registrations_.begin();
        it != uninstalling_registrations_.end();
        ++it) {
@@ skipping 37 matching lines @@
       context_->GetLiveRegistration(registration_id);
   if (registration.get()) {
     CompleteFindNow(registration, SERVICE_WORKER_OK, callback);
     return;
   }
 
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&FindForIdInDB,
                  database_.get(),
-                 base::MessageLoopProxy::current(),
-                 registration_id, origin,
+                 base::ThreadTaskRunnerHandle::Get(),
+                 registration_id,
+                 origin,
                  base::Bind(&ServiceWorkerStorage::DidFindRegistrationForId,
-                            weak_factory_.GetWeakPtr(), callback)));
+                            weak_factory_.GetWeakPtr(),
+                            callback)));
 }
 
 void ServiceWorkerStorage::FindRegistrationForIdOnly(
     int64 registration_id,
     const FindRegistrationCallback& callback) {
   if (!LazyInitialize(
           base::Bind(&ServiceWorkerStorage::FindRegistrationForIdOnly,
                      weak_factory_.GetWeakPtr(), registration_id, callback))) {
     if (state_ != INITIALIZING || !context_) {
       CompleteFindNow(nullptr, SERVICE_WORKER_ERROR_FAILED, callback);
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       context_->GetLiveRegistration(registration_id);
   if (registration) {
     // Delegate to FindRegistrationForId to make sure the same subset of live
     // registrations is returned.
     // TODO(mek): CompleteFindNow should really do all the required checks, so
     // calling that directly here should be enough.
     FindRegistrationForId(registration_id, registration->pattern().GetOrigin(),
                           callback);
     return;
   }
 
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&FindForIdOnlyInDB, database_.get(),
-                 base::MessageLoopProxy::current(), registration_id,
+      base::Bind(&FindForIdOnlyInDB,
+                 database_.get(),
+                 base::ThreadTaskRunnerHandle::Get(),
+                 registration_id,
                  base::Bind(&ServiceWorkerStorage::DidFindRegistrationForId,
-                            weak_factory_.GetWeakPtr(), callback)));
+                            weak_factory_.GetWeakPtr(),
+                            callback)));
 }
 
 void ServiceWorkerStorage::GetRegistrationsForOrigin(
     const GURL& origin, const GetRegistrationsInfosCallback& callback) {
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::GetRegistrationsForOrigin,
           weak_factory_.GetWeakPtr(), origin, callback))) {
     if (state_ != INITIALIZING || !context_) {
       RunSoon(FROM_HERE, base::Bind(
           callback, std::vector<ServiceWorkerRegistrationInfo>()));
@@ skipping 75 matching lines @@
   }
   data.resources_total_size_bytes = resources_total_size_bytes;
 
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
 
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&WriteRegistrationInDB,
                  database_.get(),
-                 base::MessageLoopProxy::current(),
+                 base::ThreadTaskRunnerHandle::Get(),
                  data,
                  resources,
                  base::Bind(&ServiceWorkerStorage::DidStoreRegistration,
                             weak_factory_.GetWeakPtr(),
                             callback,
                             data)));
 
   registration->set_is_deleted(false);
 }
 
@@ skipping 53 matching lines @@
 
   DidDeleteRegistrationParams params;
   params.registration_id = registration_id;
   params.origin = origin;
   params.callback = callback;
 
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&DeleteRegistrationFromDB,
                  database_.get(),
-                 base::MessageLoopProxy::current(),
-                 registration_id, origin,
+                 base::ThreadTaskRunnerHandle::Get(),
+                 registration_id,
+                 origin,
                  base::Bind(&ServiceWorkerStorage::DidDeleteRegistration,
-                            weak_factory_.GetWeakPtr(), params)));
+                            weak_factory_.GetWeakPtr(),
+                            params)));
 
   // The registration should no longer be findable.
   pending_deletions_.insert(registration_id);
   ServiceWorkerRegistration* registration =
       context_->GetLiveRegistration(registration_id);
   if (registration)
     registration->set_is_deleted(true);
 }
 
 scoped_ptr<ServiceWorkerResponseReader>
@@ skipping 94 matching lines @@
   if (registration_id == kInvalidServiceWorkerRegistrationId || key.empty()) {
     RunSoon(FROM_HERE,
             base::Bind(callback, std::string(), SERVICE_WORKER_ERROR_FAILED));
     return;
   }
 
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ServiceWorkerStorage::GetUserDataInDB,
                  database_.get(),
-                 base::MessageLoopProxy::current(),
+                 base::ThreadTaskRunnerHandle::Get(),
                  registration_id,
                  key,
                  base::Bind(&ServiceWorkerStorage::DidGetUserData,
-                            weak_factory_.GetWeakPtr(), callback)));
+                            weak_factory_.GetWeakPtr(),
+                            callback)));
 }
 
 void ServiceWorkerStorage::ClearUserData(
     int64 registration_id,
     const std::string& key,
     const StatusCallback& callback) {
   DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
   if (IsDisabled() || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
     return;
@@ skipping 35 matching lines @@
     RunSoon(FROM_HERE,
             base::Bind(callback, std::vector<std::pair<int64, std::string>>(),
                        SERVICE_WORKER_ERROR_FAILED));
     return;
   }
 
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &ServiceWorkerStorage::GetUserDataForAllRegistrationsInDB,
-          database_.get(), base::MessageLoopProxy::current(), key,
+          database_.get(),
+          base::ThreadTaskRunnerHandle::Get(),
+          key,
           base::Bind(&ServiceWorkerStorage::DidGetUserDataForAllRegistrations,
-                     weak_factory_.GetWeakPtr(), callback)));
+                     weak_factory_.GetWeakPtr(),
+                     callback)));
 }
 
 void ServiceWorkerStorage::DeleteAndStartOver(const StatusCallback& callback) {
   Disable();
 
   // Delete the database on the database thread.
   PostTaskAndReplyWithResult(
       database_task_manager_->GetTaskRunner(),
       FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::DestroyDatabase,
@@ skipping 133 matching lines @@
     case UNINITIALIZED:
       pending_tasks_.push_back(callback);
       // Fall-through.
   }
 
   state_ = INITIALIZING;
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ReadInitialDataFromDB,
                  database_.get(),
-                 base::MessageLoopProxy::current(),
+                 base::ThreadTaskRunnerHandle::Get(),
                  base::Bind(&ServiceWorkerStorage::DidReadInitialData,
                             weak_factory_.GetWeakPtr())));
   return false;
 }
 
 void ServiceWorkerStorage::DidReadInitialData(
     InitialData* data,
     ServiceWorkerDatabase::Status status) {
   DCHECK(data);
   DCHECK_EQ(INITIALIZING, state_);
@@ skipping 470 matching lines @@
   ContinuePurgingResources();
 }
 
 void ServiceWorkerStorage::DeleteStaleResources() {
   DCHECK(!has_checked_for_stale_resources_);
   has_checked_for_stale_resources_ = true;
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ServiceWorkerStorage::CollectStaleResourcesFromDB,
                  database_.get(),
-                 base::MessageLoopProxy::current(),
+                 base::ThreadTaskRunnerHandle::Get(),
                  base::Bind(&ServiceWorkerStorage::DidCollectStaleResources,
                             weak_factory_.GetWeakPtr())));
 }
 
 void ServiceWorkerStorage::DidCollectStaleResources(
     const std::vector<int64>& stale_resource_ids,
     ServiceWorkerDatabase::Status status) {
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     DCHECK_NE(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, status);
     ScheduleDeleteAndStartOver();
@@ skipping 336 matching lines @@
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   ServiceWorkerMetrics::RecordDeleteAndStartOverResult(
       ServiceWorkerMetrics::DELETE_OK);
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content