Remove implicit conversions from scoped_refptr to T* in content/

content/browser/renderer_host/render_widget_host_view_android.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/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/android/build_info.h"
 #include "base/basictypes.h"
@@ skipping 400 matching lines @@
   float device_scale_factor = display.device_scale_factor();
   DCHECK_GT(device_scale_factor, 0);
   gfx::Size dst_size(
       gfx::ToCeiledSize(gfx::ScaleSize(bounds, scale / device_scale_factor)));
   CopyFromCompositingSurface(
       src_subrect, dst_size, result_callback, color_type);
 }
 
 scoped_refptr<cc::DelegatedRendererLayer>
 RenderWidgetHostViewAndroid::CreateDelegatedLayerForFrameProvider() const {
-  DCHECK(frame_provider_);
+  DCHECK(frame_provider_.get());
 
   scoped_refptr<cc::DelegatedRendererLayer> delegated_layer =
       cc::DelegatedRendererLayer::Create(frame_provider_);
   delegated_layer->SetBounds(content_size_in_layer_);
   delegated_layer->SetIsDrawable(true);
   delegated_layer->SetContentsOpaque(true);
 
   return delegated_layer;
 }
 
 bool RenderWidgetHostViewAndroid::HasValidFrame() const {
   if (!content_view_core_)
     return false;
-  if (!layer_)
+  if (!layer_.get())
     return false;
 
   if (texture_size_in_layer_.IsEmpty())
     return false;
   // This tell us whether a valid frame has arrived or not.
   if (!frame_evictor_->HasFrame())
     return false;
 
   return true;
 }
@@ skipping 51 matching lines @@
 
 bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
   return HasValidFrame();
 }
 
 void RenderWidgetHostViewAndroid::Show() {
   if (is_showing_)
     return;
 
   is_showing_ = true;
-  if (layer_)
+  if (layer_.get())
     layer_->SetHideLayerAndSubtree(false);
 
   frame_evictor_->SetVisible(true);
   WasShown();
 }
 
 void RenderWidgetHostViewAndroid::Hide() {
   if (!is_showing_)
     return;
 
   is_showing_ = false;
-  if (layer_ && locks_on_frame_count_ == 0)
+  if (layer_.get() && locks_on_frame_count_ == 0)
     layer_->SetHideLayerAndSubtree(true);
 
   frame_evictor_->SetVisible(false);
   // We don't know if we will ever get a frame if we are hiding the renderer, so
   // we need to cancel all requests
   AbortPendingReadbackRequests();
   WasHidden();
 }
 
 bool RenderWidgetHostViewAndroid::IsShowing() {
@@ skipping 19 matching lines @@
   frame_evictor_->UnlockFrame();
   locks_on_frame_count_--;
 
   if (locks_on_frame_count_ == 0) {
     if (last_frame_info_) {
       InternalSwapCompositorFrame(last_frame_info_->output_surface_id,
                                   last_frame_info_->frame.Pass());
       last_frame_info_.reset();
     }
 
-    if (!is_showing_ && layer_)
+    if (!is_showing_ && layer_.get())
       layer_->SetHideLayerAndSubtree(true);
   }
 }
 
 void RenderWidgetHostViewAndroid::SetTextSurroundingSelectionCallback(
     const TextSurroundingSelectionCallback& callback) {
   // Only one outstanding request is allowed at any given time.
   DCHECK(!callback.is_null());
   text_surrounding_selection_callback_ = callback;
 }
@@ skipping 278 matching lines @@
     return;
   }
 
   scoped_ptr<cc::CopyOutputRequest> request;
   scoped_refptr<cc::Layer> readback_layer;
   DCHECK(content_view_core_);
   DCHECK(content_view_core_->GetWindowAndroid());
   ui::WindowAndroidCompositor* compositor =
       content_view_core_->GetWindowAndroid()->GetCompositor();
   DCHECK(compositor);
-  DCHECK(frame_provider_);
+  DCHECK(frame_provider_.get());
   scoped_refptr<cc::DelegatedRendererLayer> delegated_layer =
       CreateDelegatedLayerForFrameProvider();
   delegated_layer->SetHideLayerAndSubtree(true);
   compositor->AttachLayerForReadback(delegated_layer);
 
   readback_layer = delegated_layer;
   request = cc::CopyOutputRequest::CreateRequest(
       base::Bind(&RenderWidgetHostViewAndroid::
                      PrepareTextureCopyOutputResultForDelegatedReadback,
                  dst_size_in_pixel,
@@ skipping 38 matching lines @@
   if (resource_collection_.get())
     resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(host_->GetRoutingID(),
                                                    output_surface_id,
                                                    host_->GetProcess()->GetID(),
                                                    ack);
 }
 
 void RenderWidgetHostViewAndroid::SendReturnedDelegatedResources(
     uint32 output_surface_id) {
-  DCHECK(resource_collection_);
+  DCHECK(resource_collection_.get());
 
   cc::CompositorFrameAck ack;
   resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
   DCHECK(!ack.resources.empty());
 
   RenderWidgetHostImpl::SendReclaimCompositorResources(
       host_->GetRoutingID(),
       output_surface_id,
       host_->GetProcess()->GetID(),
       ack);
@@ skipping 41 matching lines @@
   // http://crbug.com/384134 or http://crbug.com/310763
   frame_data->device_scale_factor = 1.0f;
 
   if (!has_content) {
     DestroyDelegatedContent();
   } else {
     if (!resource_collection_.get()) {
       resource_collection_ = new cc::DelegatedFrameResourceCollection;
       resource_collection_->SetClient(this);
     }
-    if (!frame_provider_ ||
+    if (!frame_provider_.get() ||
         texture_size_in_layer_ != frame_provider_->frame_size()) {
       RemoveLayers();
       frame_provider_ = new cc::DelegatedFrameProvider(
           resource_collection_.get(), frame_data.Pass());
       layer_ = cc::DelegatedRendererLayer::Create(frame_provider_);
       AttachLayers();
     } else {
       frame_provider_->SetFrameData(frame_data.Pass());
     }
   }
@@ skipping 39 matching lines @@
     LOG(ERROR) << "Non-delegated renderer path no longer supported";
     return;
   }
 
   if (locks_on_frame_count_ > 0) {
     DCHECK(HasValidFrame());
     RetainFrame(output_surface_id, frame.Pass());
     return;
   }
 
-  if (layer_ && layer_->layer_tree_host()) {
+  if (layer_.get() && layer_->layer_tree_host()) {
     for (size_t i = 0; i < frame->metadata.latency_info.size(); i++) {
       scoped_ptr<cc::SwapPromise> swap_promise(
           new cc::LatencyInfoSwapPromise(frame->metadata.latency_info[i]));
       layer_->layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
     }
   }
 
   DCHECK(!frame->delegated_frame_data->render_pass_list.empty());
 
   cc::RenderPass* root_pass =
@@ skipping 63 matching lines @@
     // Unblock the compositor.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&RenderViewDevToolsAgentHost::SynchronousSwapCompositorFrame,
                    static_cast<RenderViewDevToolsAgentHost*>(dtah.get()),
                    frame_metadata));
   }
 }
 
 void RenderWidgetHostViewAndroid::SetOverlayVideoMode(bool enabled) {
-  if (layer_)
+  if (layer_.get())
     layer_->SetContentsOpaque(!enabled);
 }
 
 bool RenderWidgetHostViewAndroid::SupportsAnimation() const {
   // The synchronous (WebView) compositor does not have a proper browser
   // compositor with which to drive animations.
   return !using_synchronous_compositor_;
 }
 
 void RenderWidgetHostViewAndroid::SetNeedsAnimate() {
@@ skipping 370 matching lines @@
   selection_controller_->OnSelectionBoundsChanged(insertion_bound,
                                                   insertion_bound);
 }
 
 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
   return cached_background_color_;
 }
 
 void RenderWidgetHostViewAndroid::DidOverscroll(
     const DidOverscrollParams& params) {
-  if (!content_view_core_ || !layer_ || !is_showing_)
+  if (!content_view_core_ || !layer_.get() || !is_showing_)
     return;
 
   const float device_scale_factor = content_view_core_->GetDpiScale();
 
   if (overscroll_effect_ &&
       overscroll_effect_->OnOverscrolled(
           content_view_core_->GetLayer(),
           base::TimeTicks::Now(),
           gfx::ScaleVector2d(params.accumulated_overscroll,
                              device_scale_factor),
@@ skipping 247 matching lines @@
   results->orientationAngle = display.RotationAsDegree();
   results->orientationType =
       RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 } // namespace content