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

ppapi/proxy/serialized_var.h

 // 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.
 
 #ifndef PPAPI_PROXY_SERIALIZED_VAR_H_
 #define PPAPI_PROXY_SERIALIZED_VAR_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 21 matching lines @@
 // no useful public methods). Instead, instantiate one of the helper classes
 // below which are conveniently named for each use case to prevent screwups.
 //
 // Design background
 // -----------------
 // This is sadly super complicated. The IPC system needs a consistent type to
 // use for sending and receiving vars (this is a SerializedVar). But there are
 // different combinations of reference counting for sending and receiving
 // objects and for dealing with strings
 //
-// This makes SerializedVar complicate and easy to mess up. To make it
+// This makes SerializedVar complicated and easy to mess up. To make it
 // reasonable to use all functions are protected and there are a use-specific
 // classes that encapsulate exactly one type of use in a way that typically
 // won't compile if you do the wrong thing.
 //
 // The IPC system is designed to pass things around and will make copies in
 // some cases, so our system must be designed so that this stuff will work.
 // This is challenging when the SerializedVar must to some cleanup after the
 // message is sent. To work around this, we create an inner class using a
 // linked_ptr so all copies of a SerializedVar can share and we can guarantee
 // that the actual data will get cleaned up on shutdown.
 //
 // Constness
 // ---------
 // SerializedVar basically doesn't support const. Everything is mutable and
 // most functions are declared const. This unfortunateness is because of the
 // way the IPC system works. When deserializing, it will have a const
 // SerializedVar in a Tuple and this will be given to the function. We kind of
 // want to modify that to convert strings and do refcounting.
 //
 // The helper classes used for accessing the SerializedVar have more reasonable
 // behavior and will enforce that you don't do stupid things.
 class SerializedVar {
  public:
-  enum CleanupMode {
-    // The serialized var won't do anything special in the destructor (default).
-    CLEANUP_NONE,
-
-    // The serialized var will call EndSendPassRef in the destructor.
-    END_SEND_PASS_REF,
-
-    // The serialized var will call EndReceiveCallerOwned in the destructor.
-    END_RECEIVE_CALLER_OWNED
-  };
-
   SerializedVar();
   ~SerializedVar();
 
   // Backend implementation for IPC::ParamTraits<SerializedVar>.
   void WriteToMessage(IPC::Message* m) const {
     inner_->WriteToMessage(m);
   }
   bool ReadFromMessage(const IPC::Message* m, void** iter) {
     return inner_->ReadFromMessage(m, iter);
   }
 
  protected:
   friend class SerializedVarReceiveInput;
   friend class SerializedVarReturnValue;
   friend class SerializedVarOutParam;
   friend class SerializedVarSendInput;
+  friend class SerializedVarTestConstructor;
   friend class SerializedVarVectorReceiveInput;
 
   class Inner : public base::RefCounted<Inner> {
    public:
     Inner();
     Inner(VarSerializationRules* serialization_rules);
     Inner(VarSerializationRules* serialization_rules, const PP_Var& var);
     ~Inner();
 
     VarSerializationRules* serialization_rules() {
       return serialization_rules_;
     }
     void set_serialization_rules(VarSerializationRules* serialization_rules) {
       serialization_rules_ = serialization_rules;
     }
 
-    void set_cleanup_mode(CleanupMode cm) { cleanup_mode_ = cm; }
-
     // See outer class's declarations above.
     PP_Var GetVar() const;
     PP_Var GetIncompleteVar() const;
     void SetVar(PP_Var var);
     const std::string& GetString() const;
     std::string* GetStringPtr();
 
     void WriteToMessage(IPC::Message* m) const;
     bool ReadFromMessage(const IPC::Message* m, void** iter);
 
+    // Sets the cleanup mode. See the CleanupMode enum below. These functions
+    // are not just a simple setter in order to require that the appropriate
+    // data is set along with the corresponding mode.
+    void SetCleanupModeToEndSendPassRef(Dispatcher* dispatcher);
+    void SetCleanupModeToEndReceiveCallerOwned();
+
    private:
+    enum CleanupMode {
+      // The serialized var won't do anything special in the destructor
+      // (default).
+      CLEANUP_NONE,
+
+      // The serialized var will call EndSendPassRef in the destructor.
+      END_SEND_PASS_REF,
+
+      // The serialized var will call EndReceiveCallerOwned in the destructor.
+      END_RECEIVE_CALLER_OWNED
+    };
+
     // Rules for serializing and deserializing vars for this process type.
     // This may be NULL, but must be set before trying to serialize to IPC when
     // sending, or before converting back to a PP_Var when receiving.
     VarSerializationRules* serialization_rules_;
 
     // If this is set to VARTYPE_STRING and the 'value.id' is 0, then the
     // string_value_ contains the string. This means that the caller hasn't
     // called Deserialize with a valid Dispatcher yet, which is how we can
     // convert the serialized string value to a PP_Var string ID.
     //
     // 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_;
 
     // Holds the literal string value to/from IPC. This will be valid of the
     // var_ is VARTYPE_STRING.
     std::string string_value_;
 
     CleanupMode cleanup_mode_;
 
+    // The dispatcher saved for the call to EndSendPassRef for the cleanup.
+    // This is only valid when cleanup_mode == END_SEND_PASS_REF.
+    Dispatcher* dispatcher_for_end_send_pass_ref_;
+
 #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
 
     DISALLOW_COPY_AND_ASSIGN(Inner);
   };
 
@@ skipping 218 matching lines @@
   // returned var pointer before this class goes out of scope. The var's
   // initial value will be VARTYPE_UNDEFINED.
   PP_Var* OutParam(Dispatcher* dispatcher);
 
  private:
   SerializedVar* serialized_;
 
   // This is the value actually written by the code and returned by OutParam.
   // We'll write this into serialized_ in our destructor.
   PP_Var writable_var_;
+
+  Dispatcher* dispatcher_;
 };
 
 // For returning an array of PP_Vars to the other side and transferring
 // ownership.
 //
 class SerializedVarVectorOutParam {
  public:
   SerializedVarVectorOutParam(std::vector<SerializedVar>* serialized);
   ~SerializedVarVectorOutParam();
 
   uint32_t* CountOutParam() { return &count_; }
   PP_Var** ArrayOutParam(Dispatcher* dispatcher);
 
  private:
   Dispatcher* dispatcher_;
   std::vector<SerializedVar>* serialized_;
 
   uint32_t count_;
   PP_Var* array_;
 };
 
+// For tests that just want to construct a SerializedVar for giving it to one
+// of the other classes.
+class SerializedVarTestConstructor : public SerializedVar {
+ public:
+  // For POD-types and objects.
+  explicit SerializedVarTestConstructor(const PP_Var& pod_var);
+
+  // For strings.
+  explicit SerializedVarTestConstructor(const std::string& str);
+};
+
+// For tests that want to read what's in a SerializedVar.
+class SerializedVarTestReader : public SerializedVar {
+ public:
+  explicit SerializedVarTestReader(const SerializedVar& var);
+
+  // The "incomplete" var is the one sent over the wire. Strings and object
+  // IDs have not yet been converted, so this is the thing that tests will
+  // actually want to check.
+  PP_Var GetIncompleteVar() const { return inner_->GetIncompleteVar(); }
+
+  const std::string& GetString() const { return inner_->GetString(); }
+};
+
 }  // namespace proxy
 }  // namespace pp
 
 #endif  // PPAPI_PROXY_SERIALIZED_VAR_H_