Revert r14310 due to isolate tests failure.

src/d8.cc

 // Copyright 2012 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 65 matching lines @@
   return ThrowException(String::New(message));
 }
 
 
 // TODO(rossberg): should replace these by proper uses of HasInstance,
 // once we figure out a good way to make the templates global.
 const char kArrayBufferMarkerPropName[] = "d8::_is_array_buffer_";
 const char kArrayMarkerPropName[] = "d8::_is_typed_array_";
 
 
-#define FOR_EACH_STRING(V) \
+#define FOR_EACH_SYMBOL(V) \
   V(ArrayBuffer, "ArrayBuffer") \
   V(ArrayBufferMarkerPropName, kArrayBufferMarkerPropName) \
   V(ArrayMarkerPropName, kArrayMarkerPropName) \
   V(buffer, "buffer") \
   V(byteLength, "byteLength") \
   V(byteOffset, "byteOffset") \
   V(BYTES_PER_ELEMENT, "BYTES_PER_ELEMENT")  \
   V(length, "length")
 
 
-class PerIsolateData {
+class Symbols {
  public:
-  explicit PerIsolateData(Isolate* isolate) : isolate_(isolate), realms_(NULL) {
+  explicit Symbols(Isolate* isolate) : isolate_(isolate) {
     HandleScope scope(isolate);
-#define INIT_STRING(name, value) \
-    name##_string_ = Persistent<String>::New(isolate, String::NewSymbol(value));
-    FOR_EACH_STRING(INIT_STRING)
-#undef INIT_STRING
+#define INIT_SYMBOL(name, value) \
+    name##_ = Persistent<String>::New(isolate, String::NewSymbol(value));
+    FOR_EACH_SYMBOL(INIT_SYMBOL)
+#undef INIT_SYMBOL
     isolate->SetData(this);
   }
 
-  ~PerIsolateData() {
-#define DISPOSE_STRING(name, value) name##_string_.Dispose(isolate_);
-    FOR_EACH_STRING(DISPOSE_STRING)
-#undef DISPOSE_STRING
+  ~Symbols() {
+#define DISPOSE_SYMBOL(name, value) name##_.Dispose(isolate_);
+    FOR_EACH_SYMBOL(DISPOSE_SYMBOL)
+#undef DISPOSE_SYMBOL
     isolate_->SetData(NULL);  // Not really needed, just to be sure...
   }
 
-  inline static PerIsolateData* Get(Isolate* isolate) {
-    return reinterpret_cast<PerIsolateData*>(isolate->GetData());
+#define DEFINE_SYMBOL_GETTER(name, value) \
+  static Persistent<String> name(Isolate* isolate) { \
+    return reinterpret_cast<Symbols*>(isolate->GetData())->name##_; \
   }
-
-#define DEFINE_STRING_GETTER(name, value) \
-  static Persistent<String> name##_string(Isolate* isolate) { \
-    return Get(isolate)->name##_string_; \
-  }
-  FOR_EACH_STRING(DEFINE_STRING_GETTER)
-#undef DEFINE_STRING_GETTER
+  FOR_EACH_SYMBOL(DEFINE_SYMBOL_GETTER)
+#undef DEFINE_SYMBOL_GETTER
 
  private:
-  friend class Shell;
   Isolate* isolate_;
-  int realm_count_;
-  int realm_current_;
-  int realm_switch_;
-  Persistent<Context>* realms_;
-  Persistent<Value> realm_shared_;
-
-#define DEFINE_MEMBER(name, value) Persistent<String> name##_string_;
-  FOR_EACH_STRING(DEFINE_MEMBER)
+#define DEFINE_MEMBER(name, value) Persistent<String> name##_;
+  FOR_EACH_SYMBOL(DEFINE_MEMBER)
 #undef DEFINE_MEMBER
-
-  void RealmInit();
-  int RealmFind(Handle<Context> context);
 };
 
 
 LineEditor *LineEditor::current_ = NULL;
 
 
 LineEditor::LineEditor(Type type, const char* name)
     : type_(type), name_(name) {
   if (current_ == NULL || current_->type_ < type) current_ = this;
 }
@@ skipping 63 matching lines @@
 #else
   bool FLAG_debugger = false;
 #endif  // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT
   HandleScope handle_scope(isolate);
   TryCatch try_catch;
   options.script_executed = true;
   if (FLAG_debugger) {
     // When debugging make exceptions appear to be uncaught.
     try_catch.SetVerbose(true);
   }
-  Handle<Script> script = Script::New(source, name);
+  Handle<Script> script = Script::Compile(source, name);
   if (script.IsEmpty()) {
     // Print errors that happened during compilation.
     if (report_exceptions && !FLAG_debugger)
       ReportException(isolate, &try_catch);
     return false;
   } else {
-    PerIsolateData* data = PerIsolateData::Get(isolate);
-    Local<Context> realm =
-        Local<Context>::New(data->realms_[data->realm_current_]);
-    realm->Enter();
     Handle<Value> result = script->Run();
-    realm->Exit();
-    data->realm_current_ = data->realm_switch_;
     if (result.IsEmpty()) {
       ASSERT(try_catch.HasCaught());
       // Print errors that happened during execution.
       if (report_exceptions && !FLAG_debugger)
         ReportException(isolate, &try_catch);
       return false;
     } else {
       ASSERT(!try_catch.HasCaught());
       if (print_result) {
 #if !defined(V8_SHARED)
@@ skipping 20 matching lines @@
           printf("\n");
         }
 #endif
       }
       return true;
     }
   }
 }
 
 
-void PerIsolateData::RealmInit() {
-  if (realms_ != NULL) {
-    // Drop realms from previous run.
-    for (int i = 0; i < realm_count_; ++i) realms_[i].Dispose(isolate_);
-    delete[] realms_;
-    if (!realm_shared_.IsEmpty()) realm_shared_.Dispose(isolate_);
-  }
-  realm_count_ = 1;
-  realm_current_ = 0;
-  realm_switch_ = 0;
-  realms_ = new Persistent<Context>[1];
-  realms_[0] = Persistent<Context>::New(isolate_, Context::GetEntered());
-  realm_shared_.Clear();
-}
-
-
-int PerIsolateData::RealmFind(Handle<Context> context) {
-  for (int i = 0; i < realm_count_; ++i) {
-    if (realms_[i] == context) return i;
-  }
-  return -1;
-}
-
-
-// Realm.current() returns the index of the currently active realm.
-Handle<Value> Shell::RealmCurrent(const Arguments& args) {
-  Isolate* isolate = args.GetIsolate();
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  int index = data->RealmFind(Context::GetEntered());
-  if (index == -1) return Undefined(isolate);
-  return Number::New(index);
-}
-
-
-// Realm.owner(o) returns the index of the realm that created o.
-Handle<Value> Shell::RealmOwner(const Arguments& args) {
-  Isolate* isolate = args.GetIsolate();
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  if (args.Length() < 1 || !args[0]->IsObject()) {
-    return Throw("Invalid argument");
-  }
-  int index = data->RealmFind(args[0]->ToObject()->CreationContext());
-  if (index == -1) return Undefined(isolate);
-  return Number::New(index);
-}
-
-
-// Realm.global(i) returns the global object of realm i.
-// (Note that properties of global objects cannot be read/written cross-realm.)
-Handle<Value> Shell::RealmGlobal(const Arguments& args) {
-  PerIsolateData* data = PerIsolateData::Get(args.GetIsolate());
-  if (args.Length() < 1 || !args[0]->IsNumber()) {
-    return Throw("Invalid argument");
-  }
-  int index = args[0]->Uint32Value();
-  if (index >= data->realm_count_ || data->realms_[index].IsEmpty()) {
-    return Throw("Invalid realm index");
-  }
-  return data->realms_[index]->Global();
-}
-
-
-// Realm.create() creates a new realm and returns its index.
-Handle<Value> Shell::RealmCreate(const Arguments& args) {
-  Isolate* isolate = args.GetIsolate();
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  Persistent<Context>* old_realms = data->realms_;
-  int index = data->realm_count_;
-  data->realms_ = new Persistent<Context>[++data->realm_count_];
-  for (int i = 0; i < index; ++i) data->realms_[i] = old_realms[i];
-  delete[] old_realms;
-  Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
-  data->realms_[index] = Persistent<Context>::New(
-      isolate, Context::New(isolate, NULL, global_template));
-  return Number::New(index);
-}
-
-
-// Realm.dispose(i) disposes the reference to the realm i.
-Handle<Value> Shell::RealmDispose(const Arguments& args) {
-  Isolate* isolate = args.GetIsolate();
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  if (args.Length() < 1 || !args[0]->IsNumber()) {
-    return Throw("Invalid argument");
-  }
-  int index = args[0]->Uint32Value();
-  if (index >= data->realm_count_ || data->realms_[index].IsEmpty() ||
-      index == 0 ||
-      index == data->realm_current_ || index == data->realm_switch_) {
-    return Throw("Invalid realm index");
-  }
-  data->realms_[index].Dispose(isolate);
-  data->realms_[index].Clear();
-  return Undefined(isolate);
-}
-
-
-// Realm.switch(i) switches to the realm i for consecutive interactive inputs.
-Handle<Value> Shell::RealmSwitch(const Arguments& args) {
-  Isolate* isolate = args.GetIsolate();
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  if (args.Length() < 1 || !args[0]->IsNumber()) {
-    return Throw("Invalid argument");
-  }
-  int index = args[0]->Uint32Value();
-  if (index >= data->realm_count_ || data->realms_[index].IsEmpty()) {
-    return Throw("Invalid realm index");
-  }
-  data->realm_switch_ = index;
-  return Undefined(isolate);
-}
-
-
-// Realm.eval(i, s) evaluates s in realm i and returns the result.
-Handle<Value> Shell::RealmEval(const Arguments& args) {
-  Isolate* isolate = args.GetIsolate();
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  if (args.Length() < 2 || !args[0]->IsNumber() || !args[1]->IsString()) {
-    return Throw("Invalid argument");
-  }
-  int index = args[0]->Uint32Value();
-  if (index >= data->realm_count_ || data->realms_[index].IsEmpty()) {
-    return Throw("Invalid realm index");
-  }
-  Handle<Script> script = Script::New(args[1]->ToString());
-  if (script.IsEmpty()) return Undefined(isolate);
-  Local<Context> realm = Local<Context>::New(data->realms_[index]);
-  realm->Enter();
-  Handle<Value> result = script->Run();
-  realm->Exit();
-  return result;
-}
-
-
-// Realm.shared is an accessor for a single shared value across realms.
-Handle<Value> Shell::RealmSharedGet(Local<String> property,
-                                    const AccessorInfo& info) {
-  Isolate* isolate = info.GetIsolate();
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  if (data->realm_shared_.IsEmpty()) return Undefined(isolate);
-  return data->realm_shared_;
-}
-
-void Shell::RealmSharedSet(Local<String> property,
-                           Local<Value> value,
-                           const AccessorInfo& info) {
-  Isolate* isolate = info.GetIsolate();
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  if (!data->realm_shared_.IsEmpty()) data->realm_shared_.Dispose(isolate);
-  data->realm_shared_ = Persistent<Value>::New(isolate, value);
-}
-
-
 Handle<Value> Shell::Print(const Arguments& args) {
   Handle<Value> val = Write(args);
   printf("\n");
   fflush(stdout);
   return val;
 }
 
 
 Handle<Value> Shell::Write(const Arguments& args) {
   for (int i = 0; i < args.Length(); i++) {
@@ skipping 141 matching lines @@
   // Make sure the total size fits into a (signed) int.
   if (length < 0 || length > kMaxSize) {
     return Throw("ArrayBuffer exceeds maximum size (2G)");
   }
   uint8_t* data = new uint8_t[length];
   if (data == NULL) {
     return Throw("Memory allocation failed");
   }
   memset(data, 0, length);
 
-  buffer->SetHiddenValue(
-      PerIsolateData::ArrayBufferMarkerPropName_string(isolate), True());
+  buffer->SetHiddenValue(Symbols::ArrayBufferMarkerPropName(isolate), True());
   Persistent<Object> persistent_array =
       Persistent<Object>::New(isolate, buffer);
   persistent_array.MakeWeak(isolate, data, ExternalArrayWeakCallback);
   persistent_array.MarkIndependent(isolate);
   isolate->AdjustAmountOfExternalAllocatedMemory(length);
 
   buffer->SetIndexedPropertiesToExternalArrayData(
       data, v8::kExternalByteArray, length);
-  buffer->Set(PerIsolateData::byteLength_string(isolate),
+  buffer->Set(Symbols::byteLength(isolate),
               Int32::New(length, isolate),
               ReadOnly);
 
   return buffer;
 }
 
 
 Handle<Value> Shell::ArrayBuffer(const Arguments& args) {
   if (!args.IsConstructCall()) {
     Handle<Value>* rec_args = new Handle<Value>[args.Length()];
@@ skipping 24 matching lines @@
                                           int32_t element_size) {
   ASSERT(element_size == 1 || element_size == 2 ||
          element_size == 4 || element_size == 8);
   ASSERT(byteLength == length * element_size);
 
   void* data = buffer->GetIndexedPropertiesExternalArrayData();
   ASSERT(data != NULL);
 
   array->SetIndexedPropertiesToExternalArrayData(
       static_cast<uint8_t*>(data) + byteOffset, type, length);
-  array->SetHiddenValue(PerIsolateData::ArrayMarkerPropName_string(isolate),
+  array->SetHiddenValue(Symbols::ArrayMarkerPropName(isolate),
                         Int32::New(type, isolate));
-  array->Set(PerIsolateData::byteLength_string(isolate),
+  array->Set(Symbols::byteLength(isolate),
              Int32::New(byteLength, isolate),
              ReadOnly);
-  array->Set(PerIsolateData::byteOffset_string(isolate),
+  array->Set(Symbols::byteOffset(isolate),
              Int32::New(byteOffset, isolate),
              ReadOnly);
-  array->Set(PerIsolateData::length_string(isolate),
+  array->Set(Symbols::length(isolate),
              Int32::New(length, isolate),
              ReadOnly);
-  array->Set(PerIsolateData::BYTES_PER_ELEMENT_string(isolate),
+  array->Set(Symbols::BYTES_PER_ELEMENT(isolate),
              Int32::New(element_size, isolate));
-  array->Set(PerIsolateData::buffer_string(isolate),
+  array->Set(Symbols::buffer(isolate),
              buffer,
              ReadOnly);
 
   return array;
 }
 
 
 Handle<Value> Shell::CreateExternalArray(const Arguments& args,
                                          ExternalArrayType type,
                                          int32_t element_size) {
@@ skipping 20 matching lines @@
   Handle<Object> buffer;
   int32_t length;
   int32_t byteLength;
   int32_t byteOffset;
   bool init_from_array = false;
   if (args.Length() == 0) {
     return Throw("Array constructor must have at least one argument");
   }
   if (args[0]->IsObject() &&
       !args[0]->ToObject()->GetHiddenValue(
-         PerIsolateData::ArrayBufferMarkerPropName_string(isolate)).IsEmpty()) {
+          Symbols::ArrayBufferMarkerPropName(isolate)).IsEmpty()) {
     // Construct from ArrayBuffer.
     buffer = args[0]->ToObject();
-    int32_t bufferLength = convertToUint(
-        buffer->Get(PerIsolateData::byteLength_string(isolate)), &try_catch);
+    int32_t bufferLength =
+        convertToUint(buffer->Get(Symbols::byteLength(isolate)), &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
 
     if (args.Length() < 2 || args[1]->IsUndefined()) {
       byteOffset = 0;
     } else {
       byteOffset = convertToUint(args[1], &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
       if (byteOffset > bufferLength) {
         return Throw("byteOffset out of bounds");
       }
@@ skipping 11 matching lines @@
     } else {
       length = convertToUint(args[2], &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
       byteLength = length * element_size;
       if (byteOffset + byteLength > bufferLength) {
         return Throw("length out of bounds");
       }
     }
   } else {
     if (args[0]->IsObject() &&
-        args[0]->ToObject()->Has(PerIsolateData::length_string(isolate))) {
+        args[0]->ToObject()->Has(Symbols::length(isolate))) {
       // Construct from array.
-      Local<Value> value =
-          args[0]->ToObject()->Get(PerIsolateData::length_string(isolate));
+      Local<Value> value = args[0]->ToObject()->Get(Symbols::length(isolate));
       if (try_catch.HasCaught()) return try_catch.ReThrow();
       length = convertToUint(value, &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
       init_from_array = true;
     } else {
       // Construct from size.
       length = convertToUint(args[0], &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
     }
     byteLength = length * element_size;
     byteOffset = 0;
 
     Handle<Object> global = Context::GetCurrent()->Global();
-    Handle<Value> array_buffer =
-        global->Get(PerIsolateData::ArrayBuffer_string(isolate));
+    Handle<Value> array_buffer = global->Get(Symbols::ArrayBuffer(isolate));
     ASSERT(!try_catch.HasCaught() && array_buffer->IsFunction());
     Handle<Value> buffer_args[] = { Uint32::New(byteLength, isolate) };
     Handle<Value> result = Handle<Function>::Cast(array_buffer)->NewInstance(
         1, buffer_args);
     if (try_catch.HasCaught()) return result;
     buffer = result->ToObject();
   }
 
   Handle<Object> array =
       CreateExternalArray(isolate, args.This(), buffer, type, length,
@@ skipping 14 matching lines @@
 
 Handle<Value> Shell::ArrayBufferSlice(const Arguments& args) {
   TryCatch try_catch;
 
   if (!args.This()->IsObject()) {
     return Throw("'slice' invoked on non-object receiver");
   }
 
   Isolate* isolate = args.GetIsolate();
   Local<Object> self = args.This();
-  Local<Value> marker = self->GetHiddenValue(
-      PerIsolateData::ArrayBufferMarkerPropName_string(isolate));
+  Local<Value> marker =
+      self->GetHiddenValue(Symbols::ArrayBufferMarkerPropName(isolate));
   if (marker.IsEmpty()) {
     return Throw("'slice' invoked on wrong receiver type");
   }
 
-  int32_t length = convertToUint(
-      self->Get(PerIsolateData::byteLength_string(isolate)), &try_catch);
+  int32_t length =
+      convertToUint(self->Get(Symbols::byteLength(isolate)), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
 
   if (args.Length() == 0) {
     return Throw("'slice' must have at least one argument");
   }
   int32_t begin = convertToInt(args[0], &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
   if (begin < 0) begin += length;
   if (begin < 0) begin = 0;
   if (begin > length) begin = length;
@@ skipping 28 matching lines @@
 Handle<Value> Shell::ArraySubArray(const Arguments& args) {
   TryCatch try_catch;
 
   if (!args.This()->IsObject()) {
     return Throw("'subarray' invoked on non-object receiver");
   }
 
   Isolate* isolate = args.GetIsolate();
   Local<Object> self = args.This();
   Local<Value> marker =
-      self->GetHiddenValue(PerIsolateData::ArrayMarkerPropName_string(isolate));
+      self->GetHiddenValue(Symbols::ArrayMarkerPropName(isolate));
   if (marker.IsEmpty()) {
     return Throw("'subarray' invoked on wrong receiver type");
   }
 
-  Handle<Object> buffer =
-      self->Get(PerIsolateData::buffer_string(isolate))->ToObject();
+  Handle<Object> buffer = self->Get(Symbols::buffer(isolate))->ToObject();
   if (try_catch.HasCaught()) return try_catch.ReThrow();
-  int32_t length = convertToUint(
-      self->Get(PerIsolateData::length_string(isolate)), &try_catch);
+  int32_t length =
+      convertToUint(self->Get(Symbols::length(isolate)), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
-  int32_t byteOffset = convertToUint(
-      self->Get(PerIsolateData::byteOffset_string(isolate)), &try_catch);
+  int32_t byteOffset =
+      convertToUint(self->Get(Symbols::byteOffset(isolate)), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
-  int32_t element_size = convertToUint(
-      self->Get(PerIsolateData::BYTES_PER_ELEMENT_string(isolate)), &try_catch);
+  int32_t element_size =
+      convertToUint(self->Get(Symbols::BYTES_PER_ELEMENT(isolate)), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
 
   if (args.Length() == 0) {
     return Throw("'subarray' must have at least one argument");
   }
   int32_t begin = convertToInt(args[0], &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
   if (begin < 0) begin += length;
   if (begin < 0) begin = 0;
   if (begin > length) begin = length;
@@ skipping 24 matching lines @@
 Handle<Value> Shell::ArraySet(const Arguments& args) {
   TryCatch try_catch;
 
   if (!args.This()->IsObject()) {
     return Throw("'set' invoked on non-object receiver");
   }
 
   Isolate* isolate = args.GetIsolate();
   Local<Object> self = args.This();
   Local<Value> marker =
-      self->GetHiddenValue(PerIsolateData::ArrayMarkerPropName_string(isolate));
+      self->GetHiddenValue(Symbols::ArrayMarkerPropName(isolate));
   if (marker.IsEmpty()) {
     return Throw("'set' invoked on wrong receiver type");
   }
-  int32_t length = convertToUint(
-      self->Get(PerIsolateData::length_string(isolate)), &try_catch);
+  int32_t length =
+      convertToUint(self->Get(Symbols::length(isolate)), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
-  int32_t element_size = convertToUint(
-      self->Get(PerIsolateData::BYTES_PER_ELEMENT_string(isolate)), &try_catch);
+  int32_t element_size =
+      convertToUint(self->Get(Symbols::BYTES_PER_ELEMENT(isolate)), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
 
   if (args.Length() == 0) {
     return Throw("'set' must have at least one argument");
   }
   if (!args[0]->IsObject() ||
-      !args[0]->ToObject()->Has(PerIsolateData::length_string(isolate))) {
+      !args[0]->ToObject()->Has(Symbols::length(isolate))) {
     return Throw("'set' invoked with non-array argument");
   }
   Handle<Object> source = args[0]->ToObject();
-  int32_t source_length = convertToUint(
-      source->Get(PerIsolateData::length_string(isolate)), &try_catch);
+  int32_t source_length =
+      convertToUint(source->Get(Symbols::length(isolate)), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
 
   int32_t offset;
   if (args.Length() < 2 || args[1]->IsUndefined()) {
     offset = 0;
   } else {
     offset = convertToUint(args[1], &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
   }
   if (offset + source_length > length) {
     return Throw("offset or source length out of bounds");
   }
 
   int32_t source_element_size;
-  if (source->GetHiddenValue(
-          PerIsolateData::ArrayMarkerPropName_string(isolate)).IsEmpty()) {
+  if (source->GetHiddenValue(Symbols::ArrayMarkerPropName(isolate)).IsEmpty()) {
     source_element_size = 0;
   } else {
-    source_element_size = convertToUint(
-        source->Get(PerIsolateData::BYTES_PER_ELEMENT_string(isolate)),
-        &try_catch);
+    source_element_size =
+        convertToUint(source->Get(Symbols::BYTES_PER_ELEMENT(isolate)),
+                      &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
   }
 
   if (element_size == source_element_size &&
       self->GetConstructor()->StrictEquals(source->GetConstructor())) {
     // Use memmove on the array buffers.
-    Handle<Object> buffer =
-        self->Get(PerIsolateData::buffer_string(isolate))->ToObject();
+    Handle<Object> buffer = self->Get(Symbols::buffer(isolate))->ToObject();
     if (try_catch.HasCaught()) return try_catch.ReThrow();
     Handle<Object> source_buffer =
-        source->Get(PerIsolateData::buffer_string(isolate))->ToObject();
+        source->Get(Symbols::buffer(isolate))->ToObject();
     if (try_catch.HasCaught()) return try_catch.ReThrow();
-    int32_t byteOffset = convertToUint(
-        self->Get(PerIsolateData::byteOffset_string(isolate)), &try_catch);
+    int32_t byteOffset =
+        convertToUint(self->Get(Symbols::byteOffset(isolate)), &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
-    int32_t source_byteOffset = convertToUint(
-        source->Get(PerIsolateData::byteOffset_string(isolate)), &try_catch);
+    int32_t source_byteOffset =
+        convertToUint(source->Get(Symbols::byteOffset(isolate)), &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
 
     uint8_t* dest = byteOffset + offset * element_size + static_cast<uint8_t*>(
         buffer->GetIndexedPropertiesExternalArrayData());
     uint8_t* src = source_byteOffset + static_cast<uint8_t*>(
         source_buffer->GetIndexedPropertiesExternalArrayData());
     memmove(dest, src, source_length * element_size);
   } else if (source_element_size == 0) {
     // Source is not a typed array, copy element-wise sequentially.
     for (int i = 0; i < source_length; ++i) {
       self->Set(offset + i, source->Get(i));
       if (try_catch.HasCaught()) return try_catch.ReThrow();
     }
   } else {
     // Need to copy element-wise to make the right conversions.
-    Handle<Object> buffer =
-        self->Get(PerIsolateData::buffer_string(isolate))->ToObject();
+    Handle<Object> buffer = self->Get(Symbols::buffer(isolate))->ToObject();
     if (try_catch.HasCaught()) return try_catch.ReThrow();
     Handle<Object> source_buffer =
-        source->Get(PerIsolateData::buffer_string(isolate))->ToObject();
+        source->Get(Symbols::buffer(isolate))->ToObject();
     if (try_catch.HasCaught()) return try_catch.ReThrow();
 
     if (buffer->StrictEquals(source_buffer)) {
       // Same backing store, need to handle overlap correctly.
       // This gets a bit tricky in the case of different element sizes
       // (which, of course, is extremely unlikely to ever occur in practice).
-      int32_t byteOffset = convertToUint(
-          self->Get(PerIsolateData::byteOffset_string(isolate)), &try_catch);
+      int32_t byteOffset =
+          convertToUint(self->Get(Symbols::byteOffset(isolate)), &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
-      int32_t source_byteOffset = convertToUint(
-          source->Get(PerIsolateData::byteOffset_string(isolate)), &try_catch);
+      int32_t source_byteOffset =
+          convertToUint(source->Get(Symbols::byteOffset(isolate)), &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
 
       // Copy as much as we can from left to right.
       int i = 0;
       int32_t next_dest_offset = byteOffset + (offset + 1) * element_size;
       int32_t next_src_offset = source_byteOffset + source_element_size;
       while (i < length && next_dest_offset <= next_src_offset) {
         self->Set(offset + i, source->Get(i));
         ++i;
         next_dest_offset += element_size;
@@ skipping 27 matching lines @@
   }
 
   return Undefined(args.GetIsolate());
 }
 
 
 void Shell::ExternalArrayWeakCallback(v8::Isolate* isolate,
                                       Persistent<Value> object,
                                       void* data) {
   HandleScope scope(isolate);
-  int32_t length = object->ToObject()->Get(
-      PerIsolateData::byteLength_string(isolate))->Uint32Value();
+  int32_t length =
+      object->ToObject()->Get(Symbols::byteLength(isolate))->Uint32Value();
   isolate->AdjustAmountOfExternalAllocatedMemory(-length);
   delete[] static_cast<uint8_t*>(data);
   object.Dispose(isolate);
 }
 
 
 Handle<Value> Shell::Int8Array(const Arguments& args) {
   return CreateExternalArray(args, v8::kExternalByteArray, sizeof(int8_t));
 }
 
@@ skipping 356 matching lines @@
   global_template->Set(String::New("readline"),
                        FunctionTemplate::New(ReadLine));
   global_template->Set(String::New("load"), FunctionTemplate::New(Load));
   global_template->Set(String::New("quit"), FunctionTemplate::New(Quit));
   global_template->Set(String::New("version"), FunctionTemplate::New(Version));
   global_template->Set(String::New("enableProfiler"),
                        FunctionTemplate::New(EnableProfiler));
   global_template->Set(String::New("disableProfiler"),
                        FunctionTemplate::New(DisableProfiler));
 
-  // Bind the Realm object.
-  Handle<ObjectTemplate> realm_template = ObjectTemplate::New();
-  realm_template->Set(String::New("current"),
-                      FunctionTemplate::New(RealmCurrent));
-  realm_template->Set(String::New("owner"),
-                      FunctionTemplate::New(RealmOwner));
-  realm_template->Set(String::New("global"),
-                      FunctionTemplate::New(RealmGlobal));
-  realm_template->Set(String::New("create"),
-                      FunctionTemplate::New(RealmCreate));
-  realm_template->Set(String::New("dispose"),
-                      FunctionTemplate::New(RealmDispose));
-  realm_template->Set(String::New("switch"),
-                      FunctionTemplate::New(RealmSwitch));
-  realm_template->Set(String::New("eval"),
-                      FunctionTemplate::New(RealmEval));
-  realm_template->SetAccessor(String::New("shared"),
-                              RealmSharedGet, RealmSharedSet);
-  global_template->Set(String::New("Realm"), realm_template);
-
   // Bind the handlers for external arrays.
   PropertyAttribute attr =
       static_cast<PropertyAttribute>(ReadOnly | DontDelete);
-  global_template->Set(PerIsolateData::ArrayBuffer_string(isolate),
+  global_template->Set(Symbols::ArrayBuffer(isolate),
                        CreateArrayBufferTemplate(ArrayBuffer), attr);
   global_template->Set(String::New("Int8Array"),
                        CreateArrayTemplate(Int8Array), attr);
   global_template->Set(String::New("Uint8Array"),
                        CreateArrayTemplate(Uint8Array), attr);
   global_template->Set(String::New("Int16Array"),
                        CreateArrayTemplate(Int16Array), attr);
   global_template->Set(String::New("Uint16Array"),
                        CreateArrayTemplate(Uint16Array), attr);
   global_template->Set(String::New("Int32Array"),
@@ skipping 63 matching lines @@
 Persistent<Context> Shell::CreateEvaluationContext(Isolate* isolate) {
 #ifndef V8_SHARED
   // This needs to be a critical section since this is not thread-safe
   i::ScopedLock lock(context_mutex_);
 #endif  // V8_SHARED
   // Initialize the global objects
   Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
   Persistent<Context> context = Context::New(NULL, global_template);
   ASSERT(!context.IsEmpty());
   Context::Scope scope(context);
-  PerIsolateData::Get(isolate)->RealmInit();
 
 #ifndef V8_SHARED
   i::JSArguments js_args = i::FLAG_js_arguments;
   i::Handle<i::FixedArray> arguments_array =
       FACTORY->NewFixedArray(js_args.argc());
   for (int j = 0; j < js_args.argc(); j++) {
     i::Handle<i::String> arg =
         FACTORY->NewStringFromUtf8(i::CStrVector(js_args[j]));
     arguments_array->set(j, *arg);
   }
@@ skipping 124 matching lines @@
     return Throw("Error loading file");
   }
 
   uint8_t* data = reinterpret_cast<uint8_t*>(
       ReadChars(args.GetIsolate(), *filename, &length));
   if (data == NULL) {
     return Throw("Error reading file");
   }
   Isolate* isolate = args.GetIsolate();
   Handle<Object> buffer = Object::New();
-  buffer->SetHiddenValue(
-      PerIsolateData::ArrayBufferMarkerPropName_string(isolate), True());
+  buffer->SetHiddenValue(Symbols::ArrayBufferMarkerPropName(isolate), True());
   Persistent<Object> persistent_buffer =
       Persistent<Object>::New(isolate, buffer);
   persistent_buffer.MakeWeak(isolate, data, ExternalArrayWeakCallback);
   persistent_buffer.MarkIndependent(isolate);
   isolate->AdjustAmountOfExternalAllocatedMemory(length);
 
   buffer->SetIndexedPropertiesToExternalArrayData(
       data, kExternalUnsignedByteArray, length);
-  buffer->Set(PerIsolateData::byteLength_string(isolate),
+  buffer->Set(Symbols::byteLength(isolate),
       Int32::New(static_cast<int32_t>(length), isolate), ReadOnly);
   return buffer;
 }
 
 
 #ifndef V8_SHARED
 static char* ReadToken(char* data, char token) {
   char* next = i::OS::StrChr(data, token);
   if (next != NULL) {
     *next = '\0';
@@ skipping 172 matching lines @@
 
 
 void SourceGroup::ExecuteInThread() {
   Isolate* isolate = Isolate::New();
   do {
     if (next_semaphore_ != NULL) next_semaphore_->Wait();
     {
       Isolate::Scope iscope(isolate);
       Locker lock(isolate);
       HandleScope scope(isolate);
-      PerIsolateData data(isolate);
+      Symbols symbols(isolate);
       Persistent<Context> context = Shell::CreateEvaluationContext(isolate);
       {
         Context::Scope cscope(context);
         Execute(isolate);
       }
       context.Dispose(isolate);
       if (Shell::options.send_idle_notification) {
         const int kLongIdlePauseInMs = 1000;
         V8::ContextDisposedNotification();
         V8::IdleNotification(kLongIdlePauseInMs);
@@ skipping 241 matching lines @@
 int Shell::Main(int argc, char* argv[]) {
   if (!SetOptions(argc, argv)) return 1;
   int result = 0;
   Isolate* isolate = Isolate::GetCurrent();
   DumbLineEditor dumb_line_editor(isolate);
   {
     Initialize(isolate);
 #ifdef ENABLE_VTUNE_JIT_INTERFACE
     vTune::InitilizeVtuneForV8();
 #endif
-    PerIsolateData data(isolate);
+    Symbols symbols(isolate);
     InitializeDebugger(isolate);
 
     if (options.stress_opt || options.stress_deopt) {
       Testing::SetStressRunType(options.stress_opt
                                 ? Testing::kStressTypeOpt
                                 : Testing::kStressTypeDeopt);
       int stress_runs = Testing::GetStressRuns();
       for (int i = 0; i < stress_runs && result == 0; i++) {
         printf("============ Stress %d/%d ============\n", i + 1, stress_runs);
         Testing::PrepareStressRun(i);
@@ skipping 46 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif