Added a version of the v8::HandleScope constructor with an Isolate and use that consistently.

test/cctest/test-declarative-accessors.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 96 matching lines @@
   obj_template->SetInternalFieldCount((internal_field+1)*2 + 7);
   context->Global()->Set(v8_str(class_name), constructor->GetFunction());
   return obj_template;
 }
 
 
 static void VerifyRead(v8::Handle<v8::DeclaredAccessorDescriptor> descriptor,
                        int internal_field,
                        void* internal_object,
                        v8::Handle<v8::Value> expected_value) {
-  v8::HandleScope scope;
   LocalContext local_context;
+  v8::HandleScope scope(local_context->GetIsolate());
   v8::Handle<v8::Context> context = local_context.local();
   CreateConstructor(context, "Accessible", internal_field, "x", descriptor);
   // Setup object.
   CompileRun("var accessible = new Accessible();");
   v8::Local<v8::Object> obj(
       v8::Object::Cast(*context->Global()->Get(v8_str("accessible"))));
   obj->SetAlignedPointerInInternalField(internal_field, internal_object);
   bool added_accessor;
   added_accessor = obj->SetAccessor(v8_str("y"), descriptor);
   CHECK(added_accessor);
@@ skipping 32 matching lines @@
 }
 
 
 typedef v8::ObjectOperationDescriptor OOD;
 
 template<typename T>
 static void TestPrimitiveValue(
     T value,
     v8::DeclaredAccessorDescriptorDataType data_type,
     DescriptorTestHelper* helper) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(helper->isolate_);
   int index = 17;
   int internal_field = 6;
   v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
       OOD::NewInternalFieldDereference(helper->isolate_, internal_field)
       ->NewRawShift(helper->isolate_, static_cast<uint16_t>(index*sizeof(T)))
       ->NewPrimitiveValue(helper->isolate_, data_type, 0);
   v8::Handle<v8::Value> expected = Convert(value, helper->isolate_);
   helper->array_->Reset();
   helper->array_->As<T*>()[index] = value;
   VerifyRead(descriptor, internal_field, *helper->array_, expected);
 }
 
 
 TEST(PrimitiveValueRead) {
   DescriptorTestHelper helper;
   TestPrimitiveValue<int32_t>(203, v8::kDescriptorInt32Type, &helper);
   TestPrimitiveValue<float>(23.7f, v8::kDescriptorFloatType, &helper);
   TestPrimitiveValue<double>(23.7, v8::kDescriptorDoubleType, &helper);
 }
 
 
 template<typename T>
 static void TestBitmaskCompare(T bitmask,
                                T compare_value,
                                DescriptorTestHelper* helper) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(helper->isolate_);
   int index = 13;
   int internal_field = 4;
   v8::Handle<v8::RawOperationDescriptor> raw_descriptor =
       OOD::NewInternalFieldDereference(helper->isolate_, internal_field)
       ->NewRawShift(helper->isolate_, static_cast<uint16_t>(index*sizeof(T)));
   v8::Handle<v8::DeclaredAccessorDescriptor> descriptor;
   switch (sizeof(T)) {
     case 1:
       descriptor = raw_descriptor->NewBitmaskCompare8(
             helper->isolate_,
@@ skipping 29 matching lines @@
 TEST(BitmaskCompareRead) {
   DescriptorTestHelper helper;
   TestBitmaskCompare<uint8_t>(0xf3, 0xa8, &helper);
   TestBitmaskCompare<uint16_t>(0xfefe, 0x7d42, &helper);
   TestBitmaskCompare<uint32_t>(0xfefeab18, 0x1234fdec, &helper);
 }
 
 
 TEST(PointerCompareRead) {
   DescriptorTestHelper helper;
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(helper.isolate_);
   int index = 35;
   int internal_field = 3;
   void* ptr = helper.isolate_;
   v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
       OOD::NewInternalFieldDereference(helper.isolate_, internal_field)
       ->NewRawShift(helper.isolate_, static_cast<uint16_t>(index*sizeof(ptr)))
       ->NewPointerCompare(helper.isolate_, ptr);
   AlignedArray* array = *helper.array_;
   VerifyRead(descriptor, internal_field, array, v8::False(helper.isolate_));
   array->As<uintptr_t*>()[index] = reinterpret_cast<uintptr_t>(ptr);
   VerifyRead(descriptor, internal_field, array, v8::True(helper.isolate_));
 }
 
 
 TEST(PointerDereferenceRead) {
   DescriptorTestHelper helper;
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(helper.isolate_);
   int first_index = 13;
   int internal_field = 7;
   int second_index = 11;
   int pointed_to_index = 75;
   uint16_t expected = 0x1425;
   v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
       OOD::NewInternalFieldDereference(helper.isolate_, internal_field)
       ->NewRawShift(helper.isolate_, first_index*kPointerSize)
       ->NewRawDereference(helper.isolate_)
       ->NewRawShift(helper.isolate_,
                     static_cast<uint16_t>(second_index*sizeof(int16_t)))
       ->NewPrimitiveValue(helper.isolate_, v8::kDescriptorInt16Type, 0);
   AlignedArray* array = *helper.array_;
   array->As<uintptr_t**>()[first_index] =
       &array->As<uintptr_t*>()[pointed_to_index];
   VerifyRead(descriptor, internal_field, array, v8::Integer::New(0));
   second_index += pointed_to_index*sizeof(uintptr_t)/sizeof(uint16_t);
   array->As<uint16_t*>()[second_index] = expected;
   VerifyRead(descriptor, internal_field, array, v8::Integer::New(expected));
 }
 
 
 TEST(HandleDereferenceRead) {
   DescriptorTestHelper helper;
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(helper.isolate_);
   int index = 13;
   int internal_field = 0;
   v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
       OOD::NewInternalFieldDereference(helper.isolate_, internal_field)
       ->NewRawShift(helper.isolate_, index*kPointerSize)
       ->NewHandleDereference(helper.isolate_);
   HandleArray* array = *helper.handle_array_;
   v8::Handle<v8::String> expected = v8_str("whatever");
   array->handles_[index] = v8::Persistent<v8::Value>::New(helper.isolate_,
                                                           expected);
   VerifyRead(descriptor, internal_field, array, expected);
 }
-