Inline base::BinaryValue into base::Value

content/child/v8_value_converter_impl.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>
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "v8/include/v8.h"
 
 namespace content {
 
@@ skipping 237 matching lines @@
       return ToV8Array(isolate,
                        creation_context,
                        static_cast<const base::ListValue*>(value));
 
     case base::Value::Type::DICTIONARY:
       return ToV8Object(isolate,
                         creation_context,
                         static_cast<const base::DictionaryValue*>(value));
 
     case base::Value::Type::BINARY:
-      return ToArrayBuffer(isolate,
-                           creation_context,
-                           static_cast<const base::BinaryValue*>(value));
+      return ToArrayBuffer(isolate, creation_context, value);
 
     default:
       LOG(ERROR) << "Unexpected value type: " << value->GetType();
       return v8::Null(isolate);
   }
 }
 
 v8::Local<v8::Value> V8ValueConverterImpl::ToV8Array(
     v8::Isolate* isolate,
     v8::Local<v8::Object> creation_context,
@@ skipping 210 matching lines @@
       return out;
   }
 
   if (val->IsArrayBuffer()) {
     auto contents = val.As<v8::ArrayBuffer>()->GetContents();
     return base::BinaryValue::CreateWithCopiedBuffer(
         static_cast<const char*>(contents.Data()), contents.ByteLength());
   } else if (val->IsArrayBufferView()) {
     v8::Local<v8::ArrayBufferView> view = val.As<v8::ArrayBufferView>();
     size_t byte_length = view->ByteLength();
-    auto buffer = base::MakeUnique<char[]>(byte_length);
-    view->CopyContents(buffer.get(), byte_length);
-    return base::MakeUnique<base::BinaryValue>(std::move(buffer), byte_length);
+    std::vector<char> buffer(byte_length);
+    view->CopyContents(buffer.data(), buffer.size());

[jdoerrie, 2017/02/10 11:00:35]

Unfortunately, this will always zero initialize |buffer| now, which is unneeded
here. I considered using |buffer.reserve(byte_length)| instead, but this SO
answer claims this wouldn't be safe: http://stackoverflow.com/a/8228861

+    return base::MakeUnique<base::BinaryValue>(std::move(buffer));
   } else {
     NOTREACHED() << "Only ArrayBuffer and ArrayBufferView should get here.";
     return nullptr;
   }
 }
 
 std::unique_ptr<base::Value> V8ValueConverterImpl::FromV8Object(
     v8::Local<v8::Object> val,
     FromV8ValueState* state,
     v8::Isolate* isolate) const {
@@ skipping 92 matching lines @@
       continue;
 
     result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
                                     std::move(child));
   }
 
   return std::move(result);
 }
 
 }  // namespace content