Hookup RawVarData to SerializedVar

ppapi/proxy/raw_var_data.cc

 // 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.
 
 #include "ppapi/proxy/raw_var_data.h"
 
 #include <stack>
 
 #include "base/hash_tables.h"
 #include "base/stl_util.h"
@@ skipping 10 matching lines @@
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 // When sending array buffers, if the size is over 256K, we use shared
 // memory instead of sending the data over IPC. Light testing suggests
 // shared memory is much faster for 256K and larger messages.
 static const uint32 kMinimumArrayBufferSizeForShmem = 256 * 1024;
+static uint32 g_minimum_array_buffer_size_for_shmem =
+    kMinimumArrayBufferSizeForShmem;
 
 void DefaultHandleWriter(IPC::Message* m, const SerializedHandle& handle) {
   IPC::ParamTraits<SerializedHandle>::Write(m, handle);
 }
 
 // For a given PP_Var, returns the RawVarData associated with it, or creates a
 // new one if there is no existing one. The data is appended to |data| if it
 // is newly created. The index into |data| pointing to the result is returned.
 // |id_map| keeps track of RawVarDatas that have already been created.
 size_t GetOrCreateRawVarData(const PP_Var& var,
@@ skipping 126 matching lines @@
     if (!m->ReadInt(iter, &type))
       return scoped_ptr<RawVarDataGraph>();
     PP_VarType var_type = static_cast<PP_VarType>(type);
     result->data_.push_back(RawVarData::Create(var_type));
     if (!result->data_.back()->Read(var_type, m, iter))
       return scoped_ptr<RawVarDataGraph>();
   }
   return result.Pass();
 }
 
+std::vector<SerializedHandle*> RawVarDataGraph::GetHandles() {
+  std::vector<SerializedHandle*> result;
+  for (size_t i = 0; i < data_.size(); ++i) {
+    SerializedHandle* handle = data_[i]->GetHandle();
+    if (handle)
+      result.push_back(handle);
+  }
+  return result;
+}
+
+// static
+void RawVarDataGraph::SetMinimumArrayBufferSizeForShmemForTest(
+    uint32 threshold) {
+  if (threshold == 0)
+    g_minimum_array_buffer_size_for_shmem = kMinimumArrayBufferSizeForShmem;
+  else
+    g_minimum_array_buffer_size_for_shmem = threshold;
+}
+
 // RawVarData ------------------------------------------------------------------
 
 // static
 RawVarData* RawVarData::Create(PP_VarType type) {
   switch (type) {
     case PP_VARTYPE_UNDEFINED:
     case PP_VARTYPE_NULL:
     case PP_VARTYPE_BOOL:
     case PP_VARTYPE_INT32:
     case PP_VARTYPE_DOUBLE:
@@ skipping 11 matching lines @@
   NOTREACHED();
   return NULL;
 }
 
 RawVarData::RawVarData() : initialized_(false) {
 }
 
 RawVarData::~RawVarData() {
 }
 
+SerializedHandle* RawVarData::GetHandle() {
+  return NULL;
+}
+
 // BasicRawVarData -------------------------------------------------------------
 BasicRawVarData::BasicRawVarData() {
 }
 
 BasicRawVarData::~BasicRawVarData() {
 }
 
 PP_VarType BasicRawVarData::Type() {
   return var_.type;
 }
@@ skipping 130 matching lines @@
   return PP_VARTYPE_ARRAY_BUFFER;
 }
 
 bool ArrayBufferRawVarData::Init(const PP_Var& var,
                                  PP_Instance instance) {
   DCHECK(var.type == PP_VARTYPE_ARRAY_BUFFER);
   ArrayBufferVar* buffer_var = ArrayBufferVar::FromPPVar(var);
   if (!buffer_var)
     return false;
   bool using_shmem = false;
-  if (buffer_var->ByteLength() >= kMinimumArrayBufferSizeForShmem &&
+  if (buffer_var->ByteLength() >= g_minimum_array_buffer_size_for_shmem &&
       instance != 0) {
     int host_handle_id;
     base::SharedMemoryHandle plugin_handle;
     using_shmem = buffer_var->CopyToNewShmem(instance,
                                              &host_handle_id,
                                              &plugin_handle);
     if (using_shmem) {
-      if (host_shm_handle_id_ != -1) {
+      if (host_handle_id != -1) {
         DCHECK(!base::SharedMemory::IsHandleValid(plugin_handle));
         DCHECK(PpapiGlobals::Get()->IsPluginGlobals());
         type_ = ARRAY_BUFFER_SHMEM_HOST;
         host_shm_handle_id_ = host_handle_id;
       } else {
         DCHECK(base::SharedMemory::IsHandleValid(plugin_handle));
         DCHECK(PpapiGlobals::Get()->IsHostGlobals());
         type_ = ARRAY_BUFFER_SHMEM_PLUGIN;
         plugin_shm_handle_ = SerializedHandle(plugin_handle,
                                               buffer_var->ByteLength());
@@ skipping 92 matching lines @@
         return false;
       break;
     default:
       // We read an invalid ID.
       NOTREACHED();
       return false;
   }
   return true;
 }
 
+SerializedHandle* ArrayBufferRawVarData::GetHandle() {
+  if (type_ == ARRAY_BUFFER_SHMEM_PLUGIN && plugin_shm_handle_.size() != 0)
+    return &plugin_shm_handle_;
+  return NULL;
+}
+
 // ArrayRawVarData -------------------------------------------------------------
 ArrayRawVarData::ArrayRawVarData() {
 }
 
 ArrayRawVarData::~ArrayRawVarData() {
 }
 
 void ArrayRawVarData::AddChild(size_t element) {
   children_.push_back(element);
 }
@@ skipping 111 matching lines @@
       return false;
     if (!m->ReadUInt32(iter, &value))
       return false;
     children_.push_back(make_pair(key, value));
   }
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi