Proxy PPB_ArrayBuffer_Dev, make them work over Messaging

ppapi/native_client/src/shared/ppapi_proxy/object_serialize.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/object_serialize.h"
 
 #include <limits>
 #include <stdio.h>
@@ skipping 24 matching lines @@
 
 // The basic serialization structure.  Used alone for PP_VARTYPE_VOID,
 // PP_VARTYPE_NULL, and PP_VARTYPE_INT32.
 struct SerializedFixed {
   uint32_t type;
   union {
     // PP_VARTYPE_BOOLEAN uses this.
     bool boolean_value;
     // PP_VARTYPE_INT32 uses this.
     int32_t int32_value;
-    // PP_VARTYPE_STRING uses this.
+    // PP_VARTYPE_STRING and PP_VARTYPE_ARRAY_BUFFER use this.
     uint32_t string_length;
   } u;
   // The size of this structure should be 8 bytes on all platforms.
 };
 
 // The structure used for PP_VARTYPE_DOUBLE.
 struct SerializedDouble {
   struct SerializedFixed fixed;
   double double_value;
 };
 
-// The structure used for PP_VARTYPE_STRING.
-
+// The structure used for PP_VARTYPE_STRING and PP_VARTYPE_ARRAYBUFFER.
 struct SerializedString {
   struct SerializedFixed fixed;
   char string_bytes[kStringFixedBytes];
   // Any remaining characters immediately follow, and are padded out to the
   // nearest multiple of kStringRoundBase bytes.
 };
 
 // TODO(sehr): Add a more general compile time assertion package elsewhere.
 #define ASSERT_TYPE_SIZE(struct_name, struct_size) \
     int struct_name##_size_should_be_##struct_size[ \
                     sizeof(struct_name) == struct_size ? 1 : 0]
 
 // Check the wire format sizes for the PP_Var subtypes.
 ASSERT_TYPE_SIZE(SerializedFixed, 8);
 ASSERT_TYPE_SIZE(SerializedDouble, 16);
 ASSERT_TYPE_SIZE(SerializedString, 16);
+// IMPORTANT NOTE: SerializePpVar below assumes these sizes are multiples of 8,
+// otherwise the reinterpret_casts could cause alignment issues. New SerializedX
+// types should also be multiples of 8 bytes, or the SerializePpVar function
+// must be updated to enforce appropriate alignment.
 
 //
 // We currently use offsetof to find the start of string storage.
 // This avoids the (never seen) case where the compiler inserts in
 // padding between the struct SerializedFixed fixed header and the
 // actual payload value in the double, string, and object
 // serialization variants.
 //
 // Untrusted arm toolchain defines an offsetof in stddef.h, so we have
 // to prefix.
 //
 #define NACL_OFFSETOF(pod_t, member) \
   (static_cast<size_t>(reinterpret_cast<uintptr_t>(&((pod_t *) NULL)->member)))
 
 namespace {
 
 // Adding value1 and value2 would overflow a uint32_t.
 bool AddWouldOverflow(size_t value1, size_t value2) {
   if (value1 > std::numeric_limits<size_t>::max() - value2) {
     return true;
   }
-  size_t sum = value1 + value2;

[dmichael (off chromium), 2011/12/27 22:20:47]

size_t is 32-bit in NaCl and the 32-bit trusted builds, so this check seemed
wrong to me. Let me know if I'm misunderstanding something.

+  uint64_t sum = uint64_t(value1) + value2;
   return sum > std::numeric_limits<uint32_t>::max();
 }
 
 uint32_t RoundedStringBytes(uint32_t string_length) {
   // Compute the string length, padded to the nearest multiple of 8.
   if (AddWouldOverflow(string_length, kStringRoundBase - 1)) {
     return std::numeric_limits<uint32_t>::max();
   }
   return (string_length + (kStringRoundBase - 1)) & ~(kStringRoundBase - 1);
 }
 
 uint32_t PpVarSize(const PP_Var& var) {
   switch (var.type) {
     case PP_VARTYPE_UNDEFINED:
     case PP_VARTYPE_NULL:
     case PP_VARTYPE_BOOL:
     case PP_VARTYPE_INT32:
       return sizeof(SerializedFixed);
     case PP_VARTYPE_DOUBLE:
       return sizeof(SerializedDouble);
     case PP_VARTYPE_STRING: {
       uint32_t string_length;
       (void) PPBVarInterface()->VarToUtf8(var, &string_length);
       string_length = RoundedStringBytes(string_length);
-      if (std::numeric_limits<uint32_t>::max() == string_length ||

[dmichael (off chromium), 2011/12/27 22:20:47]

And this part doesn't seem necessary if AddWouldOverflow works...

-          AddWouldOverflow(string_length,
+      if (AddWouldOverflow(string_length,
                            NACL_OFFSETOF(SerializedString, string_bytes))) {
         // Adding the length to the fixed portion would overflow.
         return 0;
       }
       return static_cast<uint32_t>(NACL_OFFSETOF(SerializedString, string_bytes)
                                    + string_length);
       break;
     }
+    case PP_VARTYPE_ARRAY_BUFFER: {
+      uint32_t buffer_length = PPBVarArrayBufferInterface()->ByteLength(var);
+      buffer_length = RoundedStringBytes(buffer_length);
+      if (AddWouldOverflow(buffer_length,
+                           NACL_OFFSETOF(SerializedString, string_bytes))) {
+        // Adding the length to the fixed portion would overflow.
+        return 0;
+      }
+      return static_cast<uint32_t>(NACL_OFFSETOF(SerializedString, string_bytes)
+                                   + buffer_length);
+      break;
+    }
     case PP_VARTYPE_OBJECT:
     case PP_VARTYPE_ARRAY:
     case PP_VARTYPE_DICTIONARY:
-    case PP_VARTYPE_ARRAY_BUFFER:
       NACL_NOTREACHED();
       break;
   }
   // Unrecognized type.
   return 0;
 }
 
 uint32_t PpVarVectorSize(const PP_Var* vars, uint32_t argc) {
   size_t size = 0;
 
@@ skipping 61 matching lines @@
         memcpy(reinterpret_cast<void*>(ss->string_bytes),
                reinterpret_cast<const void*>(str),
                string_length);
         // Fill padding bytes with zeros.
         memset(reinterpret_cast<void*>(ss->string_bytes + string_length), 0,
             RoundedStringBytes(string_length) - string_length);
         element_size = NACL_OFFSETOF(SerializedString, string_bytes)
             + RoundedStringBytes(string_length);
         break;
       }
+      case PP_VARTYPE_ARRAY_BUFFER: {
+        uint32_t buffer_length =
+            PPBVarArrayBufferInterface()->ByteLength(vars[i]);
+        SerializedString* ss = reinterpret_cast<SerializedString*>(p);
+        ss->fixed.u.string_length = buffer_length;
+        memcpy(reinterpret_cast<void*>(ss->string_bytes),
+               PPBVarArrayBufferInterface()->Map(vars[i]),
+               buffer_length);
+        // Fill padding bytes with zeros.
+        memset(reinterpret_cast<void*>(ss->string_bytes + buffer_length), 0,
+            RoundedStringBytes(buffer_length) - buffer_length);
+        element_size = NACL_OFFSETOF(SerializedString, string_bytes)
+            + RoundedStringBytes(buffer_length);
+        break;
+      }
       case PP_VARTYPE_OBJECT:
       case PP_VARTYPE_ARRAY:
       case PP_VARTYPE_DICTIONARY:
-      case PP_VARTYPE_ARRAY_BUFFER:
         NACL_NOTREACHED();
       default:
         return false;
     }
     offset += element_size;
   }
   return true;
 }
 
 
 //
 // Compute how many bytes does the string object to be deserialzed use
 // in the serialized format.  On error, return
 // std::numeric_limits<uint32_t>::max().  This means we cannot handle
 // 2**32-1 byte strings.
 //
 uint32_t DeserializeStringSize(char* p, uint32_t length) {
   // zero length strings are okay... but not shorter
   if (length < NACL_OFFSETOF(SerializedString, string_bytes)) {
     return std::numeric_limits<uint32_t>::max();
   }
   SerializedString* ss = reinterpret_cast<SerializedString*>(p);
-  if (PP_VARTYPE_STRING != ss->fixed.type) {
+  if (PP_VARTYPE_STRING != ss->fixed.type &&
+      PP_VARTYPE_ARRAY_BUFFER != ss->fixed.type) {
     return std::numeric_limits<uint32_t>::max();
   }
   uint32_t string_length = ss->fixed.u.string_length;
   string_length = RoundedStringBytes(string_length);
   if (std::numeric_limits<uint32_t>::max() == string_length) {
     return std::numeric_limits<uint32_t>::max();
   }
   if (AddWouldOverflow(NACL_OFFSETOF(SerializedString, string_bytes),
                        string_length)) {
     return std::numeric_limits<uint32_t>::max();
@@ skipping 42 matching lines @@
       break;
     case PP_VARTYPE_DOUBLE:
       expected_element_size = sizeof(SerializedDouble);
       break;
     case PP_VARTYPE_STRING:
       expected_element_size = DeserializeStringSize(p, length);
       if (std::numeric_limits<uint32_t>::max() == expected_element_size) {
         return std::numeric_limits<uint32_t>::max();
       }
       break;
+    case PP_VARTYPE_ARRAY_BUFFER:
+      expected_element_size = DeserializeStringSize(p, length);
+      if (std::numeric_limits<uint32_t>::max() == expected_element_size) {
+        return std::numeric_limits<uint32_t>::max();
+      }
+      break;
       // NB: No default case to trigger -Wswitch-enum, so changes to
       // PP_VarType w/o corresponding changes here will cause a
       // compile-time error.
     case PP_VARTYPE_OBJECT:
     case PP_VARTYPE_ARRAY:
     case PP_VARTYPE_DICTIONARY:
-    case PP_VARTYPE_ARRAY_BUFFER:
       NACL_NOTREACHED();
       break;
   }
   if (length < expected_element_size) {
     return std::numeric_limits<uint32_t>::max();
   }
   if (NULL != element_type_ptr) {
     *element_type_ptr = static_cast<PP_VarType>(sfp->type);
   }
   return expected_element_size;
@@ skipping 10 matching lines @@
   uint32_t string_length = ss->fixed.u.string_length;
   // VarFromUtf8 creates a buffer of size string_length using the browser-side
   // memory allocation function, and copies string_length bytes from
   // ss->string_bytes in to that buffer.  The ref count of the returned var is
   // 1.
   *var = PPBVarInterface()->VarFromUtf8(ss->string_bytes,
                                         string_length);
   return true;
 }
 
+//
+// This should be invoked only if DeserializePpVarSize succeeds, i.e.,
+// there are enough bytes at p.
+//
+bool DeserializeArrayBuffer(char* p,
+                            PP_Var* var) {
+  SerializedString* ss = reinterpret_cast<SerializedString*>(p);
+  uint32_t buffer_length = ss->fixed.u.string_length;
+  // VarFromUtf8 creates a buffer of size string_length using the browser-side
+  // memory allocation function, and copies string_length bytes from
+  // ss->string_bytes in to that buffer.  The ref count of the returned var is
+  // 1.
+  *var = PPBVarArrayBufferInterface()->Create(buffer_length);
+  void* var_buffer = PPBVarArrayBufferInterface()->Map(*var);
+  memcpy(var_buffer, ss->string_bytes, buffer_length);
+  return true;
+}
+
 bool DeserializePpVar(char* bytes,
                       uint32_t length,
                       PP_Var* vars,
                       uint32_t argc) {
   char* p = bytes;
 
   for (uint32_t i = 0; i < argc; ++i) {
     PP_VarType element_type;
     uint32_t element_size = DeserializePpVarSize(p, length, &element_type);
     if (std::numeric_limits<uint32_t>::max() == element_size) {
@@ skipping 15 matching lines @@
       case PP_VARTYPE_DOUBLE: {
         SerializedDouble* sd = reinterpret_cast<SerializedDouble*>(p);
         vars[i].value.as_double = sd->double_value;
         break;
       }
       case PP_VARTYPE_STRING:
         if (!DeserializeString(p, &vars[i])) {
           return false;
         }
         break;
+      case PP_VARTYPE_ARRAY_BUFFER:
+        if (!DeserializeArrayBuffer(p, &vars[i])) {
+          return false;
+        }
+        break;
       case PP_VARTYPE_OBJECT:
       case PP_VARTYPE_ARRAY:
       case PP_VARTYPE_DICTIONARY:
-      case PP_VARTYPE_ARRAY_BUFFER:
         NACL_NOTREACHED();
       default:
         return false;
     }
     p += element_size;
     length -= element_size;
   }
   return true;
 }
 
@@ skipping 68 matching lines @@
     return false;
   }
   // Read the serialized PP_Vars into the allocated memory.
   if (!DeserializePpVar(bytes, length, vars, argc)) {
     return false;
   }
   return true;
 }
 
 }  // namespace ppapi_proxy