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

content/browser/renderer_host/render_widget_host_view_aura.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_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 284 matching lines @@
 // Swap ack for the renderer when kCompositeToMailbox is enabled.
 void SendCompositorFrameAck(
     int32 route_id,
     int renderer_host_id,
     const gpu::Mailbox& received_mailbox,
     const gfx::Size& received_size,
     bool skip_frame,
     const scoped_refptr<ui::Texture>& texture_to_produce) {
   cc::CompositorFrameAck ack;
   ack.gl_frame_data.reset(new cc::GLFrameData());
-  DCHECK(!texture_to_produce || !skip_frame);
-  if (texture_to_produce) {
+  DCHECK(!texture_to_produce.get() || !skip_frame);
+  if (texture_to_produce.get()) {
     std::string mailbox_name = texture_to_produce->Produce();
     std::copy(mailbox_name.data(),
               mailbox_name.data() + mailbox_name.length(),
               reinterpret_cast<char*>(ack.gl_frame_data->mailbox.name));
     ack.gl_frame_data->size = texture_to_produce->size();
     ack.gl_frame_data->sync_point =
         content::ImageTransportFactory::GetInstance()->InsertSyncPoint();
   } else if (skip_frame) {
     // Skip the frame, i.e. tell the producer to reuse the same buffer that
     // we just received.
     ack.gl_frame_data->size = received_size;
     ack.gl_frame_data->mailbox = received_mailbox;
   }
 
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
       route_id, renderer_host_id, ack);
 }
 
 void AcknowledgeBufferForGpu(
     int32 route_id,
     int gpu_host_id,
     const std::string& received_mailbox,
     bool skip_frame,
     const scoped_refptr<ui::Texture>& texture_to_produce) {
   AcceleratedSurfaceMsg_BufferPresented_Params ack;
   uint32 sync_point = 0;
-  DCHECK(!texture_to_produce || !skip_frame);
-  if (texture_to_produce) {
+  DCHECK(!texture_to_produce.get() || !skip_frame);
+  if (texture_to_produce.get()) {
     ack.mailbox_name = texture_to_produce->Produce();
     sync_point =
         content::ImageTransportFactory::GetInstance()->InsertSyncPoint();
   } else if (skip_frame) {
     ack.mailbox_name = received_mailbox;
     ack.sync_point = 0;
   }
 
   ack.sync_point = sync_point;
   RenderWidgetHostImpl::AcknowledgeBufferPresent(
@@ skipping 377 matching lines @@
 void RenderWidgetHostViewAura::WasShown() {
   if (!host_->is_hidden())
     return;
   host_->WasShown();
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client)
     NotifyRendererOfCursorVisibilityState(cursor_client->IsCursorVisible());
 
-  if (!current_surface_ && host_->is_accelerated_compositing_active() &&
+  if (!current_surface_.get() && host_->is_accelerated_compositing_active() &&
       !released_front_lock_.get()) {
     released_front_lock_ = GetCompositor()->GetCompositorLock();
   }
 
 #if defined(OS_WIN)
   LPARAM lparam = reinterpret_cast<LPARAM>(this);
   EnumChildWindows(ui::GetHiddenWindow(), ShowWindowsCallback, lparam);
   transient_observer_->SendPluginCutoutRects();
 #endif
 }
@@ skipping 198 matching lines @@
 
 void RenderWidgetHostViewAura::Blur() {
   window_->Blur();
 }
 
 bool RenderWidgetHostViewAura::HasFocus() const {
   return window_->HasFocus();
 }
 
 bool RenderWidgetHostViewAura::IsSurfaceAvailableForCopy() const {
-  return current_surface_ ||
-      current_software_frame_.IsValid() ||
-      !!host_->GetBackingStore(false);
+  return current_surface_.get() || current_software_frame_.IsValid() ||
+         !!host_->GetBackingStore(false);
 }
 
 void RenderWidgetHostViewAura::Show() {
   window_->Show();
 }
 
 void RenderWidgetHostViewAura::Hide() {
   window_->Hide();
 }
 
@@ skipping 242 matching lines @@
       src_subrect_in_pixel,
       dst_size_in_pixel,
       addr,
       wrapper_callback);
 }
 
 void RenderWidgetHostViewAura::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const base::Callback<void(bool, const SkBitmap&)>& callback) {
-  if (!current_surface_) {
+  if (!current_surface_.get()) {
     callback.Run(false, SkBitmap());
     return;
   }
 
   CopyFromCompositingSurfaceHelper(src_subrect,
                                    ConvertViewSizeToPixel(this, dst_size),
                                    callback);
 }
 
 void RenderWidgetHostViewAura::CopyFromCompositingSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback) {
   base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
 
-  if (!current_surface_)
+  if (!current_surface_.get())
     return;
 
   // Compute the dest size we want after the letterboxing resize. Make the
   // coordinates and sizes even because we letterbox in YUV space
   // (see CopyRGBToVideoFrame). They need to be even for the UV samples to
   // line up correctly.
   // The video frame's coded_size() is in pixels and src_subrect is in DIP, but
   // we are only concerned with the video frame's aspect ratio in this case.
   gfx::Rect region_in_frame =
       media::ComputeLetterboxRegion(gfx::Rect(target->coded_size()),
@@ skipping 42 matching lines @@
                                              current_surface_->size(),
                                              src_subrect_in_pixel,
                                              target->coded_size(),
                                              region_in_frame,
                                              true,
                                              true));
   }
 
   scoped_callback_runner.Release();
   yuv_readback_pipeline_->ReadbackYUV(
-      current_surface_->PrepareTexture(),
-      target,
-      callback);
+      current_surface_->PrepareTexture(), target.get(), callback);
 }
 
 bool RenderWidgetHostViewAura::CanCopyToVideoFrame() const {
   // TODO(skaslev): Implement this path for s/w compositing.
-  return current_surface_ != NULL && host_->is_accelerated_compositing_active();
+  return current_surface_.get() != NULL &&
+         host_->is_accelerated_compositing_active();
 }
 
 bool RenderWidgetHostViewAura::CanSubscribeFrame() const {
   return true;
 }
 
 void RenderWidgetHostViewAura::BeginFrameSubscription(
     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
   frame_subscriber_ = subscriber.Pass();
 }
@@ skipping 40 matching lines @@
 }
 
 void RenderWidgetHostViewAura::UpdateExternalTexture() {
   // Delay processing accelerated compositing state change till here where we
   // act upon the state change. (Clear the external texture if switching to
   // software mode or set the external texture if going to accelerated mode).
   if (accelerated_compositing_state_changed_)
     accelerated_compositing_state_changed_ = false;
 
   bool is_compositing_active = host_->is_accelerated_compositing_active();
-  if (is_compositing_active && current_surface_) {
+  if (is_compositing_active && current_surface_.get()) {
     window_->layer()->SetExternalTexture(current_surface_.get());
     current_frame_size_ = ConvertSizeToDIP(
         current_surface_->device_scale_factor(), current_surface_->size());
     CheckResizeLock();
   } else if (is_compositing_active &&
              current_software_frame_.IsSharedMemory()) {
     window_->layer()->SetTextureMailbox(current_software_frame_,
                                         last_swapped_surface_scale_factor_);
     current_frame_size_ = ConvertSizeToDIP(
         last_swapped_surface_scale_factor_,
@@ skipping 25 matching lines @@
                                        surface_rect.size())) ||
       mailbox_name.empty()) {
     skipped_damage_.op(RectToSkIRect(damage_rect), SkRegion::kUnion_Op);
     ack_callback.Run(true, scoped_refptr<ui::Texture>());
     return false;
   }
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   current_surface_ =
       factory->CreateTransportClient(surface_scale_factor);
-  if (!current_surface_) {
+  if (!current_surface_.get()) {
     LOG(ERROR) << "Failed to create ImageTransport texture";
     ack_callback.Run(true, scoped_refptr<ui::Texture>());
     return false;
   }
 
   current_surface_->Consume(mailbox_name, surface_rect.size());
   released_front_lock_ = NULL;
   UpdateExternalTexture();
 
   return true;
 }
 
 void RenderWidgetHostViewAura::SwapBuffersCompleted(
     const BufferPresentedCallback& ack_callback,
     const scoped_refptr<ui::Texture>& texture_to_return) {
   ui::Compositor* compositor = GetCompositor();
 
-  if (frame_subscriber() && current_surface_ != NULL) {
+  if (frame_subscriber() && current_surface_.get() != NULL) {
     const base::Time present_time = base::Time::Now();
     scoped_refptr<media::VideoFrame> frame;
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
     if (frame_subscriber()->ShouldCaptureFrame(present_time,
                                                &frame, &callback)) {
       CopyFromCompositingSurfaceToVideoFrame(
           gfx::Rect(ConvertSizeToDIP(current_surface_->device_scale_factor(),
                                      current_surface_->size())),
           frame,
           base::Bind(callback, present_time));
@@ skipping 246 matching lines @@
   }
 
   DCHECK(surface_rect.Contains(SkIRectToRect(damage.getBounds())));
   ui::Texture* current_texture = current_surface_.get();
 
   const gfx::Size surface_size_in_pixel = surface_size;
   DLOG_IF(ERROR, previous_texture &&
       previous_texture->size() != current_texture->size() &&
       SkIRectToRect(damage.getBounds()) != surface_rect) <<
       "Expected full damage rect after size change";
-  if (previous_texture && !previous_damage_.isEmpty() &&
+  if (previous_texture.get() && !previous_damage_.isEmpty() &&
       previous_texture->size() == current_texture->size()) {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     GLHelper* gl_helper = factory->GetGLHelper();
     gl_helper->CopySubBufferDamage(
         current_texture->PrepareTexture(),
         previous_texture->PrepareTexture(),
         damage,
         previous_damage_);
   }
   previous_damage_ = damage;
@@ skipping 42 matching lines @@
                  params_in_pixel.mailbox_name,
                  params_in_pixel.latency_info,
                  ack_callback);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease() {
   // This really tells us to release the frontbuffer.
-  if (current_surface_) {
+  if (current_surface_.get()) {
     ui::Compositor* compositor = GetCompositor();
     if (compositor) {
       // We need to wait for a commit to clear to guarantee that all we
       // will not issue any more GL referencing the previous surface.
       AddOnCommitCallbackAndDisableLocks(
           base::Bind(&RenderWidgetHostViewAura::
                      SetSurfaceNotInUseByCompositor,
                      AsWeakPtr(),
                      current_surface_));  // Hold a ref so the texture will not
                                           // get deleted until after commit.
@@ skipping 507 matching lines @@
 
 scoped_refptr<ui::Texture> RenderWidgetHostViewAura::CopyTexture() {
   if (!host_->is_accelerated_compositing_active())
     return scoped_refptr<ui::Texture>();
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   GLHelper* gl_helper = factory->GetGLHelper();
   if (!gl_helper)
     return scoped_refptr<ui::Texture>();
 
-  if (!current_surface_)
+  if (!current_surface_.get())
     return scoped_refptr<ui::Texture>();
 
   WebKit::WebGLId texture_id =
       gl_helper->CopyTexture(current_surface_->PrepareTexture(),
                              current_surface_->size());
   if (!texture_id)
     return scoped_refptr<ui::Texture>();
 
   return scoped_refptr<ui::Texture>(
       factory->CreateOwnedTexture(
@@ skipping 735 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content