Remove implicit conversions from scoped_refptr to T* in content/*/gpu/

content/browser/gpu/browser_gpu_channel_host_factory.cc

 // Copyright (c) 2012 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/gpu/browser_gpu_channel_host_factory.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 198 matching lines @@
 
 BrowserGpuChannelHostFactory::BrowserGpuChannelHostFactory()
     : gpu_client_id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()),
       shutdown_event_(new base::WaitableEvent(true, false)),
       gpu_host_id_(0),
       next_create_gpu_memory_buffer_request_id_(0) {
 }
 
 BrowserGpuChannelHostFactory::~BrowserGpuChannelHostFactory() {
   DCHECK(IsMainThread());
-  if (pending_request_)
+  if (pending_request_.get())
     pending_request_->Cancel();
   for (size_t n = 0; n < established_callbacks_.size(); n++)
     established_callbacks_[n].Run();
   shutdown_event_->Signal();
 }
 
 bool BrowserGpuChannelHostFactory::IsMainThread() {
   return BrowserThread::CurrentlyOn(BrowserThread::UI);
 }
 
@@ skipping 64 matching lines @@
                "BrowserGpuChannelHostFactory::CreateViewCommandBuffer");
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   request.event.Wait();
   return request.result;
 }
 
 GpuChannelHost* BrowserGpuChannelHostFactory::EstablishGpuChannelSync(
     CauseForGpuLaunch cause_for_gpu_launch) {
   EstablishGpuChannel(cause_for_gpu_launch, base::Closure());
 
-  if (pending_request_)
+  if (pending_request_.get())
     pending_request_->Wait();
 
   return gpu_channel_.get();
 }
 
 void BrowserGpuChannelHostFactory::EstablishGpuChannel(
     CauseForGpuLaunch cause_for_gpu_launch,
     const base::Closure& callback) {
   if (gpu_channel_.get() && gpu_channel_->IsLost()) {
-    DCHECK(!pending_request_);
+    DCHECK(!pending_request_.get());
     // Recreate the channel if it has been lost.
     gpu_channel_ = NULL;
   }
 
-  if (!gpu_channel_ && !pending_request_) {
+  if (!gpu_channel_.get() && !pending_request_.get()) {
     // We should only get here if the context was lost.
     pending_request_ = EstablishRequest::Create(
         cause_for_gpu_launch, gpu_client_id_, gpu_host_id_);
   }
 
   if (!callback.is_null()) {
-    if (gpu_channel_)
+    if (gpu_channel_.get())
       callback.Run();
     else
       established_callbacks_.push_back(callback);
   }
 }
 
 GpuChannelHost* BrowserGpuChannelHostFactory::GetGpuChannel() {
-  if (gpu_channel_ && !gpu_channel_->IsLost())
-    return gpu_channel_;
+  if (gpu_channel_.get() && !gpu_channel_->IsLost())
+    return gpu_channel_.get();
 
   return NULL;
 }
 
 void BrowserGpuChannelHostFactory::GpuChannelEstablished() {
   DCHECK(IsMainThread());
-  DCHECK(pending_request_);
+  DCHECK(pending_request_.get());
   if (pending_request_->channel_handle().name.empty()) {
-    DCHECK(!gpu_channel_);
+    DCHECK(!gpu_channel_.get());
   } else {
     GetContentClient()->SetGpuInfo(pending_request_->gpu_info());
     gpu_channel_ = GpuChannelHost::Create(this,
                                           pending_request_->gpu_info(),
                                           pending_request_->channel_handle(),
                                           shutdown_event_.get());
   }
   gpu_host_id_ = pending_request_->gpu_host_id();
   pending_request_ = NULL;
 
@@ skipping 131 matching lines @@
     const gfx::GpuMemoryBufferHandle& handle,
     int32 sync_point) {
   GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
   if (!host)
     return;
 
   host->DestroyGpuMemoryBuffer(handle, sync_point);
 }
 
 }  // namespace content