Track v8 API changes.

content/renderer/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 <cmath>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
@@ skipping 136 matching lines @@
     scoped_ptr<base::Value> raw(converter.FromV8Value(val, context));
 
     if (expected_value) {
       ASSERT_TRUE(raw.get());
       EXPECT_TRUE(expected_value->Equals(raw.get()));
       EXPECT_EQ(expected_type, raw->GetType());
     } else {
       EXPECT_FALSE(raw.get());
     }
 
-    v8::Handle<v8::Object> object(v8::Object::New());
+    v8::Handle<v8::Object> object(v8::Object::New(isolate_));
     object->Set(v8::String::NewFromUtf8(isolate_, "test"), val);
     scoped_ptr<base::DictionaryValue> dictionary(
         static_cast<base::DictionaryValue*>(
             converter.FromV8Value(object, context)));
     ASSERT_TRUE(dictionary.get());
 
     if (expected_value) {
       base::Value* temp = NULL;
       ASSERT_TRUE(dictionary->Get("test", &temp));
       EXPECT_EQ(expected_type, temp->GetType());
@@ skipping 280 matching lines @@
 }
 
 TEST_F(V8ValueConverterImplTest, RecursiveObjects) {
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate_, context_);
   v8::Context::Scope context_scope(context);
 
   V8ValueConverterImpl converter;
 
-  v8::Handle<v8::Object> object = v8::Object::New().As<v8::Object>();
+  v8::Handle<v8::Object> object = v8::Object::New(isolate_).As<v8::Object>();
   ASSERT_FALSE(object.IsEmpty());
   object->Set(v8::String::NewFromUtf8(isolate_, "foo"),
               v8::String::NewFromUtf8(isolate_, "bar"));
   object->Set(v8::String::NewFromUtf8(isolate_, "obj"), object);
 
   scoped_ptr<base::DictionaryValue> object_result(
       static_cast<base::DictionaryValue*>(
           converter.FromV8Value(object, context)));
   ASSERT_TRUE(object_result.get());
   EXPECT_EQ(2u, object_result->size());
@@ skipping 160 matching lines @@
 
   // The actual result.
   scoped_ptr<base::Value> actual_list(
       converter.FromV8Value(recursive_array, context));
   ASSERT_TRUE(actual_list.get());
 
   EXPECT_TRUE(expected_list.Equals(actual_list.get()));
 
   // Now create a recursive object
   const std::string key("key");
-  v8::Handle<v8::Object> recursive_object(v8::Object::New());
+  v8::Handle<v8::Object> recursive_object(v8::Object::New(isolate_));
   v8::TryCatch try_catch;
   recursive_object->Set(
       v8::String::NewFromUtf8(
           isolate_, key.c_str(), v8::String::kNormalString, key.length()),
       recursive_object);
   ASSERT_FALSE(try_catch.HasCaught());
 
   // The first repetition should be trimmed and replaced by a null value.
   base::DictionaryValue expected_dictionary;
   expected_dictionary.Set(key, base::Value::CreateNullValue());
 
   // The actual result.
   scoped_ptr<base::Value> actual_dictionary(
       converter.FromV8Value(recursive_object, context));
   ASSERT_TRUE(actual_dictionary.get());
 
   EXPECT_TRUE(expected_dictionary.Equals(actual_dictionary.get()));
 }
 
 TEST_F(V8ValueConverterImplTest, MaxRecursionDepth) {
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate_, context_);
   v8::Context::Scope context_scope(context);
 
   // Must larger than kMaxRecursionDepth in v8_value_converter_impl.cc.
   int kDepth = 1000;
   const char kKey[] = "key";
 
-  v8::Local<v8::Object> deep_object = v8::Object::New();
+  v8::Local<v8::Object> deep_object = v8::Object::New(isolate_);
 
   v8::Local<v8::Object> leaf = deep_object;
   for (int i = 0; i < kDepth; ++i) {
-    v8::Local<v8::Object> new_object = v8::Object::New();
+    v8::Local<v8::Object> new_object = v8::Object::New(isolate_);
     leaf->Set(v8::String::NewFromUtf8(isolate_, kKey), new_object);
     leaf = new_object;
   }
 
   V8ValueConverterImpl converter;
   scoped_ptr<base::Value> value(converter.FromV8Value(deep_object, context));
   ASSERT_TRUE(value);
 
   // Expected depth is kMaxRecursionDepth in v8_value_converter_impl.cc.
   int kExpectedDepth = 100;
 
   base::Value* current = value.get();
   for (int i = 1; i < kExpectedDepth; ++i) {
     base::DictionaryValue* current_as_object = NULL;
     ASSERT_TRUE(current->GetAsDictionary(&current_as_object)) << i;
     ASSERT_TRUE(current_as_object->Get(kKey, &current)) << i;
   }
 
   // The leaf node shouldn't have any properties.
   base::DictionaryValue empty;
   EXPECT_TRUE(base::Value::Equals(&empty, current)) << *current;
 }
 
 }  // namespace content