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

content/renderer/pepper/pepper_websocket_host.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/renderer/pepper/pepper_websocket_host.h"
 
 #include <string>
 
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "net/base/net_util.h"
@@ skipping 25 matching lines @@
     PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       renderer_ppapi_host_(host),
       connecting_(false),
       initiating_close_(false),
       accepting_close_(false),
       error_was_received_(false) {
 }
 
 PepperWebSocketHost::~PepperWebSocketHost() {
-  if (websocket_.get())
+  if (websocket_)
     websocket_->disconnect();
 }
 
 int32_t PepperWebSocketHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
   IPC_BEGIN_MESSAGE_MAP(PepperWebSocketHost, msg)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_WebSocket_Connect,
                                       OnHostMsgConnect)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_WebSocket_Close,
                                       OnHostMsgClose)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_WebSocket_SendText,
                                       OnHostMsgSendText)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_WebSocket_SendBinary,
                                       OnHostMsgSendBinary)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_WebSocket_Fail,
                                       OnHostMsgFail)
   IPC_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
 void PepperWebSocketHost::didConnect() {
   std::string protocol;
-  if (websocket_.get())
+  if (websocket_)
     protocol = websocket_->subprotocol().utf8();
   connecting_ = false;
   connect_reply_.params.set_result(PP_OK);
   host()->SendReply(connect_reply_,
                     PpapiPluginMsg_WebSocket_ConnectReply(
                         url_,
                         protocol));
 }
 
 void PepperWebSocketHost::didReceiveMessage(const WebKit::WebString& message) {
@@ skipping 81 matching lines @@
     accepting_close_ = false;
     host()->SendUnsolicitedReply(pp_resource(),
                                  PpapiPluginMsg_WebSocket_ClosedReply(
                                      unhandled_buffered_amount,
                                      was_clean,
                                      code,
                                      reason.utf8()));
   }
 
   // Disconnect.
-  if (websocket_.get())
+  if (websocket_)
     websocket_->disconnect();
 }
 
 int32_t PepperWebSocketHost::OnHostMsgConnect(
     ppapi::host::HostMessageContext* context,
     const std::string& url,
     const std::vector<std::string>& protocols) {
   // Validate url and convert it to WebURL.
   GURL gurl(url);
   url_ = gurl.spec();
@@ skipping 43 matching lines @@
 
   // Create WebKit::WebSocket object and connect.
   WebKit::WebPluginContainer* container =
       renderer_ppapi_host_->GetContainerForInstance(pp_instance());
   if (!container)
     return PP_ERROR_BADARGUMENT;
   // TODO(toyoshim) Remove following WebDocument object copy.
   WebDocument document = container->element().document();
   websocket_.reset(WebSocket::create(document, this));
   DCHECK(websocket_.get());
-  if (!websocket_.get())
+  if (!websocket_)
     return PP_ERROR_NOTSUPPORTED;
 
   // Set receiving binary object type.
   websocket_->setBinaryType(WebSocket::BinaryTypeArrayBuffer);
   websocket_->connect(web_url, web_protocols);
 
   connect_reply_ = context->MakeReplyMessageContext();
   connecting_ = true;
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperWebSocketHost::OnHostMsgClose(
     ppapi::host::HostMessageContext* context,
     int32_t code,
     const std::string& reason) {
-  if (!websocket_.get())
+  if (!websocket_)
     return PP_ERROR_FAILED;
   close_reply_ = context->MakeReplyMessageContext();
   initiating_close_ = true;
   WebString web_reason = WebString::fromUTF8(reason);
   websocket_->close(code, web_reason);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperWebSocketHost::OnHostMsgSendText(
     ppapi::host::HostMessageContext* context,
     const std::string& message) {
-  if (websocket_.get()) {
+  if (websocket_) {
     WebString web_message = WebString::fromUTF8(message);
     websocket_->sendText(web_message);
   }
   return PP_OK;
 }
 
 int32_t PepperWebSocketHost::OnHostMsgSendBinary(
     ppapi::host::HostMessageContext* context,
     const std::vector<uint8_t>& message) {
   if (websocket_.get() && !message.empty()) {
     WebArrayBuffer web_message = WebArrayBuffer::create(message.size(), 1);
     memcpy(web_message.data(), &message.front(), message.size());
     websocket_->sendArrayBuffer(web_message);
   }
   return PP_OK;
 }
 
 int32_t PepperWebSocketHost::OnHostMsgFail(
     ppapi::host::HostMessageContext* context,
     const std::string& message) {
-  if (websocket_.get())
+  if (websocket_)
     websocket_->fail(WebString::fromUTF8(message));
   return PP_OK;
 }
 
 }  // namespace content