Remove implicit conversions from scoped_refptr to T* in cc/

cc/output/output_surface.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 "cc/output/output_surface.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 99 matching lines @@
 
 bool OutputSurface::HasExternalStencilTest() const {
   return external_stencil_test_enabled_;
 }
 
 bool OutputSurface::BindToClient(OutputSurfaceClient* client) {
   DCHECK(client);
   client_ = client;
   bool success = true;
 
-  if (context_provider_) {
+  if (context_provider_.get()) {
     success = context_provider_->BindToCurrentThread();
     if (success)
       SetUpContext3d();
   }
 
   if (!success)
     client_ = NULL;
 
   return success;
 }
 
 bool OutputSurface::InitializeAndSetContext3d(
     scoped_refptr<ContextProvider> context_provider) {
-  DCHECK(!context_provider_);
-  DCHECK(context_provider);
+  DCHECK(!context_provider_.get());
+  DCHECK(context_provider.get());
   DCHECK(client_);
 
   bool success = false;
   if (context_provider->BindToCurrentThread()) {
     context_provider_ = context_provider;
     SetUpContext3d();
     client_->DeferredInitialize();
     success = true;
   }
 
   if (!success)
     ResetContext3d();
 
   return success;
 }
 
 void OutputSurface::ReleaseGL() {
   DCHECK(client_);
-  DCHECK(context_provider_);
+  DCHECK(context_provider_.get());
   client_->ReleaseGL();
-  DCHECK(!context_provider_);
+  DCHECK(!context_provider_.get());
 }
 
 void OutputSurface::SetUpContext3d() {
-  DCHECK(context_provider_);
+  DCHECK(context_provider_.get());
   DCHECK(client_);
 
   context_provider_->SetLostContextCallback(
       base::Bind(&OutputSurface::DidLoseOutputSurface,
                  base::Unretained(this)));
   context_provider_->ContextSupport()->SetSwapBuffersCompleteCallback(
       base::Bind(&OutputSurface::OnSwapBuffersComplete,
                  base::Unretained(this)));
   context_provider_->SetMemoryPolicyChangedCallback(
       base::Bind(&OutputSurface::SetMemoryPolicy,
                  base::Unretained(this)));
 }
 
 void OutputSurface::ReleaseContextProvider() {
   DCHECK(client_);
-  DCHECK(context_provider_);
+  DCHECK(context_provider_.get());
   ResetContext3d();
 }
 
 void OutputSurface::ResetContext3d() {
   if (context_provider_.get()) {
     context_provider_->SetLostContextCallback(
         ContextProvider::LostContextCallback());
     context_provider_->SetMemoryPolicyChangedCallback(
         ContextProvider::MemoryPolicyChangedCallback());
     if (gpu::ContextSupport* support = context_provider_->ContextSupport())
       support->SetSwapBuffersCompleteCallback(base::Closure());
   }
   context_provider_ = NULL;
 }
 
 void OutputSurface::EnsureBackbuffer() {
   if (software_device_)
     software_device_->EnsureBackbuffer();
 }
 
 void OutputSurface::DiscardBackbuffer() {
-  if (context_provider_)
+  if (context_provider_.get())
     context_provider_->ContextGL()->DiscardBackbufferCHROMIUM();
   if (software_device_)
     software_device_->DiscardBackbuffer();
 }
 
 void OutputSurface::Reshape(const gfx::Size& size, float scale_factor) {
   if (size == surface_size_ && scale_factor == device_scale_factor_)
     return;
 
   surface_size_ = size;
   device_scale_factor_ = scale_factor;
-  if (context_provider_) {
+  if (context_provider_.get()) {
     context_provider_->ContextGL()->ResizeCHROMIUM(
         size.width(), size.height(), scale_factor);
   }
   if (software_device_)
     software_device_->Resize(size, scale_factor);
 }
 
 gfx::Size OutputSurface::SurfaceSize() const {
   return surface_size_;
 }
 
 void OutputSurface::BindFramebuffer() {
-  DCHECK(context_provider_);
+  DCHECK(context_provider_.get());
   context_provider_->ContextGL()->BindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
 void OutputSurface::SwapBuffers(CompositorFrame* frame) {
   if (frame->software_frame_data) {
     PostSwapBuffersComplete();
     client_->DidSwapBuffers();
     return;
   }
 
-  DCHECK(context_provider_);
+  DCHECK(context_provider_.get());
   DCHECK(frame->gl_frame_data);
 
   if (frame->gl_frame_data->sub_buffer_rect ==
       gfx::Rect(frame->gl_frame_data->size)) {
     context_provider_->ContextSupport()->Swap();
   } else {
     context_provider_->ContextSupport()->PartialSwapBuffers(
         frame->gl_frame_data->sub_buffer_rect);
   }
 
@@ skipping 17 matching lines @@
   TRACE_EVENT1("cc", "OutputSurface::SetMemoryPolicy",
                "bytes_limit_when_visible", policy.bytes_limit_when_visible);
   // Just ignore the memory manager when it says to set the limit to zero
   // bytes. This will happen when the memory manager thinks that the renderer
   // is not visible (which the renderer knows better).
   if (policy.bytes_limit_when_visible)
     client_->SetMemoryPolicy(policy);
 }
 
 }  // namespace cc