First pass at making the proxy handle multiple renderers. This associates the...

ppapi/proxy/serialized_var.cc

 // Copyright (c) 2010 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/proxy/dispatcher.h"
 #include "ppapi/proxy/interface_proxy.h"
@@ skipping 207 matching lines @@
     : inner_(new Inner(serialization_rules, var)) {
 }
 
 SerializedVar::~SerializedVar() {
 }
 
 // SerializedVarSendInput ------------------------------------------------------
 
 SerializedVarSendInput::SerializedVarSendInput(Dispatcher* dispatcher,
                                                const PP_Var& var)
-    : SerializedVar(dispatcher->serialization_rules(), var) {
-  dispatcher->serialization_rules()->SendCallerOwned(var,
-                                                     inner_->GetStringPtr());
+    : SerializedVar(dispatcher->serialization_rules()) {
+  inner_->SetVar(dispatcher->serialization_rules()->SendCallerOwned(
+      var, inner_->GetStringPtr()));
 }
 
 // static
 void SerializedVarSendInput::ConvertVector(Dispatcher* dispatcher,
                                            const PP_Var* input,
                                            size_t input_count,
                                            std::vector<SerializedVar>* output) {
   output->resize(input_count);
   for (size_t i = 0; i < input_count; i++) {
-    (*output)[i] = SerializedVar(dispatcher->serialization_rules(), input[i]);
-    dispatcher->serialization_rules()->SendCallerOwned(
-        input[i], (*output)[i].inner_->GetStringPtr());
+    SerializedVar& cur = (*output)[i];
+    cur = SerializedVar(dispatcher->serialization_rules());
+    cur.inner_->SetVar(dispatcher->serialization_rules()->SendCallerOwned(
+        input[i], cur.inner_->GetStringPtr()));
   }
 }
 
 // ReceiveSerializedVarReturnValue ---------------------------------------------
 
 ReceiveSerializedVarReturnValue::ReceiveSerializedVarReturnValue() {
 }
 
 PP_Var ReceiveSerializedVarReturnValue::Return(Dispatcher* dispatcher) {
   inner_->set_serialization_rules(dispatcher->serialization_rules());
   inner_->SetVar(inner_->serialization_rules()->ReceivePassRef(
-      inner_->GetIncompleteVar(), inner_->GetString()));
+      inner_->GetIncompleteVar(), inner_->GetString(), dispatcher));
   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_->GetIncompleteVar(), inner_->GetString()));
+        inner_->GetIncompleteVar(), inner_->GetString(), dispatcher_));
     *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 53 matching lines @@
   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_->set_cleanup_mode(SerializedVar::END_RECEIVE_CALLER_OWNED);
 
   serialized_.inner_->SetVar(
       serialized_.inner_->serialization_rules()->BeginReceiveCallerOwned(
           serialized_.inner_->GetIncompleteVar(),
-          serialized_.inner_->GetStringPtr()));
+          serialized_.inner_->GetStringPtr(),
+          dispatcher));
   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 vector 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_->GetIncompleteVar(),
-            serialized_[i].inner_->GetStringPtr()));
+            serialized_[i].inner_->GetStringPtr(),
+            dispatcher));
     deserialized_[i] = serialized_[i].inner_->GetVar();
   }
 
   *array_size = static_cast<uint32_t>(serialized_.size());
   return deserialized_.size() > 0 ? &deserialized_[0] : NULL;
 }
 
 // SerializedVarReturnValue ----------------------------------------------------
 
 SerializedVarReturnValue::SerializedVarReturnValue(SerializedVar* serialized)
     : serialized_(serialized) {
 }
 
 void SerializedVarReturnValue::Return(Dispatcher* dispatcher,
                                       const PP_Var& var) {
   serialized_->inner_->set_serialization_rules(
       dispatcher->serialization_rules());
-  serialized_->inner_->SetVar(var);
 
   // Var must clean up after our BeginSendPassRef call.
   serialized_->inner_->set_cleanup_mode(SerializedVar::END_SEND_PASS_REF);
 
-  dispatcher->serialization_rules()->BeginSendPassRef(
-      serialized_->inner_->GetIncompleteVar(),
-      serialized_->inner_->GetStringPtr());
+  serialized_->inner_->SetVar(
+      dispatcher->serialization_rules()->BeginSendPassRef(
+          var,
+          serialized_->inner_->GetStringPtr()));
 }
 
 // SerializedVarOutParam -------------------------------------------------------
 
 SerializedVarOutParam::SerializedVarOutParam(SerializedVar* serialized)
     : serialized_(serialized),
       writable_var_(PP_MakeUndefined()) {
 }
 
 SerializedVarOutParam::~SerializedVarOutParam() {
   if (serialized_->inner_->serialization_rules()) {
     // When unset, OutParam wasn't called. We'll just leave the var untouched
     // in that case.
-    serialized_->inner_->SetVar(writable_var_);
-    serialized_->inner_->serialization_rules()->BeginSendPassRef(
-        writable_var_, serialized_->inner_->GetStringPtr());
+    serialized_->inner_->SetVar(
+        serialized_->inner_->serialization_rules()->BeginSendPassRef(
+            writable_var_, serialized_->inner_->GetStringPtr()));
 
     // 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_->set_cleanup_mode(SerializedVar::END_SEND_PASS_REF);
   }
 }
 
 PP_Var* SerializedVarOutParam::OutParam(Dispatcher* dispatcher) {
   serialized_->inner_->set_serialization_rules(
@@ skipping 33 matching lines @@
 
 PP_Var** SerializedVarVectorOutParam::ArrayOutParam(Dispatcher* dispatcher) {
   DCHECK(!dispatcher_);  // Should only be called once.
   dispatcher_ = dispatcher;
   return &array_;
 }
 
 }  // namespace proxy
 }  // namespace pp