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

gpu/command_buffer/service/async_pixel_transfer_delegate_egl.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 "gpu/command_buffer/service/async_pixel_transfer_delegate_egl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 75 matching lines @@
   }
   virtual ~TransferThread() {
     Stop();
   }
 
   virtual void Init() OVERRIDE {
     gfx::GLShareGroup* share_group = NULL;
     bool software = false;
     surface_ = new gfx::PbufferGLSurfaceEGL(software, gfx::Size(1,1));
     surface_->Initialize();
-    context_ = gfx::GLContext::CreateGLContext(share_group,
-                                               surface_,
-                                               gfx::PreferDiscreteGpu);
-    bool is_current = context_->MakeCurrent(surface_);
+    context_ = gfx::GLContext::CreateGLContext(
+        share_group, surface_.get(), gfx::PreferDiscreteGpu);
+    bool is_current = context_->MakeCurrent(surface_.get());
     DCHECK(is_current);
   }
 
   virtual void CleanUp() OVERRIDE {
     surface_ = NULL;
-    context_->ReleaseCurrent(surface_);
+    context_->ReleaseCurrent(surface_.get());
     context_ = NULL;
   }
 
   SafeSharedMemoryPool* safe_shared_memory_pool() {
       return &safe_shared_memory_pool_;
   }
 
  private:
   scoped_refptr<gfx::GLContext> context_;
   scoped_refptr<gfx::GLSurface> surface_;
@@ skipping 181 matching lines @@
                  "height",
                  tex_params.height);
 
     DCHECK_NE(EGL_NO_IMAGE_KHR, egl_image_);
     DCHECK_EQ(0, tex_params.level);
 
     void* data =
         AsyncPixelTransferDelegate::GetAddress(safe_shared_memory, mem_params);
 
     base::TimeTicks begin_time;
-    if (texture_upload_stats)
+    if (texture_upload_stats.get())
       begin_time = base::TimeTicks::HighResNow();
 
     if (!thread_texture_id_) {
       TRACE_EVENT0("gpu", "glEGLImageTargetTexture2DOES");
       glGenTextures(1, &thread_texture_id_);
       glActiveTexture(GL_TEXTURE0);
       glBindTexture(GL_TEXTURE_2D, thread_texture_id_);
       glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, egl_image_);
     } else {
       glActiveTexture(GL_TEXTURE0);
       glBindTexture(GL_TEXTURE_2D, thread_texture_id_);
     }
     {
       TRACE_EVENT0("gpu", "glTexSubImage2D");
       DoTexSubImage2D(tex_params, data);
     }
     WaitForLastUpload();
     MarkAsCompleted();
 
     DCHECK(CHECK_GL());
-    if (texture_upload_stats) {
+    if (texture_upload_stats.get()) {
       texture_upload_stats->AddUpload(base::TimeTicks::HighResNow() -
                                       begin_time);
     }
   }
 
  protected:
   friend class base::RefCountedThreadSafe<TransferStateInternal>;
   friend class gpu::AsyncPixelTransferDelegateEGL;
 
   static void DeleteTexture(GLuint id) {
@@ skipping 149 matching lines @@
                      new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                 mem_params.shared_memory,
                                                 mem_params.shm_size)),
                  callback));
 }
 
 void AsyncPixelTransferDelegateEGL::WaitForTransferCompletion(
       AsyncPixelTransferState* transfer_state) {
   scoped_refptr<TransferStateInternal> state =
       static_cast<AsyncTransferStateImpl*>(transfer_state)->internal_.get();
-  DCHECK(state);
+  DCHECK(state.get());
   DCHECK(state->texture_id_);
 
   if (state->TransferIsInProgress()) {
 #if defined(OS_ANDROID) || defined(OS_LINUX)
     g_transfer_thread.Pointer()->SetPriority(base::kThreadPriority_Display);
 #endif
 
     state->WaitForTransferCompletion();
     DCHECK(!state->TransferIsInProgress());
 
@@ skipping 10 matching lines @@
     const base::Closure& bind_callback) {
   if (WorkAroundAsyncTexImage2D(transfer_state, tex_params,
                                 mem_params, bind_callback))
     return;
 
   scoped_refptr<TransferStateInternal> state =
       static_cast<AsyncTransferStateImpl*>(transfer_state)->internal_.get();
   DCHECK(mem_params.shared_memory);
   DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
             mem_params.shm_size);
-  DCHECK(state);
+  DCHECK(state.get());
   DCHECK(state->texture_id_);
   DCHECK(!state->TransferIsInProgress());
   DCHECK_EQ(state->egl_image_, EGL_NO_IMAGE_KHR);
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
   DCHECK_EQ(tex_params.level, 0);
 
   // Mark the transfer in progress and save the late bind
   // callback, so we can notify the client when it is bound.
   pending_allocations_.push_back(transfer_state->AsWeakPtr());
   state->bind_callback_ = bind_callback;
@@ skipping 54 matching lines @@
           mem_params,
           base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                  mem_params.shared_memory,
                                                  mem_params.shm_size)),
           texture_upload_stats_));
 
   DCHECK(CHECK_GL());
 }
 
 uint32 AsyncPixelTransferDelegateEGL::GetTextureUploadCount() {
-  CHECK(texture_upload_stats_);
+  CHECK(texture_upload_stats_.get());
   return texture_upload_stats_->GetStats(NULL);
 }
 
 base::TimeDelta AsyncPixelTransferDelegateEGL::GetTotalTextureUploadTime() {
-  CHECK(texture_upload_stats_);
+  CHECK(texture_upload_stats_.get());
   base::TimeDelta total_texture_upload_time;
   texture_upload_stats_->GetStats(&total_texture_upload_time);
   return total_texture_upload_time;
 }
 
 void AsyncPixelTransferDelegateEGL::ProcessMorePendingTransfers() {
 }
 
 bool AsyncPixelTransferDelegateEGL::NeedsProcessMorePendingTransfers() {
   return false;
@@ skipping 104 matching lines @@
   DCHECK_EQ(tex_params.xoffset, 0);
   DCHECK_EQ(tex_params.yoffset, 0);
   DCHECK_EQ(state->define_params_.width, tex_params.width);
   DCHECK_EQ(state->define_params_.height, tex_params.height);
   DCHECK_EQ(state->define_params_.level, tex_params.level);
   DCHECK_EQ(state->define_params_.format, tex_params.format);
   DCHECK_EQ(state->define_params_.type, tex_params.type);
 
   void* data = GetAddress(mem_params);
   base::TimeTicks begin_time;
-  if (texture_upload_stats_)
+  if (texture_upload_stats_.get())
     begin_time = base::TimeTicks::HighResNow();
   {
     TRACE_EVENT0("gpu", "glTexSubImage2D");
     // Note we use define_params_ instead of tex_params.
     // The DCHECKs above verify this is always the same.
     DoTexImage2D(state->define_params_, data);
   }
-  if (texture_upload_stats_) {
-    texture_upload_stats_->AddUpload(
-        base::TimeTicks::HighResNow() - begin_time);
+  if (texture_upload_stats_.get()) {
+    texture_upload_stats_->AddUpload(base::TimeTicks::HighResNow() -
+                                     begin_time);
   }
 
   DCHECK(CHECK_GL());
   return true;
 }
 
 }  // namespace gpu