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

content/browser/devtools/devtools_http_handler_impl.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
@@ skipping 235 matching lines @@
 
 void ServerWrapper::Close(int connection_id) {
   server_->Close(connection_id);
 }
 
 // Thread and ServerWrapper lifetime management ------------------------------
 
 void TerminateOnUI(base::Thread* thread,
                    ServerWrapper* server_wrapper,
                    DevToolsHttpHandler::ServerSocketFactory* socket_factory) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (server_wrapper) {
     DCHECK(thread);
     thread->message_loop()->DeleteSoon(FROM_HERE, server_wrapper);
   }
   if (socket_factory) {
     DCHECK(thread);
     thread->message_loop()->DeleteSoon(FROM_HERE, socket_factory);
   }
   if (thread) {
     BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE, thread);
   }
 }
 
 void ServerStartedOnUI(
     base::WeakPtr<DevToolsHttpHandlerImpl> handler,
     base::Thread* thread,
     ServerWrapper* server_wrapper,
     DevToolsHttpHandler::ServerSocketFactory* socket_factory,
     scoped_ptr<net::IPEndPoint> ip_address) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (handler && thread && server_wrapper) {
     handler->ServerStarted(thread, server_wrapper, socket_factory,
                            ip_address.Pass());
   } else {
     TerminateOnUI(thread, server_wrapper, socket_factory);
   }
 }
 
 void StartServerOnHandlerThread(
     base::WeakPtr<DevToolsHttpHandlerImpl> handler,
@@ skipping 27 matching lines @@
                  server_socket_factory,
                  base::Passed(&ip_address)));
 }
 
 void StartServerOnFile(
     base::WeakPtr<DevToolsHttpHandlerImpl> handler,
     DevToolsHttpHandler::ServerSocketFactory* server_socket_factory,
     const base::FilePath& output_directory,
     const base::FilePath& frontend_dir,
     bool bundles_resources) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   scoped_ptr<base::Thread> thread(new base::Thread(kDevToolsHandlerThreadName));
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   if (thread->StartWithOptions(options)) {
     base::MessageLoop* message_loop = thread->message_loop();
     message_loop->PostTask(FROM_HERE,
         base::Bind(&StartServerOnHandlerThread,
                    handler,
                    base::Unretained(thread.release()),
                    server_socket_factory,
@@ skipping 90 matching lines @@
             devtools::tracing::TracingHandler::Browser)),
         protocol_handler_(new DevToolsProtocolHandler(
             base::Bind(&BrowserTarget::Respond, base::Unretained(this)))) {
     DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
     dispatcher->SetSystemInfoHandler(system_info_handler_.get());
     dispatcher->SetTetheringHandler(tethering_handler_.get());
     dispatcher->SetTracingHandler(tracing_handler_.get());
   }
 
   void HandleMessage(const std::string& message) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     std::string error_response;
     scoped_ptr<base::DictionaryValue> command =
         protocol_handler_->ParseCommand(message);
     if (command)
       protocol_handler_->HandleCommand(command.Pass());
   }
 
   void Respond(const std::string& message) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&ServerWrapper::SendOverWebSocket,
                    base::Unretained(server_wrapper_),
                    connection_id_,
                    message));
   }
 
  private:
   base::MessageLoop* const message_loop_;
@@ skipping 664 matching lines @@
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace content