Remove implicit conversions from scoped_refptr to T* in content/browser/devtools/

content/browser/devtools/devtools_browser_target.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 "content/browser/devtools/devtools_browser_target.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 34 matching lines @@
 }
 
 typedef std::map<std::string, DevToolsBrowserTarget*> DomainMap;
 base::LazyInstance<DomainMap>::Leaky g_used_domains = LAZY_INSTANCE_INITIALIZER;
 
 void DevToolsBrowserTarget::HandleMessage(const std::string& data) {
   DCHECK_EQ(message_loop_proxy_, base::MessageLoopProxy::current());
   std::string error_response;
   scoped_refptr<DevToolsProtocol::Command> command =
       DevToolsProtocol::ParseCommand(data, &error_response);
-  if (!command) {
+  if (!command.get()) {
     Respond(error_response);
     return;
   }
 
   DomainHandlerMap::iterator it = handlers_.find(command->domain());
   if (it == handlers_.end()) {
     Respond(command->NoSuchMethodErrorResponse()->Serialize());
     return;
   }
   DomainMap& used_domains(g_used_domains.Get());
   std::string domain = command->domain();
   DomainMap::iterator jt = used_domains.find(domain);
   if (jt == used_domains.end()) {
     used_domains[domain] = this;
   } else if (jt->second != this) {
     std::string message =
         base::StringPrintf("'%s' is held by another connection",
                            domain.c_str());
     Respond(command->ServerErrorResponse(message)->Serialize());
     return;
   }
 
   DevToolsProtocol::Handler* handler = it->second;
   bool handle_directly = handle_on_ui_thread_.find(domain) ==
       handle_on_ui_thread_.end();
   if (handle_directly) {
     scoped_refptr<DevToolsProtocol::Response> response =
         handler->HandleCommand(command);
-    if (response && response->is_async_promise())
+    if (response.get() && response->is_async_promise())
       return;
-    if (response)
+    if (response.get())
       Respond(response->Serialize());
     else
       Respond(command->NoSuchMethodErrorResponse()->Serialize());
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&DevToolsBrowserTarget::HandleCommandOnUIThread,
@@ skipping 44 matching lines @@
   // DCHECK that Detach has been called or no handler has ever been registered.
   DCHECK(handlers_.empty());
 }
 
 void DevToolsBrowserTarget::HandleCommandOnUIThread(
     DevToolsProtocol::Handler* handler,
     scoped_refptr<DevToolsProtocol::Command> command) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_refptr<DevToolsProtocol::Response> response =
       handler->HandleCommand(command);
-  if (response && response->is_async_promise())
+  if (response.get() && response->is_async_promise())
     return;
 
-  if (response)
+  if (response.get())
     RespondFromUIThread(response->Serialize());
   else
     RespondFromUIThread(command->NoSuchMethodErrorResponse()->Serialize());
 }
 
 void DevToolsBrowserTarget::DeleteHandlersOnUIThread(
     std::vector<DevToolsProtocol::Handler*> handlers) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   STLDeleteElements(&handlers);
 }
 
 void DevToolsBrowserTarget::Respond(const std::string& message) {
   DCHECK_EQ(message_loop_proxy_, base::MessageLoopProxy::current());
   if (!http_server_)
     return;
   http_server_->SendOverWebSocket(connection_id_, message);
 }
 
 void DevToolsBrowserTarget::RespondFromUIThread(const std::string& message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&DevToolsBrowserTarget::Respond, this, message));
 }
 
 }  // namespace content