Remove implicit conversions from scoped_refptr to T* in content/browser/compositor

content/browser/compositor/delegated_frame_host.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/browser/compositor/delegated_frame_host.h"
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 45 matching lines @@
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
       can_lock_compositor_(YES_CAN_LOCK),
       delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
   ImageTransportFactory::GetInstance()->AddObserver(this);
 }
 
 void DelegatedFrameHost::WasShown(const ui::LatencyInfo& latency_info) {
   delegated_frame_evictor_->SetVisible(true);
 
-  if (surface_id_.is_null() && !frame_provider_ &&
+  if (surface_id_.is_null() && !frame_provider_.get() &&
       !released_front_lock_.get()) {
     ui::Compositor* compositor = client_->GetCompositor();
     if (compositor)
       released_front_lock_ = compositor->GetCompositorLock();
   }
 
   ui::Compositor* compositor = client_->GetCompositor();
   if (compositor) {
     compositor->SetLatencyInfo(latency_info);
   }
@@ skipping 302 matching lines @@
       scoped_ptr<cc::CompositorFrame> compositor_frame =
           make_scoped_ptr(new cc::CompositorFrame());
       compositor_frame->delegated_frame_data = frame_data.Pass();
       surface_factory_->SubmitFrame(
           surface_id_,
           compositor_frame.Pass(),
           base::Bind(&DelegatedFrameHost::SendDelegatedFrameAck,
                      AsWeakPtr(),
                      output_surface_id));
     } else {
-      if (!resource_collection_) {
+      if (!resource_collection_.get()) {
         resource_collection_ = new cc::DelegatedFrameResourceCollection;
         resource_collection_->SetClient(this);
       }
       // If the physical frame size changes, we need a new |frame_provider_|. If
       // the physical frame size is the same, but the size in DIP changed, we
       // need to adjust the scale at which the frames will be drawn, and we do
       // this by making a new |frame_provider_| also to ensure the scale change
       // is presented in sync with the new frame content.
       if (!frame_provider_.get() ||
           frame_size != frame_provider_->frame_size() ||
@@ skipping 42 matching lines @@
   if (frame_provider_.get() || !surface_id_.is_null())
     delegated_frame_evictor_->SwappedFrame(!host->is_hidden());
   // Note: the frame may have been evicted immediately.
 }
 
 void DelegatedFrameHost::SendDelegatedFrameAck(uint32 output_surface_id) {
   RenderWidgetHostImpl* host = client_->GetHost();
   cc::CompositorFrameAck ack;
   if (!surface_returned_resources_.empty())
     ack.resources.swap(surface_returned_resources_);
-  if (resource_collection_)
+  if (resource_collection_.get())
     resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(host->GetRoutingID(),
                                                    output_surface_id,
                                                    host->GetProcess()->GetID(),
                                                    ack);
   DCHECK_GT(pending_delegated_ack_count_, 0);
   pending_delegated_ack_count_--;
 }
 
 void DelegatedFrameHost::UnusedResourcesAreAvailable() {
   if (pending_delegated_ack_count_)
     return;
 
   SendReturnedDelegatedResources(last_output_surface_id_);
 }
 
 void DelegatedFrameHost::SendReturnedDelegatedResources(
     uint32 output_surface_id) {
   RenderWidgetHostImpl* host = client_->GetHost();
 
   cc::CompositorFrameAck ack;
   if (!surface_returned_resources_.empty()) {
     ack.resources.swap(surface_returned_resources_);
   } else {
-    DCHECK(resource_collection_);
+    DCHECK(resource_collection_.get());
     resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
   }
   DCHECK(!ack.resources.empty());
 
   RenderWidgetHostImpl::SendReclaimCompositorResources(
       host->GetRoutingID(),
       output_surface_id,
       host->GetProcess()->GetID(),
       ack);
 }
@@ skipping 157 matching lines @@
   callback.Run(result);
 
   uint32 sync_point = 0;
   if (result) {
     GLHelper* gl_helper = ImageTransportFactory::GetInstance()->GetGLHelper();
     sync_point = gl_helper->InsertSyncPoint();
   }
   if (release_callback) {
     // A release callback means the texture came from the compositor, so there
     // should be no |subscriber_texture|.
-    DCHECK(!subscriber_texture);
+    DCHECK(!subscriber_texture.get());
     bool lost_resource = sync_point == 0;
     release_callback->Run(sync_point, lost_resource);
   }
   ReturnSubscriberTexture(dfh, subscriber_texture, sync_point);
 }
 
 // static
 void DelegatedFrameHost::CopyFromCompositingSurfaceHasResultForVideo(
     base::WeakPtr<DelegatedFrameHost> dfh,
     scoped_refptr<OwnedMailbox> subscriber_texture,
@@ skipping 190 matching lines @@
 // DelegatedFrameHost, private:
 
 DelegatedFrameHost::~DelegatedFrameHost() {
   ImageTransportFactory::GetInstance()->RemoveObserver(this);
 
   if (!surface_id_.is_null())
     surface_factory_->Destroy(surface_id_);
   if (resource_collection_.get())
     resource_collection_->SetClient(NULL);
 
-  DCHECK(!vsync_manager_);
+  DCHECK(!vsync_manager_.get());
 }
 
 void DelegatedFrameHost::RunOnCommitCallbacks() {
   for (std::vector<base::Closure>::const_iterator
       it = on_compositing_did_commit_callbacks_.begin();
       it != on_compositing_did_commit_callbacks_.end(); ++it) {
     it->Run();
   }
   on_compositing_did_commit_callbacks_.clear();
 }
 
 void DelegatedFrameHost::AddOnCommitCallbackAndDisableLocks(
     const base::Closure& callback) {
   ui::Compositor* compositor = client_->GetCompositor();
   DCHECK(compositor);
 
   if (!compositor->HasObserver(this))
     compositor->AddObserver(this);
 
   can_lock_compositor_ = NO_PENDING_COMMIT;
   on_compositing_did_commit_callbacks_.push_back(callback);
 }
 
 void DelegatedFrameHost::AddedToWindow() {
   ui::Compositor* compositor = client_->GetCompositor();
   if (compositor) {
-    DCHECK(!vsync_manager_);
+    DCHECK(!vsync_manager_.get());
     vsync_manager_ = compositor->vsync_manager();
     vsync_manager_->AddObserver(this);
   }
 }
 
 void DelegatedFrameHost::RemovingFromWindow() {
   RunOnCommitCallbacks();
   resize_lock_.reset();
   client_->GetHost()->WasResized();
   ui::Compositor* compositor = client_->GetCompositor();
   if (compositor && compositor->HasObserver(this))
     compositor->RemoveObserver(this);
 
-  if (vsync_manager_) {
+  if (vsync_manager_.get()) {
     vsync_manager_->RemoveObserver(this);
     vsync_manager_ = NULL;
   }
 }
 
 void DelegatedFrameHost::LockResources() {
-  DCHECK(frame_provider_ || !surface_id_.is_null());
+  DCHECK(frame_provider_.get() || !surface_id_.is_null());
   delegated_frame_evictor_->LockFrame();
 }
 
 void DelegatedFrameHost::UnlockResources() {
-  DCHECK(frame_provider_ || !surface_id_.is_null());
+  DCHECK(frame_provider_.get() || !surface_id_.is_null());
   delegated_frame_evictor_->UnlockFrame();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, ui::LayerOwnerDelegate implementation:
 
 void DelegatedFrameHost::OnLayerRecreated(ui::Layer* old_layer,
                                                 ui::Layer* new_layer) {
   // The new_layer is the one that will be used by our Window, so that's the one
   // that should keep our frame. old_layer will be returned to the
   // RecreateLayer caller, and should have a copy.
   if (frame_provider_.get()) {
     new_layer->SetShowDelegatedContent(frame_provider_.get(),
                                        current_frame_size_in_dip_);
   }
   if (!surface_id_.is_null()) {
     new_layer->SetShowSurface(surface_id_, current_frame_size_in_dip_);
   }
 }
 
 }  // namespace content