Update content/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/renderer/webplugin_delegate_proxy.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/webplugin_delegate_proxy.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #elif defined(USE_X11)
 #include <cairo/cairo.h>
@@ skipping 107 matching lines @@
   void InitializeForSeekableStream(unsigned long resource_id,
                                    int range_request_id) {
     resource_id_ = resource_id;
     multibyte_response_expected_ = true;
     channel_->Send(new PluginMsg_HTTPRangeRequestReply(
         instance_id_, resource_id, range_request_id));
   }
 
   // PluginResourceClient implementation:
   virtual void WillSendRequest(const GURL& url, int http_status_code) OVERRIDE {
-    DCHECK(channel_ != NULL);
-    channel_->Send(new PluginMsg_WillSendRequest(instance_id_, resource_id_,
-                                                 url, http_status_code));
+    DCHECK(channel_.get() != NULL);
+    channel_->Send(new PluginMsg_WillSendRequest(
+        instance_id_, resource_id_, url, http_status_code));
   }
 
   virtual void DidReceiveResponse(const std::string& mime_type,
                                   const std::string& headers,
                                   uint32 expected_length,
                                   uint32 last_modified,
                                   bool request_is_seekable) OVERRIDE {
-    DCHECK(channel_ != NULL);
+    DCHECK(channel_.get() != NULL);
     PluginMsg_DidReceiveResponseParams params;
     params.id = resource_id_;
     params.mime_type = mime_type;
     params.headers = headers;
     params.expected_length = expected_length;
     params.last_modified = last_modified;
     params.request_is_seekable = request_is_seekable;
     // Grab a reference on the underlying channel so it does not get
     // deleted from under us.
     scoped_refptr<PluginChannelHost> channel_ref(channel_);
     channel_->Send(new PluginMsg_DidReceiveResponse(instance_id_, params));
   }
 
   virtual void DidReceiveData(const char* buffer,
                               int length,
                               int data_offset) OVERRIDE {
-    DCHECK(channel_ != NULL);
+    DCHECK(channel_.get() != NULL);
     DCHECK_GT(length, 0);
     std::vector<char> data;
     data.resize(static_cast<size_t>(length));
     memcpy(&data.front(), buffer, length);
     // Grab a reference on the underlying channel so it does not get
     // deleted from under us.
     scoped_refptr<PluginChannelHost> channel_ref(channel_);
     channel_->Send(new PluginMsg_DidReceiveData(instance_id_, resource_id_,
                                                 data, data_offset));
   }
 
   virtual void DidFinishLoading() OVERRIDE {
-    DCHECK(channel_ != NULL);
+    DCHECK(channel_.get() != NULL);
     channel_->Send(new PluginMsg_DidFinishLoading(instance_id_, resource_id_));
     channel_ = NULL;
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
   virtual void DidFail() OVERRIDE {
-    DCHECK(channel_ != NULL);
+    DCHECK(channel_.get() != NULL);
     channel_->Send(new PluginMsg_DidFail(instance_id_, resource_id_));
     channel_ = NULL;
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
   virtual bool IsMultiByteResponseExpected() OVERRIDE {
     return multibyte_response_expected_;
   }
 
   virtual int ResourceId() OVERRIDE {
@@ skipping 57 matching lines @@
   }
   dummy_activation_window_ = NULL;
 #endif
 
   if (window_)
     WillDestroyWindow();
 
   if (render_view_)
     render_view_->UnregisterPluginDelegate(this);
 
-  if (channel_host_) {
+  if (channel_host_.get()) {
     Send(new PluginMsg_DestroyInstance(instance_id_));
 
     // Must remove the route after sending the destroy message, since
     // RemoveRoute can lead to all the outstanding NPObjects being told the
     // channel went away if this was the last instance.
     channel_host_->RemoveRoute(instance_id_);
 
     // Release the channel host now. If we are is the last reference to the
     // channel, this avoids a race where this renderer asks a new connection to
     // the same plugin between now and the time 'this' is actually deleted.
@@ skipping 63 matching lines @@
         // crashed plugin there.
         return true;
       }
       LOG(ERROR) << "Plug-in couldn't be found";
       return false;
     }
 
     channel_host =
         PluginChannelHost::GetPluginChannelHost(
             channel_handle, ChildProcess::current()->io_message_loop_proxy());
-    if (!channel_host) {
+    if (!channel_host.get()) {
       LOG(ERROR) << "Couldn't get PluginChannelHost";
       continue;
     }
 #if defined(OS_MACOSX)
     track_nested_removes.reset();
 #endif
 
     {
       // TODO(bauerb): Debugging for http://crbug.com/141055.
       ScopedLogLevel log_level(-2);  // Equivalent to --v=2
@@ skipping 31 matching lines @@
 
   if (!result)
     LOG(ERROR) << "PluginMsg_Init returned false";
 
   render_view_->RegisterPluginDelegate(this);
 
   return result;
 }
 
 bool WebPluginDelegateProxy::Send(IPC::Message* msg) {
-  if (!channel_host_) {
+  if (!channel_host_.get()) {
     DLOG(WARNING) << "dropping message because channel host is null";
     delete msg;
     return false;
   }
 
   return channel_host_->Send(msg);
 }
 
 void WebPluginDelegateProxy::SendJavaScriptStream(const GURL& url,
                                                   const std::string& result,
@@ skipping 273 matching lines @@
 #endif
 
 void WebPluginDelegateProxy::Paint(WebKit::WebCanvas* canvas,
                                    const gfx::Rect& damaged_rect) {
   // Limit the damaged rectangle to whatever is contained inside the plugin
   // rectangle, as that's the rectangle that we'll actually draw.
   gfx::Rect rect = gfx::IntersectRects(damaged_rect, plugin_rect_);
 
   // If the plugin is no longer connected (channel crashed) draw a crashed
   // plugin bitmap
-  if (!channel_host_ || !channel_host_->channel_valid()) {
+  if (!channel_host_.get() || !channel_host_->channel_valid()) {
     PaintSadPlugin(canvas, rect);
     return;
   }
 
   if (!uses_shared_bitmaps_)
     return;
 
   // We got a paint before the plugin's coordinates, so there's no buffer to
   // copy from.
   if (!front_buffer_canvas())
@@ skipping 405 matching lines @@
 
   plugin_->HandleURLRequest(
       params.url.c_str(), params.method.c_str(), target, data,
       static_cast<unsigned int>(params.buffer.size()), params.notify_id,
       params.popups_allowed, params.notify_redirects);
 }
 
 webkit::npapi::WebPluginResourceClient*
 WebPluginDelegateProxy::CreateResourceClient(
     unsigned long resource_id, const GURL& url, int notify_id) {
-  if (!channel_host_)
+  if (!channel_host_.get())
     return NULL;
 
-  ResourceClientProxy* proxy = new ResourceClientProxy(channel_host_,
-                                                       instance_id_);
+  ResourceClientProxy* proxy =
+      new ResourceClientProxy(channel_host_.get(), instance_id_);
   proxy->Initialize(resource_id, url, notify_id);
   return proxy;
 }
 
 webkit::npapi::WebPluginResourceClient*
 WebPluginDelegateProxy::CreateSeekableResourceClient(
     unsigned long resource_id, int range_request_id) {
-  if (!channel_host_)
+  if (!channel_host_.get())
     return NULL;
 
-  ResourceClientProxy* proxy = new ResourceClientProxy(channel_host_,
-                                                       instance_id_);
+  ResourceClientProxy* proxy =
+      new ResourceClientProxy(channel_host_.get(), instance_id_);
   proxy->InitializeForSeekableStream(resource_id, range_request_id);
   return proxy;
 }
 
 #if defined(OS_MACOSX)
 void WebPluginDelegateProxy::OnFocusChanged(bool focused) {
   if (render_view_)
     render_view_->PluginFocusChanged(focused, instance_id_);
 }
 
@@ skipping 70 matching lines @@
 
 void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow,
                                                    int resource_id) {
   if (!plugin_)
     return;
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }
 
 }  // namespace content