Remove implicit conversions from scoped_refptr to T* in gpu/

gpu/command_buffer/service/query_manager.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 "gpu/command_buffer/service/query_manager.h"
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
@@ skipping 70 matching lines @@
 bool AsyncPixelTransfersCompletedQuery::Begin() {
   return true;
 }
 
 bool AsyncPixelTransfersCompletedQuery::End(
     base::subtle::Atomic32 submit_count) {
   // Get the real shared memory since it might need to be duped to prevent
   // use-after-free of the memory.
   scoped_refptr<Buffer> buffer =
       manager()->decoder()->GetSharedMemoryBuffer(shm_id());
-  if (!buffer)
+  if (!buffer.get())
     return false;
   AsyncMemoryParams mem_params(buffer, shm_offset(), sizeof(QuerySync));
   if (!mem_params.GetDataAddress())
     return false;
 
   observer_ = new AsyncPixelTransferCompletionObserverImpl(submit_count);
 
   // Ask AsyncPixelTransferDelegate to run completion callback after all
   // previous async transfers are done. No guarantee that callback is run
   // on the current thread.
-  manager()->decoder()->GetAsyncPixelTransferManager()
-      ->AsyncNotifyCompletion(mem_params, observer_);
+  manager()->decoder()->GetAsyncPixelTransferManager()->AsyncNotifyCompletion(
+      mem_params, observer_.get());
 
   return AddToPendingTransferQueue(submit_count);
 }
 
 bool AsyncPixelTransfersCompletedQuery::Process() {
   QuerySync* sync = manager()->decoder()->GetSharedMemoryAs<QuerySync*>(
       shm_id(), shm_offset(), sizeof(*sync));
   if (!sync)
     return false;
 
   // Check if completion callback has been run. sync->process_count atomicity
   // is guaranteed as this is already used to notify client of a completed
   // query.
   if (base::subtle::Acquire_Load(&sync->process_count) != submit_count())
     return true;
 
   UnmarkAsPending();
   return true;
 }
 
 void AsyncPixelTransfersCompletedQuery::Destroy(bool /* have_context */) {
   if (!IsDeleted()) {
     MarkAsDeleted();
   }
 }
 
 AsyncPixelTransfersCompletedQuery::~AsyncPixelTransfersCompletedQuery() {
-  if (observer_)
+  if (observer_.get())
     observer_->Cancel();
 }
 
 }  // namespace
 
 class AllSamplesPassedQuery : public QueryManager::Query {
  public:
   AllSamplesPassedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset,
       GLuint service_id);
@@ skipping 596 matching lines @@
 bool QueryManager::EndQuery(Query* query, base::subtle::Atomic32 submit_count) {
   DCHECK(query);
   if (!RemovePendingQuery(query)) {
     return false;
   }
   return query->End(submit_count);
 }
 
 }  // namespace gles2
 }  // namespace gpu