Hookup RawVarData to SerializedVar

ppapi/proxy/raw_var_data.h

 // Copyright (c) 2013 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_RAW_VAR_DATA_H_
 #define PPAPI_PROXY_RAW_VAR_DATA_H_
 
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 54 matching lines @@
 
   // Write the graph to a message using the given HandleWriter.
   void Write(IPC::Message* m, const HandleWriter& handle_writer);
   // Write the graph to a message using the default handle writer.
   void Write(IPC::Message* m);
 
   // Create a RawVarDataGraph from the given message.
   static scoped_ptr<RawVarDataGraph> Read(const IPC::Message* m,
                                           PickleIterator* iter);
 
+  // Returns a vector of SerializedHandles associated with this RawVarDataGraph.
+  // Ownership of the pointers remains with the elements of the RawVarDataGraph.
+  std::vector<SerializedHandle*> GetHandles();
+
+  // Sets the threshold size at which point we switch from transmitting
+  // array buffers in IPC messages to using shared memory. This is only used
+  // for testing purposes where we need to transmit small buffers using shmem
+  // (in order to have fast tests).
+  static void SetMinimumArrayBufferSizeForShmemForTest(uint32 threshold);
+
   // A list of the nodes in the graph.
   ScopedVector<RawVarData> data_;
 };
 
 // Abstract base class for the data contained in a PP_Var.
 class RawVarData {
  public:
   // Create a new, empty RawVarData for the given type.
   static RawVarData* Create(PP_VarType type);
   RawVarData();
@@ skipping 15 matching lines @@
                              const std::vector<PP_Var>& graph) = 0;
 
   // Writes the RawVarData to a message.
   virtual void Write(IPC::Message* m,
                      const HandleWriter& handle_writer) = 0;
   // Reads the RawVarData from a message. Returns true on success.
   virtual bool Read(PP_VarType type,
                     const IPC::Message* m,
                     PickleIterator* iter) = 0;
 
+  // Returns a SerializedHandle associated with this RawVarData or NULL if none
+  // exists. Ownership of the pointer remains with the RawVarData.
+  virtual SerializedHandle* GetHandle();
+
   bool initialized() { return initialized_; }
 
  protected:
   bool initialized_;
 };
 
 // A RawVarData class for PP_Vars which are value types.
 class BasicRawVarData : public RawVarData {
  public:
   BasicRawVarData();
@@ skipping 55 matching lines @@
   virtual PP_VarType Type() OVERRIDE;
   virtual bool Init(const PP_Var& var, PP_Instance instance) OVERRIDE;
   virtual PP_Var CreatePPVar(PP_Instance instance) OVERRIDE;
   virtual void PopulatePPVar(const PP_Var& var,
                              const std::vector<PP_Var>& graph) OVERRIDE;
   virtual void Write(IPC::Message* m,
                      const HandleWriter& handle_writer) OVERRIDE;
   virtual bool Read(PP_VarType type,
                     const IPC::Message* m,
                     PickleIterator* iter) OVERRIDE;
+  virtual SerializedHandle* GetHandle() OVERRIDE;
 
  private:
   // The type of the storage underlying the array buffer.
   ShmemType type_;
   // The data in the buffer. Valid for |type_| == ARRAY_BUFFER_NO_SHMEM.
   std::string data_;
   // Host shmem handle. Valid for |type_| == ARRAY_BUFFER_SHMEM_HOST.
   int host_shm_handle_id_;
   // Plugin shmem handle. Valid for |type_| == ARRAY_BUFFER_SHMEM_PLUGIN.
   SerializedHandle plugin_shm_handle_;
@@ skipping 44 matching lines @@
                     PickleIterator* iter) OVERRIDE;
 
  private:
   std::vector<std::pair<std::string, size_t> > children_;
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_RAW_VAR_DATA_H_