Refactor PPAPI proxy resource handling to maintain which host they came from,...

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"
 #include "ppapi/proxy/ppapi_param_traits.h"
 #include "ppapi/proxy/var_serialization_rules.h"
 
 namespace pp {
 namespace proxy {
 
 // SerializedVar::Inner --------------------------------------------------------
 
 SerializedVar::Inner::Inner()
     : serialization_rules_(NULL),
       var_(PP_MakeUndefined()),
-      cleanup_mode_(CLEANUP_NONE) {
+      cleanup_mode_(CLEANUP_NONE),
+      dispatcher_for_end_send_pass_ref_(NULL) {
 #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) {
+      cleanup_mode_(CLEANUP_NONE),
+      dispatcher_for_end_send_pass_ref_(NULL) {
 #ifndef NDEBUG
   has_been_serialized_ = false;
   has_been_deserialized_ = false;
 #endif
 }
 
 SerializedVar::Inner::Inner(VarSerializationRules* serialization_rules,
                             const PP_Var& var)
     : serialization_rules_(serialization_rules),
       var_(var),
-      cleanup_mode_(CLEANUP_NONE) {
+      cleanup_mode_(CLEANUP_NONE),
+      dispatcher_for_end_send_pass_ref_(NULL) {
 #ifndef NDEBUG
   has_been_serialized_ = false;
   has_been_deserialized_ = false;
 #endif
 }
 
 SerializedVar::Inner::~Inner() {
   switch (cleanup_mode_) {
     case END_SEND_PASS_REF:
-      serialization_rules_->EndSendPassRef(var_);
+      DCHECK(dispatcher_for_end_send_pass_ref_);
+      serialization_rules_->EndSendPassRef(var_,
+                                           dispatcher_for_end_send_pass_ref_);
       break;
     case END_RECEIVE_CALLER_OWNED:
       serialization_rules_->EndReceiveCallerOwned(var_);
       break;
     default:
       break;
   }
 }
 
 PP_Var SerializedVar::Inner::GetVar() const {
@@ skipping 133 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;
+  cleanup_mode_ = END_SEND_PASS_REF;
+}
+
+void SerializedVar::Inner::SetCleanupModeToEndReceiveCallerOwned() {
+  cleanup_mode_ = END_RECEIVE_CALLER_OWNED;
+}
+
 // SerializedVar ---------------------------------------------------------------
 
 SerializedVar::SerializedVar() : inner_(new Inner) {
 }
 
 SerializedVar::SerializedVar(VarSerializationRules* serialization_rules)
     : inner_(new Inner(serialization_rules)) {
 }
 
 SerializedVar::SerializedVar(VarSerializationRules* serialization_rules,
@@ skipping 115 matching lines @@
 
 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_->set_cleanup_mode(SerializedVar::END_RECEIVE_CALLER_OWNED);
+  serialized_.inner_->SetCleanupModeToEndReceiveCallerOwned();
 
   serialized_.inner_->SetVar(
       serialized_.inner_->serialization_rules()->BeginReceiveCallerOwned(
           serialized_.inner_->GetIncompleteVar(),
           serialized_.inner_->GetStringPtr(),
           dispatcher));
   return serialized_.inner_->GetVar();
 }
 
 // SerializedVarVectorReceiveInput ---------------------------------------------
@@ skipping 36 matching lines @@
 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_->set_cleanup_mode(SerializedVar::END_SEND_PASS_REF);
+  serialized_->inner_->SetCleanupModeToEndSendPassRef(dispatcher);
 
   serialized_->inner_->SetVar(
       dispatcher->serialization_rules()->BeginSendPassRef(
           var,
           serialized_->inner_->GetStringPtr()));
 }
 
 // SerializedVarOutParam -------------------------------------------------------
 
 SerializedVarOutParam::SerializedVarOutParam(SerializedVar* serialized)
     : serialized_(serialized),
-      writable_var_(PP_MakeUndefined()) {
+      writable_var_(PP_MakeUndefined()),
+      dispatcher_(NULL) {
 }
 
 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(
         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);
+    serialized_->inner_->SetCleanupModeToEndSendPassRef(dispatcher_);
   }
 }
 
 PP_Var* SerializedVarOutParam::OutParam(Dispatcher* dispatcher) {
+  dispatcher_ = dispatcher;
   serialized_->inner_->set_serialization_rules(
       dispatcher->serialization_rules());
   return &writable_var_;
 }
 
 // SerializedVarVectorOutParam -------------------------------------------------
 
 SerializedVarVectorOutParam::SerializedVarVectorOutParam(
     std::vector<SerializedVar>* serialized)
     : dispatcher_(NULL),
@@ skipping 21 matching lines @@
   // ownership of the array.
   free(array_);
 }
 
 PP_Var** SerializedVarVectorOutParam::ArrayOutParam(Dispatcher* dispatcher) {
   DCHECK(!dispatcher_);  // Should only be called once.
   dispatcher_ = dispatcher;
   return &array_;
 }
 
+SerializedVarTestConstructor::SerializedVarTestConstructor(
+    const PP_Var& pod_var) {
+  DCHECK(pod_var.type != PP_VARTYPE_STRING);
+  inner_->SetVar(pod_var);
+}
+
+SerializedVarTestConstructor::SerializedVarTestConstructor(
+    const std::string& str) {
+  PP_Var string_var;
+  string_var.type = PP_VARTYPE_STRING;
+  string_var.value.as_id = 0;
+  inner_->SetVar(string_var);
+  *inner_->GetStringPtr() = str;
+}
+
+SerializedVarTestReader::SerializedVarTestReader(const SerializedVar& var)
+    : SerializedVar(var) {
+}
+
 }  // namespace proxy
 }  // namespace pp