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

ppapi/proxy/serialized_var.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/proxy/serialized_var.h"
 
 #include "base/logging.h"
 #include "ipc/ipc_message_utils.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/proxy/dispatcher.h"
@@ skipping 38 matching lines @@
       break;
     case END_RECEIVE_CALLER_OWNED:
       serialization_rules_->EndReceiveCallerOwned(var_);
       break;
     default:
       break;
   }
 }
 
 PP_Var SerializedVar::Inner::GetVar() {
-  DCHECK(serialization_rules_);
+  DCHECK(serialization_rules_.get());
 
 #if defined(NACL_WIN64)
   NOTREACHED();
   return PP_MakeUndefined();
 #endif
 
   if (raw_var_data_.get()) {
     var_ = raw_var_data_->CreatePPVar(instance_);
     raw_var_data_.reset(NULL);
   }
 
   return var_;
 }
 
 void SerializedVar::Inner::SetVar(PP_Var var) {
   // Sanity check, when updating the var we should have received a
   // serialization rules pointer already.
-  DCHECK(serialization_rules_);
+  DCHECK(serialization_rules_.get());
   var_ = var;
   raw_var_data_.reset(NULL);
 }
 
 void SerializedVar::Inner::SetInstance(PP_Instance instance) {
   instance_ = instance;
 }
 
 void SerializedVar::Inner::ForceSetVarValueForTest(PP_Var value) {
   var_ = value;
   raw_var_data_.reset(NULL);
 }
 
 void SerializedVar::Inner::WriteToMessage(IPC::Message* m) const {
   // When writing to the IPC messages, a serialization rules handler should
   // always have been set.
   //
   // When sending a message, it should be difficult to trigger this if you're
   // using the SerializedVarSendInput class and giving a non-NULL dispatcher.
   // Make sure you're using the proper "Send" helper class.
   //
   // It should be more common to see this when handling an incoming message
   // that returns a var. This means the message handler didn't write to the
   // output parameter, or possibly you used the wrong helper class
   // (normally SerializedVarReturnValue).
-  DCHECK(serialization_rules_);
+  DCHECK(serialization_rules_.get());
 
 #ifndef NDEBUG
   // We should only be serializing something once.
   DCHECK(!has_been_serialized_);
   has_been_serialized_ = true;
 #endif
   RawVarDataGraph::Create(var_, instance_)->Write(m);
 }
 
 bool SerializedVar::Inner::ReadFromMessage(const IPC::Message* m,
@@ skipping 313 matching lines @@
     const std::string& str) {
   inner_->ForceSetVarValueForTest(StringVar::StringToPPVar(str));
 }
 
 SerializedVarTestReader::SerializedVarTestReader(const SerializedVar& var)
     : SerializedVar(var) {
 }
 
 }  // namespace proxy
 }  // namespace ppapi