Implement proxying for FileRef and FileChooser....

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 255 matching lines @@
 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(), dispatcher));
   return inner_->GetVar();
 }
 
+// static
+PP_Var ReceiveSerializedVarReturnValue::Convert(
+    Dispatcher* dispatcher,
+    const SerializedVar& serialized) {
+  // Emulate how this is called when receiving a return value.
+  ReceiveSerializedVarReturnValue ret;
+  static_cast<SerializedVar&>(ret) = serialized;

[piman, 2011/02/17 21:25:07]

How about adding an explicit constructor for ReceiveSerializedVarReturnValue
that takes a const SerializedVar & and delegates to the SerializeVar copy
constructor ? That would be cleaner (no static cast required)

+  return ret.Return(dispatcher);
+}
+
 // ReceiveSerializedException --------------------------------------------------
 
 ReceiveSerializedException::ReceiveSerializedException(Dispatcher* dispatcher,
                                                        PP_Var* exception)
     : SerializedVar(dispatcher->serialization_rules()),
       dispatcher_(dispatcher),
       exception_(exception) {
 }
 
 ReceiveSerializedException::~ReceiveSerializedException() {
@@ skipping 128 matching lines @@
 
   // Var must clean up after our BeginSendPassRef call.
   serialized_->inner_->SetCleanupModeToEndSendPassRef(dispatcher);
 
   serialized_->inner_->SetVar(
       dispatcher->serialization_rules()->BeginSendPassRef(
           var,
           serialized_->inner_->GetStringPtr()));
 }
 
+// static
+SerializedVar SerializedVarReturnValue::Convert(Dispatcher* dispatcher,
+                                                const PP_Var& var) {
+  // Mimic what happens in the normal case.
+  SerializedVar result;
+  SerializedVarReturnValue retvalue(&result);
+  retvalue.Return(dispatcher, var);
+  return result;
+}
+
 // SerializedVarOutParam -------------------------------------------------------
 
 SerializedVarOutParam::SerializedVarOutParam(SerializedVar* serialized)
     : serialized_(serialized),
       writable_var_(PP_MakeUndefined()),
       dispatcher_(NULL) {
 }
 
 SerializedVarOutParam::~SerializedVarOutParam() {
   if (serialized_->inner_->serialization_rules()) {
@@ skipping 68 matching lines @@
   *inner_->GetStringPtr() = str;
 }
 
 SerializedVarTestReader::SerializedVarTestReader(const SerializedVar& var)
     : SerializedVar(var) {
 }
 
 }  // namespace proxy
 }  // namespace pp