Cleanup: Remove unnecessary ".get()" from scoped_ptrs<>.

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 "content/browser/devtools/devtools_http_handler_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 174 matching lines @@
 }
 
 DevToolsHttpHandlerImpl::~DevToolsHttpHandlerImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Stop() must be called prior to destruction.
   DCHECK(server_.get() == NULL);
   DCHECK(thread_.get() == NULL);
 }
 
 void DevToolsHttpHandlerImpl::Start() {
-  if (thread_.get())
+  if (thread_)
     return;
   thread_.reset(new base::Thread(kDevToolsHandlerThreadName));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DevToolsHttpHandlerImpl::StartHandlerThread, this));
 }
 
 // Runs on FILE thread.
 void DevToolsHttpHandlerImpl::StartHandlerThread() {
   base::Thread::Options options;
@@ skipping 13 matching lines @@
 void DevToolsHttpHandlerImpl::ResetHandlerThread() {
   thread_.reset();
 }
 
 void DevToolsHttpHandlerImpl::ResetHandlerThreadAndRelease() {
   ResetHandlerThread();
   Release();
 }
 
 void DevToolsHttpHandlerImpl::Stop() {
-  if (!thread_.get())
+  if (!thread_)
     return;
   BrowserThread::PostTaskAndReply(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DevToolsHttpHandlerImpl::StopHandlerThread, this),
       base::Bind(&DevToolsHttpHandlerImpl::ResetHandlerThreadAndRelease, this));
 }
 
 void DevToolsHttpHandlerImpl::SetDevToolsAgentHostBinding(
     DevToolsAgentHostBinding* binding) {
   if (binding)
@@ skipping 359 matching lines @@
 }
 
 void DevToolsHttpHandlerImpl::OnDiscoveryPageRequestUI(int connection_id) {
   std::string response = delegate_->GetDiscoveryPageHTML();
   Send200(connection_id, response, "text/html; charset=UTF-8");
 }
 
 void DevToolsHttpHandlerImpl::OnWebSocketRequestUI(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
-  if (!thread_.get())
+  if (!thread_)
     return;
   std::string browser_prefix = "/devtools/browser";
   size_t browser_pos = request.path.find(browser_prefix);
   if (browser_pos == 0) {
     if (browser_target_) {
       Send500(connection_id, "Another client already attached");
       return;
     }
     browser_target_.reset(new DevToolsBrowserTarget(
         thread_->message_loop_proxy().get(), server_.get(), connection_id));
@@ skipping 112 matching lines @@
       FROM_HERE,
       base::Bind(&DevToolsHttpHandlerImpl::Teardown, this));
   // Thread::Stop joins the thread.
   thread_->Stop();
 }
 
 void DevToolsHttpHandlerImpl::SendJson(int connection_id,
                                        net::HttpStatusCode status_code,
                                        base::Value* value,
                                        const std::string& message) {
-  if (!thread_.get())
+  if (!thread_)
     return;
 
   // Serialize value and message.
   std::string json_value;
   if (value) {
     base::JSONWriter::WriteWithOptions(value,
                                        base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                        &json_value);
   }
   std::string json_message;
@@ skipping 11 matching lines @@
                  server_.get(),
                  connection_id,
                  status_code,
                  response,
                  mime_type));
 }
 
 void DevToolsHttpHandlerImpl::Send200(int connection_id,
                                       const std::string& data,
                                       const std::string& mime_type) {
-  if (!thread_.get())
+  if (!thread_)
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&net::HttpServer::Send200,
                  server_.get(),
                  connection_id,
                  data,
                  mime_type));
 }
 
 void DevToolsHttpHandlerImpl::Send404(int connection_id) {
-  if (!thread_.get())
+  if (!thread_)
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&net::HttpServer::Send404, server_.get(), connection_id));
 }
 
 void DevToolsHttpHandlerImpl::Send500(int connection_id,
                                       const std::string& message) {
-  if (!thread_.get())
+  if (!thread_)
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&net::HttpServer::Send500, server_.get(), connection_id,
                  message));
 }
 
 void DevToolsHttpHandlerImpl::AcceptWebSocket(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
-  if (!thread_.get())
+  if (!thread_)
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
                  connection_id, request));
 }
 
 base::DictionaryValue* DevToolsHttpHandlerImpl::SerializePageInfo(
     RenderViewHost* rvh,
     const std::string& host) {
@@ skipping 68 matching lines @@
                                            host.c_str(),
                                            kPageUrlPrefix,
                                            id.c_str()));
   std::string devtools_frontend_url = GetFrontendURLInternal(
       id.c_str(),
       host);
   dictionary->SetString(kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
 }
 
 }  // namespace content