Proxy PPB_ArrayBuffer_Dev, make them work over Messaging

ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_var.cc

 // Copyright (c) 2011 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 "native_client/src/shared/ppapi_proxy/plugin_ppb_var.h"
 
 #include <stdio.h>
 
 #include <string>
 #include <utility>
 
 #include "native_client/src/include/checked_cast.h"
 #include "native_client/src/include/nacl_macros.h"
 #include "native_client/src/include/portability.h"
 #include "native_client/src/include/portability_io.h"
+#include "native_client/src/shared/ppapi_proxy/array_buffer_proxy_var.h"
 #include "native_client/src/shared/ppapi_proxy/proxy_var_cache.h"
 #include "native_client/src/shared/ppapi_proxy/string_proxy_var.h"
 #include "native_client/src/shared/ppapi_proxy/utility.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_var.h"
 
 namespace ppapi_proxy {
 
 namespace {
 
@@ skipping 50 matching lines @@
 int64_t GetVarId(PP_Var var) {
   SharedProxyVar proxy_var =
       ProxyVarCache::GetInstance().SharedProxyVarForVar(var);
   if (proxy_var == NULL) {
     return -1;
   } else {
     return proxy_var->id();
   }
 }
 
+PP_Var CreateArrayBuffer(uint32_t size_in_bytes) {
+  DebugPrintf("PPB_VarArrayBuffer::Create: size_in_bytes=%"NACL_PRIu32"\n",
+              size_in_bytes);
+  SharedProxyVar proxy_var(new ArrayBufferProxyVar(size_in_bytes));
+  ProxyVarCache::GetInstance().RetainSharedProxyVar(proxy_var);
+  PP_Var var;
+  var.type = PP_VARTYPE_ARRAY_BUFFER;
+  var.value.as_id = proxy_var->id();
+  // Increment the reference count for the return to the caller.
+  AddRef(var);
+  DebugPrintf("PPB_VarArrayBuffer::Create: as_id=%"NACL_PRId64"\n",
+              var.value.as_id);
+  return var;
+}
+
+uint32_t ByteLength(PP_Var var) {
+  DebugPrintf("PPB_VarArrayBuffer::ByteLength: var=PPB_Var(%s)\n",
+              PluginVar::DebugString(var).c_str());
+  SharedArrayBufferProxyVar buffer_var = ArrayBufferProxyVar::CastFromProxyVar(
+      ProxyVarCache::GetInstance().SharedProxyVarForVar(var));
+  uint32_t len = buffer_var->buffer_length();
+  DebugPrintf("PPB_VarArrayBuffer::ByteLength: length=%"NACL_PRIu32"\n", len);
+  return len;
+}
+
+void* Map(PP_Var var) {
+  DebugPrintf("PPB_VarArrayBuffer::Map: var=PPB_Var(%s)\n",
+              PluginVar::DebugString(var).c_str());
+  SharedArrayBufferProxyVar buffer_var = ArrayBufferProxyVar::CastFromProxyVar(
+      ProxyVarCache::GetInstance().SharedProxyVarForVar(var));
+  void* data = buffer_var->buffer();
+  DebugPrintf("PPB_VarArrayBuffer::Map: buffer=%p\n", data);
+  return data;
+}
+
 }  // namespace
 
 const PPB_Var* PluginVar::GetInterface() {
   static const PPB_Var var_interface = {
     AddRef,
     Release,
     VarFromUtf8,
     VarToUtf8
   };
   return &var_interface;
 }
 
 const PPB_Var_1_0* PluginVar::GetInterface1_0() {
   static const PPB_Var_1_0 var_interface = {
     AddRef,
     Release,
     VarFromUtf8_1_0,
     VarToUtf8
   };
   return &var_interface;
 }
 
+const PPB_VarArrayBuffer_Dev* PluginVar::GetArrayBufferInterface() {
+  static const PPB_VarArrayBuffer_Dev interface = {
+    CreateArrayBuffer,
+    ByteLength,
+    Map
+  };
+  return &interface;
+}
+
 std::string PluginVar::DebugString(const PP_Var& var) {
   switch (var.type) {
     case PP_VARTYPE_UNDEFINED:
       return "##UNDEFINED##";
     case PP_VARTYPE_NULL:
       return "##NULL##";
     case PP_VARTYPE_BOOL:
       return (var.value.as_bool ? "true" : "false");
     case PP_VARTYPE_INT32:
       {
@@ skipping 12 matching lines @@
     case PP_VARTYPE_STRING:
       {
         uint32_t len;
         const char* data = VarToUtf8(var, &len);
         return std::string(data, len);
       }
     case PP_VARTYPE_OBJECT:
       {
         char buf[32];
         const size_t kBufSize = sizeof(buf);
-        SNPRINTF(buf, kBufSize, "%"NACL_PRIu64"", GetVarId(var));
+        SNPRINTF(buf, kBufSize, "%"NACL_PRId64"", GetVarId(var));
         return std::string("##OBJECT##") + buf + "##";
       }
+    case PP_VARTYPE_ARRAY_BUFFER:
+      {
+        char buf[32];
+        const size_t kBufSize = sizeof(buf);
+        SNPRINTF(buf, kBufSize, "%"NACL_PRId64"", GetVarId(var));
+        return std::string("##ARRAYBUFFER##") + buf + "##";
+      }
     case PP_VARTYPE_ARRAY:
     case PP_VARTYPE_DICTIONARY:
-    case PP_VARTYPE_ARRAY_BUFFER:
       NACL_NOTREACHED();
       break;
   }
   ASSERT_MSG(0, "Unexpected type seen");
   return "##ERROR##";
 }
 
 PP_Var PluginVar::StringToPPVar(const std::string& str) {
   static const PPB_Var* ppb_var = NULL;
   if (ppb_var == NULL) {
@@ skipping 49 matching lines @@
       break;
     case PP_VARTYPE_ARRAY:
     case PP_VARTYPE_DICTIONARY:
     case PP_VARTYPE_ARRAY_BUFFER:
       NACL_NOTREACHED();
       break;
   }
 }
 
 }  // namespace ppapi_proxy