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

content/browser/shared_worker/shared_worker_service_impl.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/shared_worker/shared_worker_service_impl.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <vector>
@@ skipping 172 matching lines @@
                        bool is_new_worker,
                        const SharedWorkerInstance& instance)
       : worker_process_id_(worker_process_id),
         worker_route_id_(worker_route_id),
         is_new_worker_(is_new_worker),
         instance_(instance) {}
 
   void TryReserve(const base::Callback<void(bool)>& success_cb,
                   const base::Closure& failure_cb,
                   bool (*try_increment_worker_ref_count)(int)) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (!try_increment_worker_ref_count(worker_process_id_)) {
       BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, failure_cb);
       return;
     }
     bool pause_on_start = false;
     if (is_new_worker_) {
       pause_on_start =
           SharedWorkerDevToolsManager::GetInstance()->WorkerCreated(
               worker_process_id_, worker_route_id_, instance_);
     }
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, base::Bind(success_cb, pause_on_start));
   }
 
  private:
   friend class base::RefCountedThreadSafe<SharedWorkerReserver>;
   ~SharedWorkerReserver() {}
 
   const int worker_process_id_;
   const int worker_route_id_;
   const bool is_new_worker_;
   const SharedWorkerInstance instance_;
 };
 
 // static
 bool (*SharedWorkerServiceImpl::s_try_increment_worker_ref_count_)(int) =
     TryIncrementWorkerRefCount;
 
 SharedWorkerServiceImpl* SharedWorkerServiceImpl::GetInstance() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return Singleton<SharedWorkerServiceImpl>::get();
 }
 
 SharedWorkerServiceImpl::SharedWorkerServiceImpl()
     : update_worker_dependency_(UpdateWorkerDependency),
       next_pending_instance_id_(0) {
 }
 
 SharedWorkerServiceImpl::~SharedWorkerServiceImpl() {}
 
@@ skipping 28 matching lines @@
       info.route_id = host->worker_route_id();
       info.process_id = host->process_id();
       info.handle = host->container_render_filter()->PeerHandle();
       results.push_back(info);
     }
   }
   return results;
 }
 
 void SharedWorkerServiceImpl::AddObserver(WorkerServiceObserver* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   observers_.AddObserver(observer);
 }
 
 void SharedWorkerServiceImpl::RemoveObserver(WorkerServiceObserver* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   observers_.RemoveObserver(observer);
 }
 
 void SharedWorkerServiceImpl::CreateWorker(
     const ViewHostMsg_CreateWorker_Params& params,
     int route_id,
     SharedWorkerMessageFilter* filter,
     ResourceContext* resource_context,
     const WorkerStoragePartitionId& partition_id,
     bool* url_mismatch) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   *url_mismatch = false;
   scoped_ptr<SharedWorkerInstance> instance(
       new SharedWorkerInstance(params.url,
                                params.name,
                                params.content_security_policy,
                                params.security_policy_type,
                                resource_context,
                                partition_id));
   scoped_ptr<SharedWorkerPendingInstance::SharedWorkerPendingRequest> request(
       new SharedWorkerPendingInstance::SharedWorkerPendingRequest(
@@ skipping 162 matching lines @@
 void SharedWorkerServiceImpl::NotifyWorkerDestroyed(int worker_process_id,
                                                     int worker_route_id) {
   FOR_EACH_OBSERVER(WorkerServiceObserver,
                     observers_,
                     WorkerDestroyed(worker_process_id, worker_route_id));
 }
 
 void SharedWorkerServiceImpl::ReserveRenderProcessToCreateWorker(
     scoped_ptr<SharedWorkerPendingInstance> pending_instance,
     bool* url_mismatch) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!FindPendingInstance(*pending_instance->instance()));
   if (url_mismatch)
     *url_mismatch = false;
   if (!pending_instance->requests()->size())
     return;
   int worker_process_id = -1;
   int worker_route_id = MSG_ROUTING_NONE;
   bool is_new_worker = true;
   SharedWorkerHost* host = FindSharedWorkerHost(*pending_instance->instance());
   if (host) {
@@ skipping 40 matching lines @@
           s_try_increment_worker_ref_count_));
   pending_instances_.set(pending_instance_id, pending_instance.Pass());
 }
 
 void SharedWorkerServiceImpl::RenderProcessReservedCallback(
     int pending_instance_id,
     int worker_process_id,
     int worker_route_id,
     bool is_new_worker,
     bool pause_on_start) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // To offset the TryIncrementWorkerRefCount called for the reservation,
   // calls DecrementWorkerRefCount after CheckWorkerDependency in
   // ScopeWorkerDependencyChecker's destructor.
   ScopedWorkerDependencyChecker checker(
       this, base::Bind(&DecrementWorkerRefCount, worker_process_id));
   scoped_ptr<SharedWorkerPendingInstance> pending_instance =
       pending_instances_.take_and_erase(pending_instance_id);
   if (!pending_instance)
     return;
   if (!is_new_worker) {
@@ skipping 117 matching lines @@
     UpdateWorkerDependencyFunc new_func) {
   update_worker_dependency_ = new_func;
 }
 
 void SharedWorkerServiceImpl::ChangeTryIncrementWorkerRefCountFuncForTesting(
     bool (*new_func)(int)) {
   s_try_increment_worker_ref_count_ = new_func;
 }
 
 }  // namespace content