Don't send PP_Vars/V8 values with cycles across PostMessage

ppapi/proxy/serialized_var.h

 // 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.
 
 #ifndef PPAPI_PROXY_SERIALIZED_VAR_H_
 #define PPAPI_PROXY_SERIALIZED_VAR_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 62 matching lines @@
 // behavior and will enforce that you don't do stupid things.
 class PPAPI_PROXY_EXPORT SerializedVar {
  public:
   SerializedVar();
   ~SerializedVar();
 
   // Backend implementation for IPC::ParamTraits<SerializedVar>.
   void WriteToMessage(IPC::Message* m) const {
     inner_->WriteToMessage(m);
   }
+  // If ReadFromMessage has been called, WriteDataToMessage will write the var
+  // that has been read from ReadFromMessage back to a message. This is used
+  // when converting handles for use in NaCl.
+  void WriteDataToMessage(IPC::Message* m,
+                          const HandleWriter& handle_writer) const {
+    inner_->WriteDataToMessage(m, handle_writer);
+  }
   bool ReadFromMessage(const IPC::Message* m, PickleIterator* iter) {
     return inner_->ReadFromMessage(m, iter);
   }
 
-  RawVarDataGraph* raw_var_data() const {
-    return inner_->raw_var_data();
+  bool is_valid_var() const {
+    return inner_->is_valid_var();
+  }
+
+  // Returns the shared memory handles associated with this SerializedVar.
+  std::vector<SerializedHandle*> GetHandles() const {
+    return inner_->GetHandles();
   }
 
  protected:
   friend class SerializedVarReceiveInput;
   friend class SerializedVarReturnValue;
   friend class SerializedVarOutParam;
   friend class SerializedVarSendInput;
   friend class SerializedVarSendInputShmem;
   friend class SerializedVarTestConstructor;
   friend class SerializedVarVectorReceiveInput;
 
   class PPAPI_PROXY_EXPORT Inner : public base::RefCounted<Inner> {
    public:
     Inner();
     Inner(VarSerializationRules* serialization_rules);
     ~Inner();
 
     VarSerializationRules* serialization_rules() {
       return serialization_rules_.get();
     }
     void set_serialization_rules(VarSerializationRules* serialization_rules) {
       serialization_rules_ = serialization_rules;
     }
 
-    RawVarDataGraph* raw_var_data() {
-      return raw_var_data_.get();
+    bool is_valid_var() const {
+      return is_valid_var_;
+    }
+
+    std::vector<SerializedHandle*> GetHandles() {
+      return (raw_var_data_ ? raw_var_data_->GetHandles() :
+          std::vector<SerializedHandle*>());
     }
 
     // See outer class's declarations above.
     PP_Var GetVar();
     void SetVar(PP_Var var);
     void SetInstance(PP_Instance instance);
 
     // For the SerializedVarTestConstructor, this writes the Var value as if
     // it was just received off the wire, without any serialization rules.
     void ForceSetVarValueForTest(PP_Var value);
 
     void WriteToMessage(IPC::Message* m) const;
+    void WriteDataToMessage(IPC::Message* m,
+                            const HandleWriter& handle_writer) const;
     bool ReadFromMessage(const IPC::Message* m, PickleIterator* iter);
 
     // Sets the cleanup mode. See the CleanupMode enum below.
     void SetCleanupModeToEndSendPassRef();
     void SetCleanupModeToEndReceiveCallerOwned();
 
    private:
     enum CleanupMode {
       // The serialized var won't do anything special in the destructor
       // (default).
@@ skipping 18 matching lines @@
     //
     // This var may not be complete until the serialization rules are set when
     // reading from IPC since we'll need that to convert the string_value to
     // a string ID. Before this, the as_id will be 0 for VARTYPE_STRING.
     PP_Var var_;
 
     PP_Instance instance_;
 
     CleanupMode cleanup_mode_;
 
+    // If the var is not properly serialized, this will be false.
+    bool is_valid_var_;
+
 #ifndef NDEBUG
     // When being sent or received over IPC, we should only be serialized or
     // deserialized once. These flags help us assert this is true.
     mutable bool has_been_serialized_;
     mutable bool has_been_deserialized_;
 #endif
 
     // ReadFromMessage() may be called on the I/O thread, e.g., when reading the
     // reply to a sync message. We cannot use the var tracker on the I/O thread,
     // which means we cannot create some types of PP_Var
@@ skipping 160 matching lines @@
 class PPAPI_PROXY_EXPORT SerializedVarReceiveInput {
  public:
   // We rely on the implicit constructor here since the IPC layer will call
   // us with a SerializedVar. Pass this object by value, the copy constructor
   // will pass along the pointer (as cheap as passing a pointer arg).
   SerializedVarReceiveInput(const SerializedVar& serialized);
   ~SerializedVarReceiveInput();
 
   PP_Var Get(Dispatcher* dispatcher);
   PP_Var GetForInstance(Dispatcher* dispatcher, PP_Instance instance);
+  bool is_valid_var() { return serialized_.is_valid_var(); }
 
  private:
   const SerializedVar& serialized_;
 };
 
 // For receiving an input vector of vars from the remote side.
 //
 // Example:
 //   OnMsgMyFunction(SerializedVarVectorReceiveInput vector) {
 //     uint32_t size;
@@ skipping 115 matching lines @@
  public:
   explicit SerializedVarTestReader(const SerializedVar& var);
 
   PP_Var GetVar() const { return inner_->GetVar(); }
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_SERIALIZED_VAR_H_