Remove implicit conversions from scoped_refptr to T* in content/renderer/

content/renderer/child_frame_compositing_helper.cc

 // Copyright 2014 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/child_frame_compositing_helper.h"
 
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/layers/delegated_renderer_layer.h"
@@ skipping 122 matching lines @@
   } else if (render_frame_proxy_) {
     render_frame_proxy_->Send(
         new FrameHostMsg_ReclaimCompositorResources(host_routing_id_, params));
   }
 }
 
 void ChildFrameCompositingHelper::CopyFromCompositingSurface(
     int request_id,
     gfx::Rect source_rect,
     gfx::Size dest_size) {
-  CHECK(background_layer_);
+  CHECK(background_layer_.get());
   scoped_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateBitmapRequest(base::Bind(
           &ChildFrameCompositingHelper::CopyFromCompositingSurfaceHasResult,
           this,
           request_id,
           dest_size));
   request->set_area(source_rect);
   background_layer_->RequestCopyOfOutput(request.Pass());
 }
 
@@ skipping 115 matching lines @@
     }
     case SOFTWARE_COMPOSITOR_FRAME:
       break;
   }
 }
 
 void ChildFrameCompositingHelper::OnContainerDestroy() {
   if (GetContainer())
     GetContainer()->setWebLayer(NULL);
 
-  if (resource_collection_)
+  if (resource_collection_.get())
     resource_collection_->SetClient(NULL);
 
   ack_pending_ = false;
   software_ack_pending_ = false;
   resource_collection_ = NULL;
   frame_provider_ = NULL;
   texture_layer_ = NULL;
   delegated_layer_ = NULL;
   background_layer_ = NULL;
   web_layer_.reset();
@@ skipping 151 matching lines @@
     last_route_id_ = route_id;
     last_output_surface_id_ = output_surface_id;
     last_host_id_ = host_id;
     return;
   }
 
   DCHECK(!texture_layer_.get());
 
   cc::DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
   // Do nothing if we are getting destroyed or have no frame data.
-  if (!frame_data || !background_layer_)
+  if (!frame_data || !background_layer_.get())
     return;
 
   DCHECK(!frame_data->render_pass_list.empty());
   cc::RenderPass* root_pass = frame_data->render_pass_list.back();
   gfx::Size frame_size = root_pass->output_rect.size();
 
   if (last_route_id_ != route_id ||
       last_output_surface_id_ != output_surface_id ||
       last_host_id_ != host_id) {
     // Resource ids are scoped by the output surface.
     // If the originating output surface doesn't match the last one, it
     // indicates the guest's output surface may have been recreated, in which
     // case we should recreate the DelegatedRendererLayer, to avoid matching
     // resources from the old one with resources from the new one which would
     // have the same id.
     frame_provider_ = NULL;
 
     // Drop the cc::DelegatedFrameResourceCollection so that we will not return
     // any resources from the old output surface with the new output surface id.
-    if (resource_collection_) {
+    if (resource_collection_.get()) {
       resource_collection_->SetClient(NULL);
 
       if (resource_collection_->LoseAllResources())
         SendReturnedDelegatedResources();
       resource_collection_ = NULL;
     }
     last_output_surface_id_ = output_surface_id;
     last_route_id_ = route_id;
     last_host_id_ = host_id;
   }
-  if (!resource_collection_) {
+  if (!resource_collection_.get()) {
     resource_collection_ = new cc::DelegatedFrameResourceCollection;
     resource_collection_->SetClient(this);
   }
   if (!frame_provider_.get() || frame_provider_->frame_size() != frame_size) {
     frame_provider_ = new cc::DelegatedFrameProvider(
         resource_collection_.get(), frame->delegated_frame_data.Pass());
     if (delegated_layer_.get())
       delegated_layer_->RemoveFromParent();
     delegated_layer_ =
         cc::DelegatedRendererLayer::Create(frame_provider_.get());
@@ skipping 21 matching lines @@
 
 void ChildFrameCompositingHelper::UnusedResourcesAreAvailable() {
   if (ack_pending_)
     return;
 
   SendReturnedDelegatedResources();
 }
 
 void ChildFrameCompositingHelper::SendReturnedDelegatedResources() {
   FrameHostMsg_ReclaimCompositorResources_Params params;
-  if (resource_collection_)
+  if (resource_collection_.get())
     resource_collection_->TakeUnusedResourcesForChildCompositor(
         &params.ack.resources);
   DCHECK(!params.ack.resources.empty());
 
   params.route_id = last_route_id_;
   params.output_surface_id = last_output_surface_id_;
   params.renderer_host_id = last_host_id_;
   SendReclaimCompositorResourcesToBrowser(params);
 }
 
@@ skipping 23 matching lines @@
                                       dest_size.height());
   }
   if (GetBrowserPluginManager()) {
     GetBrowserPluginManager()->Send(
         new BrowserPluginHostMsg_CopyFromCompositingSurfaceAck(
             host_routing_id_, GetInstanceID(), request_id, resized_bitmap));
   }
 }
 
 }  // namespace content