Should provide creation context and isolate for WebArrayConverter

content/renderer/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/renderer/v8_value_converter_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 135 matching lines @@
 }
 
 void V8ValueConverterImpl::SetStrategy(Strategy* strategy) {
   strategy_ = strategy;
 }
 
 v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Value(
     const base::Value* value, v8::Handle<v8::Context> context) const {
   v8::Context::Scope context_scope(context);
   v8::EscapableHandleScope handle_scope(context->GetIsolate());
-  return handle_scope.Escape(ToV8ValueImpl(context->GetIsolate(), value));
+  return handle_scope.Escape(
+      ToV8ValueImpl(context->GetIsolate(), context->Global(), value));
 }
 
 base::Value* V8ValueConverterImpl::FromV8Value(
     v8::Handle<v8::Value> val,
     v8::Handle<v8::Context> context) const {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope(context->GetIsolate());
   FromV8ValueState state(avoid_identity_hash_for_testing_);
   return FromV8ValueImpl(&state, val, context->GetIsolate());
 }
 
 v8::Local<v8::Value> V8ValueConverterImpl::ToV8ValueImpl(
     v8::Isolate* isolate,
+    v8::Handle<v8::Object> creationContext,

[darin (slow to review), 2014/06/10 04:52:01]

ditto... there are more. please fix-up code to match google c++ style guide.

[tasak, 2014/06/10 05:09:15]

Done.

     const base::Value* value) const {
   CHECK(value);
   switch (value->GetType()) {
     case base::Value::TYPE_NULL:
       return v8::Null(isolate);
 
     case base::Value::TYPE_BOOLEAN: {
       bool val = false;
       CHECK(value->GetAsBoolean(&val));
       return v8::Boolean::New(isolate, val);
@@ skipping 12 matching lines @@
     }
 
     case base::Value::TYPE_STRING: {
       std::string val;
       CHECK(value->GetAsString(&val));
       return v8::String::NewFromUtf8(
           isolate, val.c_str(), v8::String::kNormalString, val.length());
     }
 
     case base::Value::TYPE_LIST:
-      return ToV8Array(isolate, static_cast<const base::ListValue*>(value));
+      return ToV8Array(
+          isolate, creationContext, static_cast<const base::ListValue*>(value));
 
     case base::Value::TYPE_DICTIONARY:
       return ToV8Object(isolate,
+                        creationContext,
                         static_cast<const base::DictionaryValue*>(value));
 
     case base::Value::TYPE_BINARY:
-      return ToArrayBuffer(static_cast<const base::BinaryValue*>(value));
+      return ToArrayBuffer(isolate,
+                           creationContext,
+                           static_cast<const base::BinaryValue*>(value));
 
     default:
       LOG(ERROR) << "Unexpected value type: " << value->GetType();
       return v8::Null(isolate);
   }
 }
 
 v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Array(
     v8::Isolate* isolate,
+    v8::Handle<v8::Object> creationContext,
     const base::ListValue* val) const {
   v8::Handle<v8::Array> result(v8::Array::New(isolate, val->GetSize()));
 
   for (size_t i = 0; i < val->GetSize(); ++i) {
     const base::Value* child = NULL;
     CHECK(val->Get(i, &child));
 
-    v8::Handle<v8::Value> child_v8 = ToV8ValueImpl(isolate, child);
+    v8::Handle<v8::Value> child_v8 =
+        ToV8ValueImpl(isolate, creationContext, child);
     CHECK(!child_v8.IsEmpty());
 
     v8::TryCatch try_catch;
     result->Set(static_cast<uint32>(i), child_v8);
     if (try_catch.HasCaught())
       LOG(ERROR) << "Setter for index " << i << " threw an exception.";
   }
 
   return result;
 }
 
 v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Object(
     v8::Isolate* isolate,
+    v8::Handle<v8::Object> creationContext,
     const base::DictionaryValue* val) const {
   v8::Handle<v8::Object> result(v8::Object::New(isolate));
 
   for (base::DictionaryValue::Iterator iter(*val);
        !iter.IsAtEnd(); iter.Advance()) {
     const std::string& key = iter.key();
-    v8::Handle<v8::Value> child_v8 = ToV8ValueImpl(isolate, &iter.value());
+    v8::Handle<v8::Value> child_v8 =
+        ToV8ValueImpl(isolate, creationContext, &iter.value());
     CHECK(!child_v8.IsEmpty());
 
     v8::TryCatch try_catch;
     result->Set(
         v8::String::NewFromUtf8(
             isolate, key.c_str(), v8::String::kNormalString, key.length()),
         child_v8);
     if (try_catch.HasCaught()) {
       LOG(ERROR) << "Setter for property " << key.c_str() << " threw an "
                  << "exception.";
     }
   }
 
   return result;
 }
 
 v8::Handle<v8::Value> V8ValueConverterImpl::ToArrayBuffer(
+    v8::Isolate* isolate,
+    v8::Handle<v8::Object> creationContext,
     const base::BinaryValue* value) const {
   blink::WebArrayBuffer buffer =
       blink::WebArrayBuffer::create(value->GetSize(), 1);
   memcpy(buffer.data(), value->GetBuffer(), value->GetSize());
-  return blink::WebArrayBufferConverter::toV8Value(&buffer);
+  return blink::WebArrayBufferConverter::toV8Value(
+      &buffer, creationContext, isolate);
 }
 
 base::Value* V8ValueConverterImpl::FromV8ValueImpl(
     FromV8ValueState* state,
     v8::Handle<v8::Value> val,
     v8::Isolate* isolate) const {
   CHECK(!val.IsEmpty());
 
   FromV8ValueState::Level state_level(state);
   if (state->HasReachedMaxRecursionDepth())
@@ skipping 132 matching lines @@
   if (strategy_) {
     base::Value* out = NULL;
     if (strategy_->FromV8ArrayBuffer(val, &out, isolate))
       return out;
   }
 
   char* data = NULL;
   size_t length = 0;
 
   scoped_ptr<blink::WebArrayBuffer> array_buffer(
-      blink::WebArrayBufferConverter::createFromV8Value(val));
+      blink::WebArrayBufferConverter::createFromV8Value(val, isolate));
   scoped_ptr<blink::WebArrayBufferView> view;
   if (array_buffer) {
     data = reinterpret_cast<char*>(array_buffer->data());
     length = array_buffer->byteLength();
   } else {
     view.reset(blink::WebArrayBufferView::createFromV8Value(val));
     if (view) {
       data = reinterpret_cast<char*>(view->baseAddress()) + view->byteOffset();
       length = view->byteLength();
     }
@@ skipping 102 matching lines @@
       continue;
 
     result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
                                     child.release());
   }
 
   return result.release();
 }
 
 }  // namespace content