V8ValueConverterImpl: Use V8 to copy from array buffers.

content/child/v8_value_converter_impl_unittest.cc

 // Copyright (c) 2012 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 "content/child/v8_value_converter_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
@@ skipping 1090 matching lines @@
 
   v8::Local<v8::Array> array(v8::Array::New(isolate_));
   std::unique_ptr<base::Value> array_value(
       converter.FromV8Value(array, context));
   ASSERT_TRUE(array_value);
   std::unique_ptr<base::Value> reference_array_value(
       base::test::ParseJson("[]"));
   EXPECT_TRUE(
       base::Value::Equals(reference_array_value.get(), array_value.get()));
 
-  // Not testing ArrayBuffers as V8ValueConverter uses blink helpers and
-  // this requires having blink to be initialized.
+  const char kExampleData[] = {1, 2, 3, 4, 5};
+  v8::Local<v8::ArrayBuffer> array_buffer(
+      v8::ArrayBuffer::New(isolate_, sizeof(kExampleData)));
+  memcpy(array_buffer->GetContents().Data(), kExampleData,
+         sizeof(kExampleData));
+  std::unique_ptr<base::Value> binary_value(
+      converter.FromV8Value(array_buffer, context));
+  ASSERT_TRUE(binary_value);
+  std::unique_ptr<base::Value> reference_binary_value(
+      base::BinaryValue::CreateWithCopiedBuffer(kExampleData,
+                                                sizeof(kExampleData)));
+  EXPECT_TRUE(
+      base::Value::Equals(reference_binary_value.get(), binary_value.get()));
+
+  v8::Local<v8::ArrayBufferView> array_buffer_view(
+      v8::Uint8Array::New(array_buffer, 1, 3));
+  std::unique_ptr<base::Value> binary_view_value(
+      converter.FromV8Value(array_buffer_view, context));
+  ASSERT_TRUE(binary_view_value);
+  std::unique_ptr<base::Value> reference_binary_view_value(
+      base::BinaryValue::CreateWithCopiedBuffer(&kExampleData[1], 3));
+  EXPECT_TRUE(base::Value::Equals(reference_binary_view_value.get(),
+                                  binary_view_value.get()));
 
   v8::Local<v8::Number> number(v8::Number::New(isolate_, 0.0));
   std::unique_ptr<base::Value> number_value(
       converter.FromV8Value(number, context));
   ASSERT_TRUE(number_value);
   std::unique_ptr<base::Value> reference_number_value(
       base::test::ParseJson("0"));
   EXPECT_TRUE(
       base::Value::Equals(reference_number_value.get(), number_value.get()));
 
   v8::Local<v8::Primitive> undefined(v8::Undefined(isolate_));
   std::unique_ptr<base::Value> undefined_value(
       converter.FromV8Value(undefined, context));
   EXPECT_FALSE(undefined_value);
 }
 
 }  // namespace content