favor DCHECK_CURRENTLY_ON for better logs in content/browser/[q-z]*

content/browser/service_worker/service_worker_internals_ui.cc

 // Copyright 2014 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_internals_ui.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 29 matching lines @@
 void OperationCompleteCallback(WeakPtr<ServiceWorkerInternalsUI> internals,
                                int callback_id,
                                ServiceWorkerStatusCode status) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(OperationCompleteCallback, internals, callback_id, status));
     return;
   }
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (internals) {
     internals->web_ui()->CallJavascriptFunction(
         "serviceworker.onOperationComplete",
         FundamentalValue(static_cast<int>(status)),
         FundamentalValue(callback_id));
   }
 }
 
 void CallServiceWorkerVersionMethodWithVersionID(
     ServiceWorkerInternalsUI::ServiceWorkerVersionMethod method,
     scoped_refptr<ServiceWorkerContextWrapper> context,
     int64 version_id,
     const ServiceWorkerInternalsUI::StatusCallback& callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(CallServiceWorkerVersionMethodWithVersionID,
                    method,
                    context,
                    version_id,
                    callback));
     return;
   }
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   scoped_refptr<ServiceWorkerVersion> version =
       context->context()->GetLiveVersion(version_id);
   if (!version.get()) {
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
     return;
   }
   (*version.get().*method)(callback);
 }
 
 void DispatchPushEventWithVersionID(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     int64 version_id,
     const ServiceWorkerInternalsUI::StatusCallback& callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(DispatchPushEventWithVersionID,
                    context,
                    version_id,
                    callback));
     return;
   }
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   scoped_refptr<ServiceWorkerVersion> version =
       context->context()->GetLiveVersion(version_id);
   if (!version.get()) {
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
     return;
   }
   std::string data = "Test push message from ServiceWorkerInternals.";
   version->DispatchPushEvent(callback, data);
 }
 
 void UnregisterWithScope(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const GURL& scope,
     const ServiceWorkerInternalsUI::StatusCallback& callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(UnregisterWithScope, context, scope, callback));
     return;
   }
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   context->context()->UnregisterServiceWorker(scope, callback);
 }
 
 void WorkerStarted(const scoped_refptr<ServiceWorkerRegistration>& registration,
                    const ServiceWorkerInternalsUI::StatusCallback& callback,
                    ServiceWorkerStatusCode status) {
   callback.Run(status);
 }
 
 void StartActiveWorker(
     const ServiceWorkerInternalsUI::StatusCallback& callback,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status == SERVICE_WORKER_OK) {
     // Pass the reference of |registration| to WorkerStarted callback to prevent
     // it from being deleted while starting the worker. If the refcount of
     // |registration| is 1, it will be deleted after WorkerStarted is called.
     registration->active_version()->StartWorker(
         base::Bind(WorkerStarted, registration, callback));
     return;
   }
   callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
 }
 
 void FindRegistrationForPattern(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const GURL& scope,
     const ServiceWorkerStorage::FindRegistrationCallback callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(FindRegistrationForPattern, context, scope, callback));
     return;
   }
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   context->context()->storage()->FindRegistrationForPattern(scope, callback);
 }
 
 void UpdateVersionInfo(const ServiceWorkerVersionInfo& version,
                        DictionaryValue* info) {
   switch (version.running_status) {
     case ServiceWorkerVersion::STOPPED:
       info->SetString("running_status", "STOPPED");
       break;
     case ServiceWorkerVersion::STARTING:
@@ skipping 77 matching lines @@
     UpdateVersionInfo(*it, info);
     result->Append(info);
   }
   return result;
 }
 
 void GetRegistrationsOnIOThread(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     base::Callback<void(const std::vector<ServiceWorkerRegistrationInfo>&)>
         callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   context->context()->storage()->GetAllRegistrations(callback);
 }
 
 void OnStoredRegistrations(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     base::Callback<void(const std::vector<ServiceWorkerRegistrationInfo>&,
                         const std::vector<ServiceWorkerVersionInfo>&,
                         const std::vector<ServiceWorkerRegistrationInfo>&)>
         callback,
     const std::vector<ServiceWorkerRegistrationInfo>& stored_registrations) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(callback,
                  context->context()->GetAllLiveRegistrationInfo(),
                  context->context()->GetAllLiveVersionInfo(),
                  stored_registrations));
 }
 
 void OnAllRegistrations(
     WeakPtr<ServiceWorkerInternalsUI> internals,
     int partition_id,
     const base::FilePath& context_path,
     const std::vector<ServiceWorkerRegistrationInfo>& live_registrations,
     const std::vector<ServiceWorkerVersionInfo>& live_versions,
     const std::vector<ServiceWorkerRegistrationInfo>& stored_registrations) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!internals)
     return;
 
   ScopedVector<const Value> args;
   args.push_back(GetRegistrationListValue(live_registrations));
   args.push_back(GetVersionListValue(live_versions));
   args.push_back(GetRegistrationListValue(stored_registrations));
   args.push_back(new FundamentalValue(partition_id));
   args.push_back(new StringValue(context_path.value()));
   internals->web_ui()->CallJavascriptFunction("serviceworker.onPartitionData",
                                               args.get());
 }
 
 }  // namespace
 
 class ServiceWorkerInternalsUI::PartitionObserver
     : public ServiceWorkerContextObserver {
  public:
   PartitionObserver(int partition_id, WebUI* web_ui)
       : partition_id_(partition_id), web_ui_(web_ui) {}
   ~PartitionObserver() override {}
   // ServiceWorkerContextObserver overrides:
   void OnRunningStateChanged(int64 version_id) override {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     web_ui_->CallJavascriptFunction(
         "serviceworker.onRunningStateChanged", FundamentalValue(partition_id_),
         StringValue(base::Int64ToString(version_id)));
   }
   void OnVersionStateChanged(int64 version_id) override {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     web_ui_->CallJavascriptFunction(
         "serviceworker.onVersionStateChanged",
         FundamentalValue(partition_id_),
         StringValue(base::Int64ToString(version_id)));
   }
   void OnErrorReported(int64 version_id,
                        int process_id,
                        int thread_id,
                        const ErrorInfo& info) override {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     ScopedVector<const Value> args;
     args.push_back(new FundamentalValue(partition_id_));
     args.push_back(new StringValue(base::Int64ToString(version_id)));
     args.push_back(new FundamentalValue(process_id));
     args.push_back(new FundamentalValue(thread_id));
     scoped_ptr<DictionaryValue> value(new DictionaryValue());
     value->SetString("message", info.error_message);
     value->SetInteger("lineNumber", info.line_number);
     value->SetInteger("columnNumber", info.column_number);
     value->SetString("sourceURL", info.source_url.spec());
     args.push_back(value.release());
     web_ui_->CallJavascriptFunction("serviceworker.onErrorReported",
                                     args.get());
   }
   void OnReportConsoleMessage(int64 version_id,
                               int process_id,
                               int thread_id,
                               const ConsoleMessage& message) override {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     ScopedVector<const Value> args;
     args.push_back(new FundamentalValue(partition_id_));
     args.push_back(new StringValue(base::Int64ToString(version_id)));
     args.push_back(new FundamentalValue(process_id));
     args.push_back(new FundamentalValue(thread_id));
     scoped_ptr<DictionaryValue> value(new DictionaryValue());
     value->SetInteger("sourceIdentifier", message.source_identifier);
     value->SetInteger("message_level", message.message_level);
     value->SetString("message", message.message);
     value->SetInteger("lineNumber", message.line_number);
     value->SetString("sourceURL", message.source_url.spec());
     args.push_back(value.release());
     web_ui_->CallJavascriptFunction("serviceworker.onConsoleMessageReported",
                                     args.get());
   }
   void OnRegistrationStored(int64 registration_id,
                             const GURL& pattern) override {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     web_ui_->CallJavascriptFunction("serviceworker.onRegistrationStored",
                                     StringValue(pattern.spec()));
   }
   void OnRegistrationDeleted(int64 registration_id,
                              const GURL& pattern) override {
     web_ui_->CallJavascriptFunction("serviceworker.onRegistrationDeleted",
                                     StringValue(pattern.spec()));
   }
   int partition_id() const { return partition_id_; }
 
@@ skipping 81 matching lines @@
   bool option_boolean;
   if (!args->GetString(0, &option_name) || option_name != "debug_on_start" ||
       !args->GetBoolean(1, &option_boolean)) {
     return;
   }
   ServiceWorkerDevToolsManager::GetInstance()
       ->set_debug_service_worker_on_start(option_boolean);
 }
 
 void ServiceWorkerInternalsUI::GetAllRegistrations(const ListValue* args) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserContext* browser_context =
       web_ui()->GetWebContents()->GetBrowserContext();
   // Safe to use base::Unretained(this) because
   // ForEachStoragePartition is synchronous.
   BrowserContext::StoragePartitionCallback add_context_cb =
       base::Bind(&ServiceWorkerInternalsUI::AddContextFromStoragePartition,
                  base::Unretained(this));
   BrowserContext::ForEachStoragePartition(browser_context, add_context_cb);
 }
 
@@ skipping 67 matching lines @@
   if (!result_partition)
     return false;
   *context = static_cast<ServiceWorkerContextWrapper*>(
       result_partition->GetServiceWorkerContext());
   return true;
 }
 
 void ServiceWorkerInternalsUI::CallServiceWorkerVersionMethod(
     ServiceWorkerVersionMethod method,
     const ListValue* args) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int callback_id;
   const DictionaryValue* cmd_args = NULL;
   int partition_id;
   scoped_refptr<ServiceWorkerContextWrapper> context;
   std::string version_id_string;
   int64 version_id = 0;
   if (!args->GetInteger(0, &callback_id) ||
       !args->GetDictionary(1, &cmd_args) ||
       !cmd_args->GetInteger("partition_id", &partition_id) ||
       !GetServiceWorkerContext(partition_id, &context) ||
       !cmd_args->GetString("version_id", &version_id_string) ||
       !base::StringToInt64(version_id_string, &version_id)) {
     return;
   }
 
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
   CallServiceWorkerVersionMethodWithVersionID(
       method, context, version_id, callback);
 }
 
 void ServiceWorkerInternalsUI::DispatchPushEvent(
     const ListValue* args) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int callback_id;
   int partition_id;
   int64 version_id = 0;
   std::string version_id_string;
   const DictionaryValue* cmd_args = NULL;
   scoped_refptr<ServiceWorkerContextWrapper> context;
   if (!args->GetInteger(0, &callback_id) ||
       !args->GetDictionary(1, &cmd_args) ||
       !cmd_args->GetInteger("partition_id", &partition_id) ||
       !GetServiceWorkerContext(partition_id, &context) ||
       !cmd_args->GetString("version_id", &version_id_string) ||
       !base::StringToInt64(version_id_string, &version_id)) {
     return;
   }
 
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
   DispatchPushEventWithVersionID(context, version_id, callback);
 }
 
 void ServiceWorkerInternalsUI::InspectWorker(const ListValue* args) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int callback_id;
   const DictionaryValue* cmd_args = NULL;
   int process_id = 0;
   int devtools_agent_route_id = 0;
   if (!args->GetInteger(0, &callback_id) ||
       !args->GetDictionary(1, &cmd_args) ||
       !cmd_args->GetInteger("process_id", &process_id) ||
       !cmd_args->GetInteger("devtools_agent_route_id",
                             &devtools_agent_route_id)) {
     return;
   }
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
   scoped_refptr<DevToolsAgentHostImpl> agent_host(
       ServiceWorkerDevToolsManager::GetInstance()
           ->GetDevToolsAgentHostForWorker(process_id, devtools_agent_route_id));
   if (!agent_host.get()) {
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
     return;
   }
   agent_host->Inspect(web_ui()->GetWebContents()->GetBrowserContext());
   callback.Run(SERVICE_WORKER_OK);
 }
 
 void ServiceWorkerInternalsUI::Unregister(const ListValue* args) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int callback_id;
   int partition_id;
   std::string scope_string;
   const DictionaryValue* cmd_args = NULL;
   scoped_refptr<ServiceWorkerContextWrapper> context;
   if (!args->GetInteger(0, &callback_id) ||
       !args->GetDictionary(1, &cmd_args) ||
       !cmd_args->GetInteger("partition_id", &partition_id) ||
       !GetServiceWorkerContext(partition_id, &context) ||
       !cmd_args->GetString("scope", &scope_string)) {
     return;
   }
 
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
   UnregisterWithScope(context, GURL(scope_string), callback);
 }
 
 void ServiceWorkerInternalsUI::StartWorker(const ListValue* args) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int callback_id;
   int partition_id;
   std::string scope_string;
   const DictionaryValue* cmd_args = NULL;
   scoped_refptr<ServiceWorkerContextWrapper> context;
   if (!args->GetInteger(0, &callback_id) ||
       !args->GetDictionary(1, &cmd_args) ||
       !cmd_args->GetInteger("partition_id", &partition_id) ||
       !GetServiceWorkerContext(partition_id, &context) ||
       !cmd_args->GetString("scope", &scope_string)) {
     return;
   }
 
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
   FindRegistrationForPattern(
       context, GURL(scope_string), base::Bind(StartActiveWorker, callback));
 }
 
 }  // namespace content