Remove implicit conversions from scoped_refptr to T* in gpu/

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 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 "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
@@ skipping 193 matching lines @@
 }
 
 InProcessCommandBuffer::InProcessCommandBuffer(
     const scoped_refptr<Service>& service)
     : context_lost_(false),
       idle_work_pending_(false),
       last_put_offset_(-1),
       flush_event_(false, false),
       service_(service.get() ? service : GetDefaultService()),
       gpu_thread_weak_ptr_factory_(this) {
-  if (!service) {
+  if (!service.get()) {
     base::AutoLock lock(default_thread_clients_lock_.Get());
     default_thread_clients_.Get().insert(this);
   }
 }
 
 InProcessCommandBuffer::~InProcessCommandBuffer() {
   Destroy();
   base::AutoLock lock(default_thread_clients_lock_.Get());
   default_thread_clients_.Get().erase(this);
 }
@@ skipping 38 matching lines @@
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const std::vector<int32>& attribs,
     gfx::GpuPreference gpu_preference,
     const base::Closure& context_lost_callback,
     InProcessCommandBuffer* share_group) {
   DCHECK(!share_group || service_ == share_group->service_);
   context_lost_callback_ = WrapCallback(context_lost_callback);
 
-  if (surface) {
+  if (surface.get()) {
     // GPU thread must be the same as client thread due to GLSurface not being
     // thread safe.
     sequence_checker_.reset(new base::SequenceChecker);
     surface_ = surface;
   }
 
   gpu::Capabilities capabilities;
   InitializeOnGpuThreadParams params(is_offscreen,
                                      window,
                                      size,
@@ skipping 64 matching lines @@
                                     bind_generates_resource)));
 
   gpu_scheduler_.reset(
       new GpuScheduler(command_buffer.get(), decoder_.get(), decoder_.get()));
   command_buffer->SetGetBufferChangeCallback(base::Bind(
       &GpuScheduler::SetGetBuffer, base::Unretained(gpu_scheduler_.get())));
   command_buffer_ = command_buffer.Pass();
 
   decoder_->set_engine(gpu_scheduler_.get());
 
-  if (!surface_) {
+  if (!surface_.get()) {
     if (params.is_offscreen)
       surface_ = gfx::GLSurface::CreateOffscreenGLSurface(params.size);
     else
       surface_ = gfx::GLSurface::CreateViewGLSurface(params.window);
   }
 
   if (!surface_.get()) {
     LOG(ERROR) << "Could not create GLSurface.";
     DestroyOnGpuThread();
     return false;
@@ skipping 64 matching lines @@
   QueueTask(
       base::Bind(&RunTaskWithResult<bool>, destroy_task, &result, &completion));
   completion.Wait();
 }
 
 bool InProcessCommandBuffer::DestroyOnGpuThread() {
   CheckSequencedThread();
   gpu_thread_weak_ptr_factory_.InvalidateWeakPtrs();
   command_buffer_.reset();
   // Clean up GL resources if possible.
-  bool have_context = context_ && context_->MakeCurrent(surface_);
+  bool have_context = context_.get() && context_->MakeCurrent(surface_.get());
   if (decoder_) {
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
   context_ = NULL;
   surface_ = NULL;
   gl_share_group_ = NULL;
 #if defined(OS_ANDROID)
   stream_texture_manager_.reset();
 #endif
@@ skipping 188 matching lines @@
 
 void InProcessCommandBuffer::RegisterGpuMemoryBufferOnGpuThread(
     int32 id,
     const gfx::GpuMemoryBufferHandle& handle,
     size_t width,
     size_t height,
     unsigned internalformat) {
   scoped_refptr<gfx::GLImage> image =
       g_gpu_memory_buffer_factory->CreateImageForGpuMemoryBuffer(
           handle, gfx::Size(width, height), internalformat);
-  if (!image)
+  if (!image.get())
     return;
 
   // For Android specific workaround.
   gles2::ContextGroup* context_group = decoder_->GetContextGroup();
   if (context_group->feature_info()->workarounds().release_image_after_use)
     image->SetReleaseAfterUse();
 
   if (decoder_) {
     gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
     DCHECK(image_manager);
@@ skipping 178 matching lines @@
 }
 #endif
 
 // static
 void InProcessCommandBuffer::SetGpuMemoryBufferFactory(
     InProcessGpuMemoryBufferFactory* factory) {
   g_gpu_memory_buffer_factory = factory;
 }
 
 }  // namespace gpu