Fix a crash related to PPAPI scripting.

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 "base/memory/ref_counted.h"
 #include "ipc/ipc_message_utils.h"
 #include "ppapi/proxy/dispatcher.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/ppapi_param_traits.h"
-#include "ppapi/proxy/var_serialization_rules.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/var.h"
 
 namespace ppapi {
 namespace proxy {
 
 // SerializedVar::Inner --------------------------------------------------------
 
 SerializedVar::Inner::Inner()
     : serialization_rules_(NULL),
       var_(PP_MakeUndefined()),
-      cleanup_mode_(CLEANUP_NONE),
-      dispatcher_for_end_send_pass_ref_(NULL) {
+      cleanup_mode_(CLEANUP_NONE) {
 #ifndef NDEBUG
   has_been_serialized_ = false;
   has_been_deserialized_ = false;
 #endif
 }
 
 SerializedVar::Inner::Inner(VarSerializationRules* serialization_rules)
     : serialization_rules_(serialization_rules),
       var_(PP_MakeUndefined()),
-      cleanup_mode_(CLEANUP_NONE),
-      dispatcher_for_end_send_pass_ref_(NULL) {
+      cleanup_mode_(CLEANUP_NONE) {
 #ifndef NDEBUG
   has_been_serialized_ = false;
   has_been_deserialized_ = false;
 #endif
 }
 
 SerializedVar::Inner::~Inner() {
   switch (cleanup_mode_) {
     case END_SEND_PASS_REF:
-      DCHECK(dispatcher_for_end_send_pass_ref_);
-      serialization_rules_->EndSendPassRef(var_,
-                                           dispatcher_for_end_send_pass_ref_);
+      serialization_rules_->EndSendPassRef(var_);
       break;
     case END_RECEIVE_CALLER_OWNED:
       serialization_rules_->EndReceiveCallerOwned(var_);
       break;
     default:
       break;
   }
 }
 
 PP_Var SerializedVar::Inner::GetVar() const {
@@ skipping 157 matching lines @@
   }
 
   // All success cases get here. We avoid writing the type above so that the
   // output param is untouched (defaults to VARTYPE_UNDEFINED) even in the
   // failure case.
   if (success)
     var_.type = static_cast<PP_VarType>(type);
   return success;
 }
 
-void SerializedVar::Inner::SetCleanupModeToEndSendPassRef(
-    Dispatcher* dispatcher) {
-  DCHECK(dispatcher);
-  DCHECK(!dispatcher_for_end_send_pass_ref_);
-  dispatcher_for_end_send_pass_ref_ = dispatcher;
+void SerializedVar::Inner::SetCleanupModeToEndSendPassRef() {
   cleanup_mode_ = END_SEND_PASS_REF;
 }
 
 void SerializedVar::Inner::SetCleanupModeToEndReceiveCallerOwned() {
   cleanup_mode_ = END_RECEIVE_CALLER_OWNED;
 }
 
 // SerializedVar ---------------------------------------------------------------
 
 SerializedVar::SerializedVar() : inner_(new Inner) {
@@ skipping 30 matching lines @@
 }
 
 ReceiveSerializedVarReturnValue::ReceiveSerializedVarReturnValue(
     const SerializedVar& serialized)
     : SerializedVar(serialized) {
 }
 
 PP_Var ReceiveSerializedVarReturnValue::Return(Dispatcher* dispatcher) {
   inner_->set_serialization_rules(dispatcher->serialization_rules());
   inner_->SetVar(inner_->serialization_rules()->ReceivePassRef(
-      inner_->GetVar(), dispatcher));
+      inner_->GetVar()));
   return inner_->GetVar();
 }
 
 // ReceiveSerializedException --------------------------------------------------
 
 ReceiveSerializedException::ReceiveSerializedException(Dispatcher* dispatcher,
                                                        PP_Var* exception)
     : SerializedVar(dispatcher->serialization_rules()),
-      dispatcher_(dispatcher),
       exception_(exception) {
 }
 
 ReceiveSerializedException::~ReceiveSerializedException() {
   if (exception_) {
     // When an output exception is specified, it will take ownership of the
     // reference.
     inner_->SetVar(
-        inner_->serialization_rules()->ReceivePassRef(inner_->GetVar(),
-                                                      dispatcher_));
+        inner_->serialization_rules()->ReceivePassRef(inner_->GetVar()));
     *exception_ = inner_->GetVar();
   } else {
     // When no output exception is specified, the browser thinks we have a ref
     // to an object that we don't want (this will happen only in the plugin
     // since the browser will always specify an out exception for the plugin to
     // write into).
     //
     // Strings don't need this handling since we can just avoid creating a
     // Var from the std::string in the first place.
     if (inner_->GetVar().type == PP_VARTYPE_OBJECT)
@@ skipping 34 matching lines @@
 }
 
 std::vector<SerializedVar>* ReceiveSerializedVarVectorOutParam::OutParam() {
   return &vector_;
 }
 
 // SerializedVarReceiveInput ---------------------------------------------------
 
 SerializedVarReceiveInput::SerializedVarReceiveInput(
     const SerializedVar& serialized)
-    : serialized_(serialized),
-      dispatcher_(NULL),
-      var_(PP_MakeUndefined()) {
+    : serialized_(serialized) {
 }
 
 SerializedVarReceiveInput::~SerializedVarReceiveInput() {
 }
 
 PP_Var SerializedVarReceiveInput::Get(Dispatcher* dispatcher) {
   serialized_.inner_->set_serialization_rules(
       dispatcher->serialization_rules());
 
   // Ensure that when the serialized var goes out of scope it cleans up the
   // stuff we're making in BeginReceiveCallerOwned.
   serialized_.inner_->SetCleanupModeToEndReceiveCallerOwned();
 
   serialized_.inner_->SetVar(
       serialized_.inner_->serialization_rules()->BeginReceiveCallerOwned(
-          serialized_.inner_->GetVar(),
-          dispatcher));
+          serialized_.inner_->GetVar()));
   return serialized_.inner_->GetVar();
 }
 
 // SerializedVarVectorReceiveInput ---------------------------------------------
 
 SerializedVarVectorReceiveInput::SerializedVarVectorReceiveInput(
     const std::vector<SerializedVar>& serialized)
     : serialized_(serialized) {
 }
 
 SerializedVarVectorReceiveInput::~SerializedVarVectorReceiveInput() {
   for (size_t i = 0; i < deserialized_.size(); i++) {
     serialized_[i].inner_->serialization_rules()->EndReceiveCallerOwned(
         deserialized_[i]);
   }
 }
 
 PP_Var* SerializedVarVectorReceiveInput::Get(Dispatcher* dispatcher,
                                              uint32_t* array_size) {
   deserialized_.resize(serialized_.size());
   for (size_t i = 0; i < serialized_.size(); i++) {
     // The vectors must be able to clean themselves up after this call is
     // torn down.
     serialized_[i].inner_->set_serialization_rules(
         dispatcher->serialization_rules());
 
     serialized_[i].inner_->SetVar(
         serialized_[i].inner_->serialization_rules()->BeginReceiveCallerOwned(
-            serialized_[i].inner_->GetVar(),
-            dispatcher));
+            serialized_[i].inner_->GetVar()));
     deserialized_[i] = serialized_[i].inner_->GetVar();
   }
 
   *array_size = static_cast<uint32_t>(serialized_.size());
   return deserialized_.empty() ? NULL : &deserialized_[0];
 }
 
 // SerializedVarReturnValue ----------------------------------------------------
 
 SerializedVarReturnValue::SerializedVarReturnValue(SerializedVar* serialized)
     : serialized_(serialized) {
 }
 
 void SerializedVarReturnValue::Return(Dispatcher* dispatcher,
                                       const PP_Var& var) {
   serialized_->inner_->set_serialization_rules(
       dispatcher->serialization_rules());
 
   // Var must clean up after our BeginSendPassRef call.
-  serialized_->inner_->SetCleanupModeToEndSendPassRef(dispatcher);
+  serialized_->inner_->SetCleanupModeToEndSendPassRef();
 
   serialized_->inner_->SetVar(
       dispatcher->serialization_rules()->BeginSendPassRef(var));
 }
 
 // static
 SerializedVar SerializedVarReturnValue::Convert(Dispatcher* dispatcher,
                                                 const PP_Var& var) {
   // Mimic what happens in the normal case.
   SerializedVar result;
@@ skipping 14 matching lines @@
   if (serialized_->inner_->serialization_rules()) {
     // When unset, OutParam wasn't called. We'll just leave the var untouched
     // in that case.
     serialized_->inner_->SetVar(
         serialized_->inner_->serialization_rules()->BeginSendPassRef(
             writable_var_));
 
     // Normally the current object will be created on the stack to wrap a
     // SerializedVar and won't have a scope around the actual IPC send. So we
     // need to tell the SerializedVar to do the begin/end send pass ref calls.
-    serialized_->inner_->SetCleanupModeToEndSendPassRef(dispatcher_);
+    serialized_->inner_->SetCleanupModeToEndSendPassRef();
   }
 }
 
 PP_Var* SerializedVarOutParam::OutParam(Dispatcher* dispatcher) {
   dispatcher_ = dispatcher;
   serialized_->inner_->set_serialization_rules(
       dispatcher->serialization_rules());
   return &writable_var_;
 }
 
@@ skipping 43 matching lines @@
     const std::string& str) {
   inner_->ForceSetVarValueForTest(StringVar::StringToPPVar(str));
 }
 
 SerializedVarTestReader::SerializedVarTestReader(const SerializedVar& var)
     : SerializedVar(var) {
 }
 
 }  // namespace proxy
 }  // namespace ppapi
-