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

gpu/command_buffer/service/async_pixel_transfer_delegate_share_group.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/async_pixel_transfer_delegate_share_group.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 68 matching lines @@
                                    base::WaitableEvent* caller_wait) {
     TRACE_EVENT0("gpu", "InitializeOnTransferThread");
 
     if (!parent_context) {
       LOG(ERROR) << "No parent context provided.";
       caller_wait->Signal();
       return;
     }
 
     surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false, gfx::Size(1, 1));
-    if (!surface_) {
+    if (!surface_.get()) {
       LOG(ERROR) << "Unable to create GLSurface";
       caller_wait->Signal();
       return;
     }
 
     // TODO(backer): This is coded for integrated GPUs. For discrete GPUs
     // we would probably want to use a PBO texture upload for a true async
     // upload (that would hopefully be optimized as a DMA transfer by the
     // driver).
     context_ = gfx::GLContext::CreateGLContext(parent_context->share_group(),
-                                               surface_,
+                                               surface_.get(),
                                                gfx::PreferIntegratedGpu);
-    if (!context_) {
+    if (!context_.get()) {
       LOG(ERROR) << "Unable to create GLContext.";
       caller_wait->Signal();
       return;
     }
 
-    context_->MakeCurrent(surface_);
+    context_->MakeCurrent(surface_.get());
     initialized_ = true;
     caller_wait->Signal();
   }
 
   DISALLOW_COPY_AND_ASSIGN(TransferThread);
 };
 
 base::LazyInstance<TransferThread>::Leaky
     g_transfer_thread = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 103 matching lines @@
 
     TRACE_EVENT2("gpu",
                  "PerformAsyncTexSubImage2D",
                  "width",
                  tex_params.width,
                  "height",
                  tex_params.height);
     DCHECK_EQ(0, tex_params.level);
 
     base::TimeTicks begin_time;
-    if (texture_upload_stats)
+    if (texture_upload_stats.get())
       begin_time = base::TimeTicks::HighResNow();
 
     void* data =
         AsyncPixelTransferDelegate::GetAddress(safe_shared_memory, mem_params);
 
     {
       TRACE_EVENT0("gpu", "glTexSubImage2D");
       glBindTexture(GL_TEXTURE_2D, texture_id_);
       glTexSubImage2D(GL_TEXTURE_2D,
                       tex_params.level,
                       tex_params.xoffset,
                       tex_params.yoffset,
                       tex_params.width,
                       tex_params.height,
                       tex_params.format,
                       tex_params.type,
                       data);
       glBindTexture(GL_TEXTURE_2D, 0);
     }
 
     MarkAsCompleted();
 
-    if (texture_upload_stats) {
+    if (texture_upload_stats.get()) {
       texture_upload_stats->AddUpload(base::TimeTicks::HighResNow() -
                                       begin_time);
     }
   }
 
   base::CancellationFlag* cancel_upload_flag() { return &cancel_upload_flag_; }
   base::Lock* upload_lock() { return &upload_lock_; }
 
  private:
   friend class base::RefCountedThreadSafe<TransferStateInternal>;
@@ skipping 117 matching lines @@
                      new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                 mem_params.shared_memory,
                                                 mem_params.shm_size)),
                  callback));
 }
 
 void AsyncPixelTransferDelegateShareGroup::WaitForTransferCompletion(
       AsyncPixelTransferState* transfer_state) {
   scoped_refptr<TransferStateInternal> state =
       static_cast<AsyncTransferStateImpl*>(transfer_state)->internal();
-  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());
 
 #if defined(OS_ANDROID) || defined(OS_LINUX)
     g_transfer_thread.Pointer()->SetPriority(base::kThreadPriority_Background);
 #endif
   }
 }
 
 void AsyncPixelTransferDelegateShareGroup::AsyncTexImage2D(
     AsyncPixelTransferState* transfer_state,
     const AsyncTexImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params,
     const base::Closure& bind_callback) {
   scoped_refptr<TransferStateInternal> state =
       static_cast<AsyncTransferStateImpl*>(transfer_state)->internal();
   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(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->SetBindCallback(bind_callback);
 
@@ skipping 44 matching lines @@
           state,
           tex_params,
           mem_params,
           base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                  mem_params.shared_memory,
                                                  mem_params.shm_size)),
           texture_upload_stats_));
 }
 
 uint32 AsyncPixelTransferDelegateShareGroup::GetTextureUploadCount() {
-  DCHECK(texture_upload_stats_);
+  DCHECK(texture_upload_stats_.get());
   return texture_upload_stats_->GetStats(NULL);
 }
 
 base::TimeDelta
     AsyncPixelTransferDelegateShareGroup::GetTotalTextureUploadTime() {
-  DCHECK(texture_upload_stats_);
+  DCHECK(texture_upload_stats_.get());
   base::TimeDelta total_texture_upload_time;
   texture_upload_stats_->GetStats(&total_texture_upload_time);
   return total_texture_upload_time;
 }
 
 void AsyncPixelTransferDelegateShareGroup::ProcessMorePendingTransfers() {
 }
 
 bool AsyncPixelTransferDelegateShareGroup::NeedsProcessMorePendingTransfers() {
   return false;
 }
 
 }  // namespace gpu