favor DCHECK_CURRENTLY_ON for better logs in content/browser/[a-d]*

content/browser/devtools/protocol/service_worker_handler.cc

 // Copyright 2015 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/devtools/protocol/service_worker_handler.h"
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/devtools/service_worker_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
@@ skipping 124 matching lines @@
                              const GURL& pattern) override;
 
   scoped_refptr<ServiceWorkerContextWrapper> context_;
   base::WeakPtr<ServiceWorkerHandler> handler_;
 };
 
 ServiceWorkerHandler::ContextObserver::ContextObserver(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     base::WeakPtr<ServiceWorkerHandler> handler)
     : context_(context), handler_(handler) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 void ServiceWorkerHandler::ContextObserver::Start() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&ServiceWorkerHandler::ContextObserver::
                                          GetStoredRegistrationsOnIOThread,
                                      this));
 }
 
 void ServiceWorkerHandler::ContextObserver::Stop() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ServiceWorkerHandler::ContextObserver::StopOnIOThread, this));
 }
 
 void ServiceWorkerHandler::ContextObserver::GetStoredRegistrationsOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   context_->context()->storage()->GetAllRegistrations(base::Bind(
       &ServiceWorkerHandler::ContextObserver::OnStoredRegistrationsOnIOThread,
       this));
 }
 
 void ServiceWorkerHandler::ContextObserver::OnStoredRegistrationsOnIOThread(
     const std::vector<ServiceWorkerRegistrationInfo>& registrations) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   context_->AddObserver(this);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated, handler_,
                  registrations));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated, handler_,
                  context_->context()->GetAllLiveRegistrationInfo()));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ServiceWorkerHandler::OnWorkerVersionUpdated, handler_,
                  context_->context()->GetAllLiveVersionInfo()));
 }
 
 void ServiceWorkerHandler::ContextObserver::StopOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   context_->RemoveObserver(this);
 }
 
 ServiceWorkerHandler::ContextObserver::~ContextObserver() {
 }
 
 void ServiceWorkerHandler::ContextObserver::OnVersionUpdated(int64 version_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   content::ServiceWorkerVersion* version =
       context_->context()->GetLiveVersion(version_id);
   if (!version)
     return;
   OnRegistrationUpdated(version->registration_id());
   std::vector<ServiceWorkerVersionInfo> versions;
   versions.push_back(version->GetInfo());
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ServiceWorkerHandler::OnWorkerVersionUpdated, handler_,
@@ skipping 20 matching lines @@
 }
 
 void ServiceWorkerHandler::ContextObserver::OnVersionStateChanged(
     int64 version_id) {
   OnVersionUpdated(version_id);
 }
 
 void ServiceWorkerHandler::ContextObserver::OnRegistrationStored(
     int64 registration_id,
     const GURL& pattern) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   content::ServiceWorkerRegistration* registration =
       context_->context()->GetLiveRegistration(registration_id);
   DCHECK(registration);
   std::vector<ServiceWorkerRegistrationInfo> registrations;
   registrations.push_back(registration->GetInfo());
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated, handler_,
                  registrations));
 }
 
 void ServiceWorkerHandler::ContextObserver::OnRegistrationDeleted(
     int64 registration_id,
     const GURL& pattern) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationDeleted, handler_,
                  registration_id));
 }
 
 ServiceWorkerHandler::ServiceWorkerHandler()
     : enabled_(false), weak_factory_(this) {
 }
 
@@ skipping 181 matching lines @@
 bool ServiceWorkerHandler::MatchesInspectedPage(
     ServiceWorkerDevToolsAgentHost* host) {
   // TODO(pfeldman): match based on scope.
   // TODO(pfeldman): match iframes.
   return host->GetURL().host() == url_.host();
 }
 
 }  // namespace service_worker
 }  // namespace devtools
 }  // namespace content