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

ppapi/thunk/enter.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 "ppapi/thunk/enter.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
@@ skipping 55 matching lines @@
   DCHECK(resource_ || !instance);
   if (!resource_)
     retval_ = PP_ERROR_BADARGUMENT;
   callback_ = new TrackedCallback(resource_, callback);
 }
 
 EnterBase::~EnterBase() {
   // callback_ is cleared any time it is run, scheduled to be run, or once we
   // know it will be completed asynchronously. So by this point it should be
   // NULL.
-  DCHECK(!callback_) << "|callback_| is not NULL. Did you forget to call "
-      "|EnterBase::SetResult| in the interface's thunk?";
+  DCHECK(!callback_.get())
+      << "|callback_| is not NULL. Did you forget to call "
+         "|EnterBase::SetResult| in the interface's thunk?";
 }
 
 int32_t EnterBase::SetResult(int32_t result) {
-  if (!callback_) {
+  if (!callback_.get()) {
     // It doesn't make sense to call SetResult if there is no callback.
     NOTREACHED();
     retval_ = result;
     return result;
   }
   if (result == PP_OK_COMPLETIONPENDING) {
     retval_ = result;
     if (callback_->is_blocking()) {
       DCHECK(!IsMainThread());  // We should have returned an error before this.
       retval_ = callback_->BlockUntilComplete();
@@ skipping 33 matching lines @@
     return NULL;
 
   return ppb_instance->GetSingletonResource(instance, resource_id);
 }
 
 void EnterBase::SetStateForCallbackError(bool report_error) {
   if (PpapiGlobals::Get()->IsHostGlobals()) {
     // In-process plugins can't make PPAPI calls off the main thread.
     CHECK(IsMainThread());
   }
-  if (callback_) {
+  if (callback_.get()) {
     if (callback_->is_blocking() && IsMainThread()) {
       // Blocking callbacks are never allowed on the main thread.
       callback_->MarkAsCompleted();
       callback_ = NULL;
       retval_ = PP_ERROR_BLOCKS_MAIN_THREAD;
       if (report_error) {
         std::string message(
             "Blocking callbacks are not allowed on the main thread.");
         PpapiGlobals::Get()->BroadcastLogWithSource(0, PP_LOGLEVEL_ERROR,
                                                     std::string(), message);
@@ skipping 40 matching lines @@
                                          bool report_error) {
   // Check for callback errors. If we get any, SetStateForCallbackError will
   // emit a log message. But we also want to check for resource errors. If there
   // are both kinds of errors, we'll emit two log messages and return
   // PP_ERROR_BADRESOURCE.
   SetStateForCallbackError(report_error);
 
   if (object)
     return;  // Everything worked.
 
-  if (callback_ && callback_->is_required()) {
+  if (callback_.get() && callback_->is_required()) {
     callback_->PostRun(static_cast<int32_t>(PP_ERROR_BADRESOURCE));
     callback_ = NULL;
     retval_ = PP_OK_COMPLETIONPENDING;
   } else {
-    if (callback_)
+    if (callback_.get())
       callback_->MarkAsCompleted();
     callback_ = NULL;
     retval_ = PP_ERROR_BADRESOURCE;
   }
 
   // We choose to silently ignore the error when the pp_resource is null
   // because this is a pretty common case and we don't want to have lots
   // of errors in the log. This should be an obvious case to debug.
   if (report_error && pp_resource) {
     std::string message;
@@ skipping 16 matching lines @@
                                          bool report_error) {
   // Check for callback errors. If we get any, SetStateForCallbackError will
   // emit a log message. But we also want to check for instance errors. If there
   // are both kinds of errors, we'll emit two log messages and return
   // PP_ERROR_BADARGUMENT.
   SetStateForCallbackError(report_error);
 
   if (object)
     return;  // Everything worked.
 
-  if (callback_ && callback_->is_required()) {
+  if (callback_.get() && callback_->is_required()) {
     callback_->PostRun(static_cast<int32_t>(PP_ERROR_BADARGUMENT));
     callback_ = NULL;
     retval_ = PP_OK_COMPLETIONPENDING;
   } else {
-    if (callback_)
+    if (callback_.get())
       callback_->MarkAsCompleted();
     callback_ = NULL;
     retval_ = PP_ERROR_BADARGUMENT;
   }
 
   // We choose to silently ignore the error when the pp_instance is null as
   // for PP_Resources above.
   if (report_error && pp_instance) {
     std::string message;
     message = base::StringPrintf(
@@ skipping 58 matching lines @@
     : EnterBase(),
       functions_(PpapiGlobals::Get()->GetResourceCreationAPI(instance)) {
   SetStateForFunctionError(instance, functions_, true);
 }
 
 EnterResourceCreationNoLock::~EnterResourceCreationNoLock() {
 }
 
 }  // namespace thunk
 }  // namespace ppapi