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

ppapi/shared_impl/tracked_callback.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/shared_impl/tracked_callback.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 105 matching lines @@
     // tracker. Then MarkAsCompleted before waking up the blocked thread,
     // which could potentially re-enter.
     scoped_refptr<TrackedCallback> thiz(this);
     MarkAsCompleted();
     // Wake up the blocked thread. See BlockUntilComplete for where the thread
     // Wait()s.
     operation_completed_condvar_->Signal();
   } else {
     // If there's a target_loop_, and we're not on the right thread, we need to
     // post to target_loop_.
-    if (target_loop_ &&
-        target_loop_ != PpapiGlobals::Get()->GetCurrentMessageLoop()) {
+    if (target_loop_.get() &&
+        target_loop_.get() != PpapiGlobals::Get()->GetCurrentMessageLoop()) {
       PostRun(result);
       return;
     }
     // Copy |callback_| now, since |MarkAsCompleted()| may delete us.
     PP_CompletionCallback callback = callback_;
     // Do this before running the callback in case of reentrancy (which
     // shouldn't happen, but avoid strange failures).
     MarkAsCompleted();
     // TODO(dmichael): Associate a message loop with the callback; if it's not
     // the same as the current thread's loop, then post it to the right loop.
     CallWhileUnlocked(PP_RunCompletionCallback, &callback, result);
   }
 }
 
 void TrackedCallback::PostRun(int32_t result) {
   if (completed()) {
     NOTREACHED();
     return;
   }
   if (result == PP_ERROR_ABORTED)
     aborted_ = true;
   // We might abort when there's already a scheduled callback, but callers
   // should never try to PostRun more than once otherwise.
   DCHECK(result == PP_ERROR_ABORTED || !is_scheduled_);
 
   base::Closure callback_closure(
       RunWhileLocked(base::Bind(&TrackedCallback::Run, this, result)));
-  if (!target_loop_) {
+  if (!target_loop_.get()) {
     // We must be running in-process and on the main thread (the Enter
     // classes protect against having a null target_loop_ otherwise).
     DCHECK(IsMainThread());
     DCHECK(PpapiGlobals::Get()->IsHostGlobals());
     base::MessageLoop::current()->PostTask(FROM_HERE, callback_closure);
   } else {
     target_loop_->PostClosure(FROM_HERE, callback_closure, 0);
   }
   is_scheduled_ = true;
 }
@@ skipping 31 matching lines @@
   // until we're done.
   scoped_refptr<TrackedCallback> thiz = this;
   completed_ = true;
   // We may not have a valid resource, in which case we're not in the tracker.
   if (resource_id_)
     tracker_->Remove(thiz);
   tracker_ = NULL;
 }
 
 }  // namespace ppapi