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

content/renderer/browser_plugin/browser_plugin_compositing_helper.cc

 // Copyright (c) 2013 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/browser_plugin/browser_plugin_compositing_helper.h"
 
 #include "cc/layers/delegated_renderer_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/output/context_provider.h"
@@ skipping 22 matching lines @@
       ack_pending_(true),
       ack_pending_for_crashed_guest_(false),
       container_(container),
       browser_plugin_manager_(manager) {
 }
 
 BrowserPluginCompositingHelper::~BrowserPluginCompositingHelper() {
 }
 
 void BrowserPluginCompositingHelper::DidCommitCompositorFrame() {
-  if (!delegated_layer_ || !ack_pending_)
+  if (!delegated_layer_.get() || !ack_pending_)
     return;
 
   cc::CompositorFrameAck ack;
   delegated_layer_->TakeUnusedResourcesForChildCompositor(&ack.resources);
 
   browser_plugin_manager_->Send(
       new BrowserPluginHostMsg_CompositorFrameACK(
           host_routing_id_,
           instance_id_,
           last_route_id_,
           last_host_id_,
           ack));
 
   ack_pending_ = false;
 }
 
 void BrowserPluginCompositingHelper::EnableCompositing(bool enable) {
-  if (enable && !background_layer_) {
+  if (enable && !background_layer_.get()) {
     background_layer_ = cc::SolidColorLayer::Create();
     background_layer_->SetMasksToBounds(true);
     background_layer_->SetBackgroundColor(
         SkColorSetARGBInline(255, 255, 255, 255));
     web_layer_.reset(new webkit::WebLayerImpl(background_layer_));
   }
 
   container_->setWebLayer(enable ? web_layer_.get() : NULL);
 }
 
@@ skipping 20 matching lines @@
 // We use a shared graphics context accessible from the main
 // thread to do it.
 void BrowserPluginCompositingHelper::FreeMailboxMemory(
     const std::string& mailbox_name,
     unsigned sync_point) {
   if (mailbox_name.empty())
     return;
 
   scoped_refptr<cc::ContextProvider> context_provider =
       RenderThreadImpl::current()->OffscreenContextProviderForMainThread();
-  if (!context_provider)
+  if (!context_provider.get())
     return;
 
   WebKit::WebGraphicsContext3D *context = context_provider->Context3d();
   // When a buffer is released from the compositor, we also get a
   // sync point that specifies when in the command buffer
   // it's safe to use it again.
   // If the sync point is non-zero, we need to tell our context
   // to wait until this sync point is reached before we can safely
   // delete the buffer.
   if (sync_point)
@@ skipping 75 matching lines @@
   background_layer_ = NULL;
   web_layer_.reset();
 }
 
 void BrowserPluginCompositingHelper::OnBuffersSwapped(
     const gfx::Size& size,
     const std::string& mailbox_name,
     int gpu_route_id,
     int gpu_host_id,
     float device_scale_factor) {
-  DCHECK(!delegated_layer_);
+  DCHECK(!delegated_layer_.get());
   // If the guest crashed but the GPU process didn't, we may still have
   // a transport surface waiting on an ACK, which we must send to
   // avoid leaking.
   if (last_route_id_ != gpu_route_id && last_host_id_ == gpu_host_id)
     ack_pending_for_crashed_guest_ = ack_pending_;
 
   // If these mismatch, we are either just starting up, GPU process crashed or
   // guest renderer crashed.
   // In this case, we are communicating with a new image transport
   // surface and must ACK with the new ID's and an empty mailbox.
   if (last_route_id_ != gpu_route_id || last_host_id_ != gpu_host_id)
     last_mailbox_valid_ = false;
 
   last_route_id_ = gpu_route_id;
   last_host_id_ = gpu_host_id;
 
   ack_pending_ = true;
   // Browser plugin getting destroyed, do a fast ACK.
-  if (!background_layer_) {
+  if (!background_layer_.get()) {
     MailboxReleased(mailbox_name, gpu_route_id, gpu_host_id, 0, false);
     return;
   }
 
-  if (!texture_layer_) {
+  if (!texture_layer_.get()) {
     texture_layer_ = cc::TextureLayer::CreateForMailbox(NULL);
     texture_layer_->SetIsDrawable(true);
     texture_layer_->SetContentsOpaque(true);
 
     background_layer_->AddChild(texture_layer_);
   }
 
   // The size of browser plugin container is not always equal to the size
   // of the buffer that arrives here. This could be for a number of reasons,
   // including autosize and a resize in progress.
@@ skipping 26 matching lines @@
   texture_layer_->SetTextureMailbox(cc::TextureMailbox(mailbox_name,
                                                        callback));
   texture_layer_->SetNeedsDisplay();
   last_mailbox_valid_ = current_mailbox_valid;
 }
 
 void BrowserPluginCompositingHelper::OnCompositorFrameSwapped(
     scoped_ptr<cc::CompositorFrame> frame,
     int route_id,
     int host_id) {
-  DCHECK(!texture_layer_);
-  if (!delegated_layer_) {
+  DCHECK(!texture_layer_.get());
+  if (!delegated_layer_.get()) {
     delegated_layer_ = cc::DelegatedRendererLayer::Create(NULL);
     delegated_layer_->SetIsDrawable(true);
     delegated_layer_->SetContentsOpaque(true);
 
     background_layer_->AddChild(delegated_layer_);
   }
 
   cc::DelegatedFrameData *frame_data = frame->delegated_frame_data.get();
   if (!frame_data)
     return;
 
   CheckSizeAndAdjustLayerBounds(
       frame_data->render_pass_list.back()->output_rect.size(),
       frame->metadata.device_scale_factor,
       delegated_layer_.get());
 
   delegated_layer_->SetFrameData(frame->delegated_frame_data.Pass());
   last_route_id_ = route_id;
   last_host_id_ = host_id;
   ack_pending_ = true;
 }
 
 void BrowserPluginCompositingHelper::UpdateVisibility(bool visible) {
-  if (texture_layer_)
+  if (texture_layer_.get())
     texture_layer_->SetIsDrawable(visible);
-  if (delegated_layer_)
+  if (delegated_layer_.get())
     delegated_layer_->SetIsDrawable(visible);
 }
 
 }  // namespace content