Remove usage of deprecated APIs from cctests

test/cctest/test-debug.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 136 matching lines @@
                            global_template,
                            global_object)) {
     context_->Enter();
   }
   inline ~DebugLocalContext() {
     context_->Exit();
   }
   inline v8::Local<v8::Context> context() { return context_; }
   inline v8::Context* operator->() { return *context_; }
   inline v8::Context* operator*() { return *context_; }
+  inline v8::Isolate* GetIsolate() { return context_->GetIsolate(); }
   inline bool IsReady() { return !context_.IsEmpty(); }
   void ExposeDebug() {
     v8::internal::Isolate* isolate =
         reinterpret_cast<v8::internal::Isolate*>(context_->GetIsolate());
     v8::internal::Factory* factory = isolate->factory();
     v8::internal::Debug* debug = isolate->debug();
     // Expose the debug context global object in the global object for testing.
     debug->Load();
     debug->debug_context()->set_security_token(
         v8::Utils::OpenHandle(*context_)->security_token());
@@ skipping 14 matching lines @@
 };
 
 
 // --- H e l p e r   F u n c t i o n s
 
 
 // Compile and run the supplied source and return the fequested function.
 static v8::Local<v8::Function> CompileFunction(DebugLocalContext* env,
                                                const char* source,
                                                const char* function_name) {
-  v8::Script::Compile(v8::String::New(source))->Run();
-  return v8::Local<v8::Function>::Cast(
-      (*env)->Global()->Get(v8::String::New(function_name)));
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), source))
+      ->Run();
+  return v8::Local<v8::Function>::Cast((*env)->Global()->Get(
+      v8::String::NewFromUtf8(env->GetIsolate(), function_name)));
 }
 
 
 // Compile and run the supplied source and return the requested function.
-static v8::Local<v8::Function> CompileFunction(const char* source,
+static v8::Local<v8::Function> CompileFunction(v8::Isolate* isolate,
+                                               const char* source,
                                                const char* function_name) {
-  v8::Script::Compile(v8::String::New(source))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate, source))->Run();
   v8::Local<v8::Object> global =
       CcTest::isolate()->GetCurrentContext()->Global();
   return v8::Local<v8::Function>::Cast(
-      global->Get(v8::String::New(function_name)));
+      global->Get(v8::String::NewFromUtf8(isolate, function_name)));
 }
 
 
 // Is there any debug info for the function?
 static bool HasDebugInfo(v8::Handle<v8::Function> fun) {
   Handle<v8::internal::JSFunction> f = v8::Utils::OpenHandle(*fun);
   Handle<v8::internal::SharedFunctionInfo> shared(f->shared());
   return Debug::HasDebugInfo(shared);
 }
 
@@ skipping 14 matching lines @@
 
 // Set a break point in a function and return the associated break point
 // number.
 static int SetBreakPoint(v8::Handle<v8::Function> fun, int position) {
   return SetBreakPoint(v8::Utils::OpenHandle(*fun), position);
 }
 
 
 // Set a break point in a function using the Debug object and return the
 // associated break point number.
-static int SetBreakPointFromJS(const char* function_name,
+static int SetBreakPointFromJS(v8::Isolate* isolate,
+                               const char* function_name,
                                int line, int position) {
   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
   OS::SNPrintF(buffer,
                "debug.Debug.setBreakPoint(%s,%d,%d)",
                function_name, line, position);
   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
-  v8::Handle<v8::String> str = v8::String::New(buffer.start());
+  v8::Handle<v8::String> str = v8::String::NewFromUtf8(isolate, buffer.start());
   return v8::Script::Compile(str)->Run()->Int32Value();
 }
 
 
 // Set a break point in a script identified by id using the global Debug object.
-static int SetScriptBreakPointByIdFromJS(int script_id, int line, int column) {
+static int SetScriptBreakPointByIdFromJS(v8::Isolate* isolate, int script_id,
+                                         int line, int column) {
   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
   if (column >= 0) {
     // Column specified set script break point on precise location.
     OS::SNPrintF(buffer,
                  "debug.Debug.setScriptBreakPointById(%d,%d,%d)",
                  script_id, line, column);
   } else {
     // Column not specified set script break point on line.
     OS::SNPrintF(buffer,
                  "debug.Debug.setScriptBreakPointById(%d,%d)",
                  script_id, line);
   }
   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
   {
     v8::TryCatch try_catch;
-    v8::Handle<v8::String> str = v8::String::New(buffer.start());
+    v8::Handle<v8::String> str =
+        v8::String::NewFromUtf8(isolate, buffer.start());
     v8::Handle<v8::Value> value = v8::Script::Compile(str)->Run();
     CHECK(!try_catch.HasCaught());
     return value->Int32Value();
   }
 }
 
 
 // Set a break point in a script identified by name using the global Debug
 // object.
-static int SetScriptBreakPointByNameFromJS(const char* script_name,
-                                           int line, int column) {
+static int SetScriptBreakPointByNameFromJS(v8::Isolate* isolate,
+                                           const char* script_name, int line,
+                                           int column) {
   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
   if (column >= 0) {
     // Column specified set script break point on precise location.
     OS::SNPrintF(buffer,
                  "debug.Debug.setScriptBreakPointByName(\"%s\",%d,%d)",
                  script_name, line, column);
   } else {
     // Column not specified set script break point on line.
     OS::SNPrintF(buffer,
                  "debug.Debug.setScriptBreakPointByName(\"%s\",%d)",
                  script_name, line);
   }
   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
   {
     v8::TryCatch try_catch;
-    v8::Handle<v8::String> str = v8::String::New(buffer.start());
+    v8::Handle<v8::String> str =
+        v8::String::NewFromUtf8(isolate, buffer.start());
     v8::Handle<v8::Value> value = v8::Script::Compile(str)->Run();
     CHECK(!try_catch.HasCaught());
     return value->Int32Value();
   }
 }
 
 
 // Clear a break point.
 static void ClearBreakPoint(int break_point) {
   v8::internal::Isolate* isolate = CcTest::i_isolate();
   v8::internal::Debug* debug = isolate->debug();
   debug->ClearBreakPoint(
       Handle<Object>(v8::internal::Smi::FromInt(break_point), isolate));
 }
 
 
 // Clear a break point using the global Debug object.
-static void ClearBreakPointFromJS(int break_point_number) {
+static void ClearBreakPointFromJS(v8::Isolate* isolate,
+                                  int break_point_number) {
   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
   OS::SNPrintF(buffer,
                "debug.Debug.clearBreakPoint(%d)",
                break_point_number);
   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
-  v8::Script::Compile(v8::String::New(buffer.start()))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate, buffer.start()))->Run();
 }
 
 
-static void EnableScriptBreakPointFromJS(int break_point_number) {
+static void EnableScriptBreakPointFromJS(v8::Isolate* isolate,
+                                         int break_point_number) {
   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
   OS::SNPrintF(buffer,
                "debug.Debug.enableScriptBreakPoint(%d)",
                break_point_number);
   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
-  v8::Script::Compile(v8::String::New(buffer.start()))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate, buffer.start()))->Run();
 }
 
 
-static void DisableScriptBreakPointFromJS(int break_point_number) {
+static void DisableScriptBreakPointFromJS(v8::Isolate* isolate,
+                                          int break_point_number) {
   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
   OS::SNPrintF(buffer,
                "debug.Debug.disableScriptBreakPoint(%d)",
                break_point_number);
   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
-  v8::Script::Compile(v8::String::New(buffer.start()))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate, buffer.start()))->Run();
 }
 
 
-static void ChangeScriptBreakPointConditionFromJS(int break_point_number,
+static void ChangeScriptBreakPointConditionFromJS(v8::Isolate* isolate,
+                                                  int break_point_number,
                                                   const char* condition) {
   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
   OS::SNPrintF(buffer,
                "debug.Debug.changeScriptBreakPointCondition(%d, \"%s\")",
                break_point_number, condition);
   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
-  v8::Script::Compile(v8::String::New(buffer.start()))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate, buffer.start()))->Run();
 }
 
 
-static void ChangeScriptBreakPointIgnoreCountFromJS(int break_point_number,
+static void ChangeScriptBreakPointIgnoreCountFromJS(v8::Isolate* isolate,
+                                                    int break_point_number,
                                                     int ignoreCount) {
   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
   OS::SNPrintF(buffer,
                "debug.Debug.changeScriptBreakPointIgnoreCount(%d, %d)",
                break_point_number, ignoreCount);
   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
-  v8::Script::Compile(v8::String::New(buffer.start()))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate, buffer.start()))->Run();
 }
 
 
 // Change break on exception.
 static void ChangeBreakOnException(bool caught, bool uncaught) {
   v8::internal::Debug* debug = CcTest::i_isolate()->debug();
   debug->ChangeBreakOnException(v8::internal::BreakException, caught);
   debug->ChangeBreakOnException(v8::internal::BreakUncaughtException, uncaught);
 }
 
 
 // Change break on exception using the global Debug object.
-static void ChangeBreakOnExceptionFromJS(bool caught, bool uncaught) {
+static void ChangeBreakOnExceptionFromJS(v8::Isolate* isolate, bool caught,
+                                         bool uncaught) {
   if (caught) {
     v8::Script::Compile(
-        v8::String::New("debug.Debug.setBreakOnException()"))->Run();
+        v8::String::NewFromUtf8(isolate, "debug.Debug.setBreakOnException()"))
+        ->Run();
   } else {
     v8::Script::Compile(
-        v8::String::New("debug.Debug.clearBreakOnException()"))->Run();
+        v8::String::NewFromUtf8(isolate, "debug.Debug.clearBreakOnException()"))
+        ->Run();
   }
   if (uncaught) {
     v8::Script::Compile(
-        v8::String::New("debug.Debug.setBreakOnUncaughtException()"))->Run();
+        v8::String::NewFromUtf8(
+            isolate, "debug.Debug.setBreakOnUncaughtException()"))->Run();
   } else {
     v8::Script::Compile(
-        v8::String::New("debug.Debug.clearBreakOnUncaughtException()"))->Run();
+        v8::String::NewFromUtf8(
+            isolate, "debug.Debug.clearBreakOnUncaughtException()"))->Run();
   }
 }
 
 
 // Prepare to step to next break location.
 static void PrepareStep(StepAction step_action) {
   v8::internal::Debug* debug = CcTest::i_isolate()->debug();
   debug->PrepareStep(step_action, 1, StackFrame::NO_ID);
 }
 
@@ skipping 394 matching lines @@
   // When hitting a debug event listener there must be a break set.
   CHECK_NE(debug->break_id(), 0);
 
   // Count the number of breaks.
   if (event == v8::Break) {
     break_point_hit_count++;
   } else if (event == v8::Exception) {
     exception_hit_count++;
 
     // Check whether the exception was uncaught.
-    v8::Local<v8::String> fun_name = v8::String::New("uncaught");
+    v8::Local<v8::String> fun_name =
+        v8::String::NewFromUtf8(CcTest::isolate(), "uncaught");
     v8::Local<v8::Function> fun =
         v8::Local<v8::Function>::Cast(event_data->Get(fun_name));
     v8::Local<v8::Value> result = fun->Call(event_data, 0, NULL);
     if (result->IsTrue()) {
       uncaught_exception_hit_count++;
     }
   }
 
   // Collect the JavsScript stack height if the function frame_count is
   // compiled.
@@ skipping 36 matching lines @@
     const v8::Debug::EventDetails& event_details) {
   v8::DebugEvent event = event_details.GetEvent();
   v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();
   v8::internal::Debug* debug = CcTest::i_isolate()->debug();
   // When hitting a debug event listener there must be a break set.
   CHECK_NE(debug->break_id(), 0);
 
   if (event == v8::Break) {
     for (int i = 0; checks[i].expr != NULL; i++) {
       const int argc = 3;
-      v8::Handle<v8::Value> argv[argc] = { exec_state,
-                                           v8::String::New(checks[i].expr),
-                                           checks[i].expected };
+      v8::Handle<v8::Value> argv[argc] = {
+          exec_state,
+          v8::String::NewFromUtf8(CcTest::isolate(), checks[i].expr),
+          checks[i].expected};
       v8::Handle<v8::Value> result =
           evaluate_check_function->Call(exec_state, argc, argv);
       if (!result->IsTrue()) {
         v8::String::Utf8Value utf8(checks[i].expected->ToString());
         V8_Fatal(__FILE__, __LINE__, "%s != %s", checks[i].expr, *utf8);
       }
     }
   }
 }
 
@@ skipping 308 matching lines @@
 }
 
 
 // Test that a break point can be set at an IC store location.
 TEST(BreakPointICStore) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
-  v8::Script::Compile(v8::String::New("function foo(){bar=0;}"))->Run();
-  v8::Local<v8::Function> foo =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                              "function foo(){bar=0;}"))->Run();
+  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
 
   // Run without breakpoints.
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test that a break point can be set at an IC load location.
 TEST(BreakPointICLoad) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
-  v8::Script::Compile(v8::String::New("bar=1"))->Run();
-  v8::Script::Compile(v8::String::New("function foo(){var x=bar;}"))->Run();
-  v8::Local<v8::Function> foo =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "bar=1"))
+      ->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(), "function foo(){var x=bar;}"))
+      ->Run();
+  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
 
   // Run without breakpoints.
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint.
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test that a break point can be set at an IC call location.
 TEST(BreakPointICCall) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
-  v8::Script::Compile(v8::String::New("function bar(){}"))->Run();
-  v8::Script::Compile(v8::String::New("function foo(){bar();}"))->Run();
-  v8::Local<v8::Function> foo =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(), "function bar(){}"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                              "function foo(){bar();}"))->Run();
+  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
 
   // Run without breakpoints.
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test that a break point can be set at an IC call location and survive a GC.
 TEST(BreakPointICCallWithGC) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointCollectGarbage);
-  v8::Script::Compile(v8::String::New("function bar(){return 1;}"))->Run();
-  v8::Script::Compile(v8::String::New("function foo(){return bar();}"))->Run();
-  v8::Local<v8::Function> foo =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(), "function bar(){return 1;}"))
+      ->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                              "function foo(){return bar();}"))
+      ->Run();
+  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
 
   // Run without breakpoints.
   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint.
   int bp = SetBreakPoint(foo, 0);
   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
   CHECK_EQ(1, break_point_hit_count);
   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test that a break point can be set at an IC call location and survive a GC.
 TEST(BreakPointConstructCallWithGC) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointCollectGarbage);
-  v8::Script::Compile(v8::String::New("function bar(){ this.x = 1;}"))->Run();
-  v8::Script::Compile(v8::String::New(
-      "function foo(){return new bar(1).x;}"))->Run();
-  v8::Local<v8::Function> foo =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                              "function bar(){ this.x = 1;}"))
+      ->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(),
+                              "function foo(){return new bar(1).x;}"))->Run();
+  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
 
   // Run without breakpoints.
   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint.
   int bp = SetBreakPoint(foo, 0);
   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
   CHECK_EQ(1, break_point_hit_count);
   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
@@ skipping 19 matching lines @@
   // a break point.
   frame_source_line = CompileFunction(&env,
                                       frame_source_line_source,
                                       "frame_source_line");
   frame_source_column = CompileFunction(&env,
                                         frame_source_column_source,
                                         "frame_source_column");
 
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
-  v8::Script::Compile(v8::String::New("function foo(){}"))->Run();
-  v8::Local<v8::Function> foo =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(), "function foo(){}"))->Run();
+  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
 
   // Run without breakpoints.
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   CHECK_EQ(0, last_source_line);
@@ skipping 146 matching lines @@
 
 
 // Test that break points can be set using the global Debug object.
 TEST(BreakPointThroughJavaScript) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
-  v8::Script::Compile(v8::String::New("function bar(){}"))->Run();
-  v8::Script::Compile(v8::String::New("function foo(){bar();bar();}"))->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(), "function bar(){}"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                              "function foo(){bar();bar();}"))
+      ->Run();
   //                                               012345678901234567890
   //                                                         1         2
   // Break points are set at position 3 and 9
-  v8::Local<v8::Script> foo = v8::Script::Compile(v8::String::New("foo()"));
+  v8::Local<v8::Script> foo =
+      v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "foo()"));
 
   // Run without breakpoints.
   foo->Run();
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with one breakpoint
-  int bp1 = SetBreakPointFromJS("foo", 0, 3);
+  int bp1 = SetBreakPointFromJS(env->GetIsolate(), "foo", 0, 3);
   foo->Run();
   CHECK_EQ(1, break_point_hit_count);
   foo->Run();
   CHECK_EQ(2, break_point_hit_count);
 
   // Run with two breakpoints
-  int bp2 = SetBreakPointFromJS("foo", 0, 9);
+  int bp2 = SetBreakPointFromJS(env->GetIsolate(), "foo", 0, 9);
   foo->Run();
   CHECK_EQ(4, break_point_hit_count);
   foo->Run();
   CHECK_EQ(6, break_point_hit_count);
 
   // Run with one breakpoint
-  ClearBreakPointFromJS(bp2);
+  ClearBreakPointFromJS(env->GetIsolate(), bp2);
   foo->Run();
   CHECK_EQ(7, break_point_hit_count);
   foo->Run();
   CHECK_EQ(8, break_point_hit_count);
 
   // Run without breakpoints.
-  ClearBreakPointFromJS(bp1);
+  ClearBreakPointFromJS(env->GetIsolate(), bp1);
   foo->Run();
   CHECK_EQ(8, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 
   // Make sure that the break point numbers are consecutive.
   CHECK_EQ(1, bp1);
   CHECK_EQ(2, bp2);
 }
 
 
 // Test that break points on scripts identified by name can be set using the
 // global Debug object.
 TEST(ScriptBreakPointByNameThroughJavaScript) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
-  v8::Local<v8::String> script = v8::String::New(
+  v8::Local<v8::String> script = v8::String::NewFromUtf8(
+    env->GetIsolate(),
     "function f() {\n"
     "  function h() {\n"
     "    a = 0;  // line 2\n"
     "  }\n"
     "  b = 1;  // line 4\n"
     "  return h();\n"
     "}\n"
     "\n"
     "function g() {\n"
     "  function h() {\n"
     "    a = 0;\n"
     "  }\n"
     "  b = 2;  // line 12\n"
     "  h();\n"
     "  b = 3;  // line 14\n"
     "  f();    // line 15\n"
     "}");
 
   // Compile the script and get the two functions.
   v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::New("test"));
+      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
   v8::Script::Compile(script, &origin)->Run();
-  v8::Local<v8::Function> f =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
-  v8::Local<v8::Function> g =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
+  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
+  v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
 
   // Call f and g without break points.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Call f and g with break point on line 12.
-  int sbp1 = SetScriptBreakPointByNameFromJS("test", 12, 0);
+  int sbp1 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 12, 0);
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   // Remove the break point again.
   break_point_hit_count = 0;
-  ClearBreakPointFromJS(sbp1);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Call f and g with break point on line 2.
-  int sbp2 = SetScriptBreakPointByNameFromJS("test", 2, 0);
+  int sbp2 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 2, 0);
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Call f and g with break point on line 2, 4, 12, 14 and 15.
-  int sbp3 = SetScriptBreakPointByNameFromJS("test", 4, 0);
-  int sbp4 = SetScriptBreakPointByNameFromJS("test", 12, 0);
-  int sbp5 = SetScriptBreakPointByNameFromJS("test", 14, 0);
-  int sbp6 = SetScriptBreakPointByNameFromJS("test", 15, 0);
+  int sbp3 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 4, 0);
+  int sbp4 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 12, 0);
+  int sbp5 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 14, 0);
+  int sbp6 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 15, 0);
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(7, break_point_hit_count);
 
   // Remove all the break points again.
   break_point_hit_count = 0;
-  ClearBreakPointFromJS(sbp2);
-  ClearBreakPointFromJS(sbp3);
-  ClearBreakPointFromJS(sbp4);
-  ClearBreakPointFromJS(sbp5);
-  ClearBreakPointFromJS(sbp6);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp3);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp4);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp5);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp6);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 
   // Make sure that the break point numbers are consecutive.
   CHECK_EQ(1, sbp1);
   CHECK_EQ(2, sbp2);
   CHECK_EQ(3, sbp3);
   CHECK_EQ(4, sbp4);
   CHECK_EQ(5, sbp5);
   CHECK_EQ(6, sbp6);
 }
 
 
 TEST(ScriptBreakPointByIdThroughJavaScript) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
-  v8::Local<v8::String> source = v8::String::New(
+  v8::Local<v8::String> source = v8::String::NewFromUtf8(
+    env->GetIsolate(),
     "function f() {\n"
     "  function h() {\n"
     "    a = 0;  // line 2\n"
     "  }\n"
     "  b = 1;  // line 4\n"
     "  return h();\n"
     "}\n"
     "\n"
     "function g() {\n"
     "  function h() {\n"
     "    a = 0;\n"
     "  }\n"
     "  b = 2;  // line 12\n"
     "  h();\n"
     "  b = 3;  // line 14\n"
     "  f();    // line 15\n"
     "}");
 
   // Compile the script and get the two functions.
   v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::New("test"));
+      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
   v8::Local<v8::Script> script = v8::Script::Compile(source, &origin);
   script->Run();
-  v8::Local<v8::Function> f =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
-  v8::Local<v8::Function> g =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
+  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
+  v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
 
   // Get the script id knowing that internally it is a 32 integer.
-  uint32_t script_id = script->Id()->Uint32Value();
+  int script_id = script->GetId();
 
   // Call f and g without break points.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Call f and g with break point on line 12.
-  int sbp1 = SetScriptBreakPointByIdFromJS(script_id, 12, 0);
+  int sbp1 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 12, 0);
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   // Remove the break point again.
   break_point_hit_count = 0;
-  ClearBreakPointFromJS(sbp1);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Call f and g with break point on line 2.
-  int sbp2 = SetScriptBreakPointByIdFromJS(script_id, 2, 0);
+  int sbp2 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 2, 0);
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Call f and g with break point on line 2, 4, 12, 14 and 15.
-  int sbp3 = SetScriptBreakPointByIdFromJS(script_id, 4, 0);
-  int sbp4 = SetScriptBreakPointByIdFromJS(script_id, 12, 0);
-  int sbp5 = SetScriptBreakPointByIdFromJS(script_id, 14, 0);
-  int sbp6 = SetScriptBreakPointByIdFromJS(script_id, 15, 0);
+  int sbp3 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 4, 0);
+  int sbp4 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 12, 0);
+  int sbp5 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 14, 0);
+  int sbp6 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 15, 0);
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(7, break_point_hit_count);
 
   // Remove all the break points again.
   break_point_hit_count = 0;
-  ClearBreakPointFromJS(sbp2);
-  ClearBreakPointFromJS(sbp3);
-  ClearBreakPointFromJS(sbp4);
-  ClearBreakPointFromJS(sbp5);
-  ClearBreakPointFromJS(sbp6);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp3);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp4);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp5);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp6);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 
   // Make sure that the break point numbers are consecutive.
   CHECK_EQ(1, sbp1);
   CHECK_EQ(2, sbp2);
   CHECK_EQ(3, sbp3);
   CHECK_EQ(4, sbp4);
   CHECK_EQ(5, sbp5);
   CHECK_EQ(6, sbp6);
 }
 
 
 // Test conditional script break points.
 TEST(EnableDisableScriptBreakPoint) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
-  v8::Local<v8::String> script = v8::String::New(
+  v8::Local<v8::String> script = v8::String::NewFromUtf8(
+    env->GetIsolate(),
     "function f() {\n"
     "  a = 0;  // line 1\n"
     "};");
 
   // Compile the script and get function f.
   v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::New("test"));
+      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
   v8::Script::Compile(script, &origin)->Run();
-  v8::Local<v8::Function> f =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   // Set script break point on line 1 (in function f).
-  int sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
+  int sbp = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 1, 0);
 
   // Call f while enabeling and disabling the script break point.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
-  DisableScriptBreakPointFromJS(sbp);
+  DisableScriptBreakPointFromJS(env->GetIsolate(), sbp);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
-  EnableScriptBreakPointFromJS(sbp);
+  EnableScriptBreakPointFromJS(env->GetIsolate(), sbp);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
-  DisableScriptBreakPointFromJS(sbp);
+  DisableScriptBreakPointFromJS(env->GetIsolate(), sbp);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Reload the script and get f again checking that the disabeling survives.
   v8::Script::Compile(script, &origin)->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
-  EnableScriptBreakPointFromJS(sbp);
+  EnableScriptBreakPointFromJS(env->GetIsolate(), sbp);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(3, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test conditional script break points.
 TEST(ConditionalScriptBreakPoint) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
-  v8::Local<v8::String> script = v8::String::New(
+  v8::Local<v8::String> script = v8::String::NewFromUtf8(
+    env->GetIsolate(),
     "count = 0;\n"
     "function f() {\n"
     "  g(count++);  // line 2\n"
     "};\n"
     "function g(x) {\n"
     "  var a=x;  // line 5\n"
     "};");
 
   // Compile the script and get function f.
   v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::New("test"));
+      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
   v8::Script::Compile(script, &origin)->Run();
-  v8::Local<v8::Function> f =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   // Set script break point on line 5 (in function g).
-  int sbp1 = SetScriptBreakPointByNameFromJS("test", 5, 0);
+  int sbp1 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 5, 0);
 
   // Call f with different conditions on the script break point.
   break_point_hit_count = 0;
-  ChangeScriptBreakPointConditionFromJS(sbp1, "false");
+  ChangeScriptBreakPointConditionFromJS(env->GetIsolate(), sbp1, "false");
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
-  ChangeScriptBreakPointConditionFromJS(sbp1, "true");
+  ChangeScriptBreakPointConditionFromJS(env->GetIsolate(), sbp1, "true");
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
-  ChangeScriptBreakPointConditionFromJS(sbp1, "x % 2 == 0");
+  ChangeScriptBreakPointConditionFromJS(env->GetIsolate(), sbp1, "x % 2 == 0");
   break_point_hit_count = 0;
   for (int i = 0; i < 10; i++) {
     f->Call(env->Global(), 0, NULL);
   }
   CHECK_EQ(5, break_point_hit_count);
 
   // Reload the script and get f again checking that the condition survives.
   v8::Script::Compile(script, &origin)->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   break_point_hit_count = 0;
   for (int i = 0; i < 10; i++) {
     f->Call(env->Global(), 0, NULL);
   }
   CHECK_EQ(5, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test ignore count on script break points.
 TEST(ScriptBreakPointIgnoreCount) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
-  v8::Local<v8::String> script = v8::String::New(
+  v8::Local<v8::String> script = v8::String::NewFromUtf8(
+    env->GetIsolate(),
     "function f() {\n"
     "  a = 0;  // line 1\n"
     "};");
 
   // Compile the script and get function f.
   v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::New("test"));
+      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
   v8::Script::Compile(script, &origin)->Run();
-  v8::Local<v8::Function> f =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   // Set script break point on line 1 (in function f).
-  int sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
+  int sbp = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 1, 0);
 
   // Call f with different ignores on the script break point.
   break_point_hit_count = 0;
-  ChangeScriptBreakPointIgnoreCountFromJS(sbp, 1);
+  ChangeScriptBreakPointIgnoreCountFromJS(env->GetIsolate(), sbp, 1);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
-  ChangeScriptBreakPointIgnoreCountFromJS(sbp, 5);
+  ChangeScriptBreakPointIgnoreCountFromJS(env->GetIsolate(), sbp, 5);
   break_point_hit_count = 0;
   for (int i = 0; i < 10; i++) {
     f->Call(env->Global(), 0, NULL);
   }
   CHECK_EQ(5, break_point_hit_count);
 
   // Reload the script and get f again checking that the ignore survives.
   v8::Script::Compile(script, &origin)->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   break_point_hit_count = 0;
   for (int i = 0; i < 10; i++) {
     f->Call(env->Global(), 0, NULL);
   }
   CHECK_EQ(5, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test that script break points survive when a script is reloaded.
 TEST(ScriptBreakPointReload) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
   v8::Local<v8::Function> f;
-  v8::Local<v8::String> script = v8::String::New(
+  v8::Local<v8::String> script = v8::String::NewFromUtf8(
+    env->GetIsolate(),
     "function f() {\n"
     "  function h() {\n"
     "    a = 0;  // line 2\n"
     "  }\n"
     "  b = 1;  // line 4\n"
     "  return h();\n"
     "}");
 
-  v8::ScriptOrigin origin_1 = v8::ScriptOrigin(v8::String::New("1"));
-  v8::ScriptOrigin origin_2 = v8::ScriptOrigin(v8::String::New("2"));
+  v8::ScriptOrigin origin_1 =
+      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "1"));
+  v8::ScriptOrigin origin_2 =
+      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "2"));
 
   // Set a script break point before the script is loaded.
-  SetScriptBreakPointByNameFromJS("1", 2, 0);
+  SetScriptBreakPointByNameFromJS(env->GetIsolate(), "1", 2, 0);
 
   // Compile the script and get the function.
   v8::Script::Compile(script, &origin_1)->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   // Call f and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   // Compile the script again with a different script data and get the
   // function.
   v8::Script::Compile(script, &origin_2)->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   // Call f and check that no break points are set.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Compile the script again and get the function.
   v8::Script::Compile(script, &origin_1)->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   // Call f and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test when several scripts has the same script data
 TEST(ScriptBreakPointMultiple) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
   v8::Local<v8::Function> f;
-  v8::Local<v8::String> script_f = v8::String::New(
-    "function f() {\n"
-    "  a = 0;  // line 1\n"
-    "}");
+  v8::Local<v8::String> script_f =
+      v8::String::NewFromUtf8(env->GetIsolate(),
+                              "function f() {\n"
+                              "  a = 0;  // line 1\n"
+                              "}");
 
   v8::Local<v8::Function> g;
-  v8::Local<v8::String> script_g = v8::String::New(
-    "function g() {\n"
-    "  b = 0;  // line 1\n"
-    "}");
+  v8::Local<v8::String> script_g =
+      v8::String::NewFromUtf8(env->GetIsolate(),
+                              "function g() {\n"
+                              "  b = 0;  // line 1\n"
+                              "}");
 
   v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::New("test"));
+      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
 
   // Set a script break point before the scripts are loaded.
-  int sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
+  int sbp = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 1, 0);
 
   // Compile the scripts with same script data and get the functions.
   v8::Script::Compile(script_f, &origin)->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
   v8::Script::Compile(script_g, &origin)->Run();
-  g = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
+  g = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
 
   // Call f and g and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Clear the script break point.
-  ClearBreakPointFromJS(sbp);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp);
 
   // Call f and g and check that the script break point is no longer active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Set script break point with the scripts loaded.
-  sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
+  sbp = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 1, 0);
 
   // Call f and g and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test the script origin which has both name and line offset.
 TEST(ScriptBreakPointLineOffset) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
   v8::Local<v8::Function> f;
-  v8::Local<v8::String> script = v8::String::New(
-    "function f() {\n"
-    "  a = 0;  // line 8 as this script has line offset 7\n"
-    "  b = 0;  // line 9 as this script has line offset 7\n"
-    "}");
+  v8::Local<v8::String> script = v8::String::NewFromUtf8(
+      env->GetIsolate(),
+      "function f() {\n"
+      "  a = 0;  // line 8 as this script has line offset 7\n"
+      "  b = 0;  // line 9 as this script has line offset 7\n"
+      "}");
 
   // Create script origin both name and line offset.
-  v8::ScriptOrigin origin(v8::String::New("test.html"),
-                          v8::Integer::New(7));
+  v8::ScriptOrigin origin(
+      v8::String::NewFromUtf8(env->GetIsolate(), "test.html"),
+      v8::Integer::New(7));
 
   // Set two script break points before the script is loaded.
-  int sbp1 = SetScriptBreakPointByNameFromJS("test.html", 8, 0);
-  int sbp2 = SetScriptBreakPointByNameFromJS("test.html", 9, 0);
+  int sbp1 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 8, 0);
+  int sbp2 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 9, 0);
 
   // Compile the script and get the function.
   v8::Script::Compile(script, &origin)->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   // Call f and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Clear the script break points.
-  ClearBreakPointFromJS(sbp1);
-  ClearBreakPointFromJS(sbp2);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
 
   // Call f and check that no script break points are active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Set a script break point with the script loaded.
-  sbp1 = SetScriptBreakPointByNameFromJS("test.html", 9, 0);
+  sbp1 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 9, 0);
 
   // Call f and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test script break points set on lines.
 TEST(ScriptBreakPointLine) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
                                         "frame_function_name");
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
   v8::Local<v8::Function> f;
   v8::Local<v8::Function> g;
-  v8::Local<v8::String> script = v8::String::New(
-    "a = 0                      // line 0\n"
-    "function f() {\n"
-    "  a = 1;                   // line 2\n"
-    "}\n"
-    " a = 2;                    // line 4\n"
-    "  /* xx */ function g() {  // line 5\n"
-    "    function h() {         // line 6\n"
-    "      a = 3;               // line 7\n"
-    "    }\n"
-    "    h();                   // line 9\n"
-    "    a = 4;                 // line 10\n"
-    "  }\n"
-    " a=5;                      // line 12");
+  v8::Local<v8::String> script =
+      v8::String::NewFromUtf8(env->GetIsolate(),
+                              "a = 0                      // line 0\n"
+                              "function f() {\n"
+                              "  a = 1;                   // line 2\n"
+                              "}\n"
+                              " a = 2;                    // line 4\n"
+                              "  /* xx */ function g() {  // line 5\n"
+                              "    function h() {         // line 6\n"
+                              "      a = 3;               // line 7\n"
+                              "    }\n"
+                              "    h();                   // line 9\n"
+                              "    a = 4;                 // line 10\n"
+                              "  }\n"
+                              " a=5;                      // line 12");
 
   // Set a couple script break point before the script is loaded.
-  int sbp1 = SetScriptBreakPointByNameFromJS("test.html", 0, -1);
-  int sbp2 = SetScriptBreakPointByNameFromJS("test.html", 1, -1);
-  int sbp3 = SetScriptBreakPointByNameFromJS("test.html", 5, -1);
+  int sbp1 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 0, -1);
+  int sbp2 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 1, -1);
+  int sbp3 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 5, -1);
 
   // Compile the script and get the function.
   break_point_hit_count = 0;
-  v8::ScriptOrigin origin(v8::String::New("test.html"), v8::Integer::New(0));
+  v8::ScriptOrigin origin(
+      v8::String::NewFromUtf8(env->GetIsolate(), "test.html"),
+      v8::Integer::New(0));
   v8::Script::Compile(script, &origin)->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
-  g = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
+  g = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
 
   // Check that a break point was hit when the script was run.
   CHECK_EQ(1, break_point_hit_count);
   CHECK_EQ(0, StrLength(last_function_hit));
 
   // Call f and check that the script break point.
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
   CHECK_EQ("f", last_function_hit);
 
   // Call g and check that the script break point.
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(3, break_point_hit_count);
   CHECK_EQ("g", last_function_hit);
 
   // Clear the script break point on g and set one on h.
-  ClearBreakPointFromJS(sbp3);
-  int sbp4 = SetScriptBreakPointByNameFromJS("test.html", 6, -1);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp3);
+  int sbp4 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 6, -1);
 
   // Call g and check that the script break point in h is hit.
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(4, break_point_hit_count);
   CHECK_EQ("h", last_function_hit);
 
   // Clear break points in f and h. Set a new one in the script between
   // functions f and g and test that there is no break points in f and g any
   // more.
-  ClearBreakPointFromJS(sbp2);
-  ClearBreakPointFromJS(sbp4);
-  int sbp5 = SetScriptBreakPointByNameFromJS("test.html", 4, -1);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp4);
+  int sbp5 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 4, -1);
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Reload the script which should hit two break points.
   break_point_hit_count = 0;
   v8::Script::Compile(script, &origin)->Run();
   CHECK_EQ(2, break_point_hit_count);
   CHECK_EQ(0, StrLength(last_function_hit));
 
   // Set a break point in the code after the last function decleration.
-  int sbp6 = SetScriptBreakPointByNameFromJS("test.html", 12, -1);
+  int sbp6 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 12, -1);
 
   // Reload the script which should hit three break points.
   break_point_hit_count = 0;
   v8::Script::Compile(script, &origin)->Run();
   CHECK_EQ(3, break_point_hit_count);
   CHECK_EQ(0, StrLength(last_function_hit));
 
   // Clear the last break points, and reload the script which should not hit any
   // break points.
-  ClearBreakPointFromJS(sbp1);
-  ClearBreakPointFromJS(sbp5);
-  ClearBreakPointFromJS(sbp6);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp5);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp6);
   break_point_hit_count = 0;
   v8::Script::Compile(script, &origin)->Run();
   CHECK_EQ(0, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test top level script break points set on lines.
 TEST(ScriptBreakPointLineTopLevel) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
-  v8::Local<v8::String> script = v8::String::New(
-    "function f() {\n"
-    "  a = 1;                   // line 1\n"
-    "}\n"
-    "a = 2;                     // line 3\n");
+  v8::Local<v8::String> script =
+      v8::String::NewFromUtf8(env->GetIsolate(),
+                              "function f() {\n"
+                              "  a = 1;                   // line 1\n"
+                              "}\n"
+                              "a = 2;                     // line 3\n");
   v8::Local<v8::Function> f;
   {
     v8::HandleScope scope(env->GetIsolate());
-    v8::Script::Compile(script, v8::String::New("test.html"))->Run();
+    v8::Script::Compile(
+        script, v8::String::NewFromUtf8(env->GetIsolate(), "test.html"))->Run();
   }
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);
 
-  SetScriptBreakPointByNameFromJS("test.html", 3, -1);
+  SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 3, -1);
 
   // Call f and check that there was no break points.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Recompile and run script and check that break point was hit.
   break_point_hit_count = 0;
-  v8::Script::Compile(script, v8::String::New("test.html"))->Run();
+  v8::Script::Compile(
+      script, v8::String::NewFromUtf8(env->GetIsolate(), "test.html"))->Run();
   CHECK_EQ(1, break_point_hit_count);
 
   // Call f and check that there are still no break points.
   break_point_hit_count = 0;
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
   CHECK_EQ(0, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test that it is possible to add and remove break points in a top level
 // function which has no references but has not been collected yet.
 TEST(ScriptBreakPointTopLevelCrash) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
-  v8::Local<v8::String> script_source = v8::String::New(
-    "function f() {\n"
-    "  return 0;\n"
-    "}\n"
-    "f()");
+  v8::Local<v8::String> script_source =
+      v8::String::NewFromUtf8(env->GetIsolate(),
+                              "function f() {\n"
+                              "  return 0;\n"
+                              "}\n"
+                              "f()");
 
-  int sbp1 = SetScriptBreakPointByNameFromJS("test.html", 3, -1);
+  int sbp1 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 3, -1);
   {
     v8::HandleScope scope(env->GetIsolate());
     break_point_hit_count = 0;
-    v8::Script::Compile(script_source, v8::String::New("test.html"))->Run();
+    v8::Script::Compile(script_source,
+                        v8::String::NewFromUtf8(env->GetIsolate(), "test.html"))
+        ->Run();
     CHECK_EQ(1, break_point_hit_count);
   }
 
-  int sbp2 = SetScriptBreakPointByNameFromJS("test.html", 3, -1);
-  ClearBreakPointFromJS(sbp1);
-  ClearBreakPointFromJS(sbp2);
+  int sbp2 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 3, -1);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test that it is possible to remove the last break point for a function
 // inside the break handling of that break point.
 TEST(RemoveBreakPointInBreak) {
   DebugLocalContext env;
@@ skipping 18 matching lines @@
   CheckDebuggerUnloaded();
 }
 
 
 // Test that the debugger statement causes a break.
 TEST(DebuggerStatement) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
-  v8::Script::Compile(v8::String::New("function bar(){debugger}"))->Run();
-  v8::Script::Compile(v8::String::New(
-      "function foo(){debugger;debugger;}"))->Run();
-  v8::Local<v8::Function> foo =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
-  v8::Local<v8::Function> bar =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("bar")));
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(), "function bar(){debugger}"))
+      ->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(),
+                              "function foo(){debugger;debugger;}"))->Run();
+  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
+  v8::Local<v8::Function> bar = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "bar")));
 
   // Run function with debugger statement
   bar->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   // Run function with two debugger statement
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(3, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 // Test setting a breakpoint on the debugger statement.
 TEST(DebuggerStatementBreakpoint) {
     break_point_hit_count = 0;
     DebugLocalContext env;
     v8::HandleScope scope(env->GetIsolate());
     v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
-    v8::Script::Compile(v8::String::New("function foo(){debugger;}"))->Run();
-    v8::Local<v8::Function> foo =
-    v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
+    v8::Script::Compile(
+        v8::String::NewFromUtf8(env->GetIsolate(), "function foo(){debugger;}"))
+        ->Run();
+    v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
+        env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
 
     // The debugger statement triggers breakpint hit
     foo->Call(env->Global(), 0, NULL);
     CHECK_EQ(1, break_point_hit_count);
 
     int bp = SetBreakPoint(foo, 0);
 
     // Set breakpoint does not duplicate hits
     foo->Call(env->Global(), 0, NULL);
     CHECK_EQ(2, break_point_hit_count);
@@ skipping 20 matching lines @@
   v8::Debug::SetDebugEventListener2(DebugEventEvaluate);
 
   // Different expected vaules of x and a when in a break point (u = undefined,
   // d = Hello, world!).
   struct EvaluateCheck checks_uu[] = {
     {"x", v8::Undefined(isolate)},
     {"a", v8::Undefined(isolate)},
     {NULL, v8::Handle<v8::Value>()}
   };
   struct EvaluateCheck checks_hu[] = {
-    {"x", v8::String::New("Hello, world!")},
+    {"x", v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!")},
     {"a", v8::Undefined(isolate)},
     {NULL, v8::Handle<v8::Value>()}
   };
   struct EvaluateCheck checks_hh[] = {
-    {"x", v8::String::New("Hello, world!")},
-    {"a", v8::String::New("Hello, world!")},
+    {"x", v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!")},
+    {"a", v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!")},
     {NULL, v8::Handle<v8::Value>()}
   };
 
   // Simple test function. The "y=0" is in the function foo to provide a break
   // location. For "y=0" the "y" is at position 15 in the barbar function
   // therefore setting breakpoint at position 15 will break at "y=0" and
   // setting it higher will break after.
   v8::Local<v8::Function> foo = CompileFunction(&env,
     "function foo(x) {"
     "  var a;"
     "  y=0;"  // To ensure break location 1.
     "  a=x;"
     "  y=0;"  // To ensure break location 2.
     "}",
     "foo");
   const int foo_break_position_1 = 15;
   const int foo_break_position_2 = 29;
 
   // Arguments with one parameter "Hello, world!"
-  v8::Handle<v8::Value> argv_foo[1] = { v8::String::New("Hello, world!") };
+  v8::Handle<v8::Value> argv_foo[1] = {
+      v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!")};
 
   // Call foo with breakpoint set before a=x and undefined as parameter.
   int bp = SetBreakPoint(foo, foo_break_position_1);
   checks = checks_uu;
   foo->Call(env->Global(), 0, NULL);
 
   // Call foo with breakpoint set before a=x and parameter "Hello, world!".
   checks = checks_hu;
   foo->Call(env->Global(), 1, argv_foo);
 
@@ skipping 29 matching lines @@
   v8::Handle<v8::Value> argv_bar_1[2] = {
     v8::Undefined(isolate),
     v8::Number::New(barbar_break_position)
   };
   bar->Call(env->Global(), 2, argv_bar_1);
 
   // Call bar setting breakpoint before a=x in barbar and parameter
   // "Hello, world!".
   checks = checks_hu;
   v8::Handle<v8::Value> argv_bar_2[2] = {
-    v8::String::New("Hello, world!"),
+    v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!"),
     v8::Number::New(barbar_break_position)
   };
   bar->Call(env->Global(), 2, argv_bar_2);
 
   // Call bar setting breakpoint after a=x in barbar and parameter
   // "Hello, world!".
   checks = checks_hh;
   v8::Handle<v8::Value> argv_bar_3[2] = {
-    v8::String::New("Hello, world!"),
+    v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!"),
     v8::Number::New(barbar_break_position + 1)
   };
   bar->Call(env->Global(), 2, argv_bar_3);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 int debugEventCount = 0;
@@ skipping 167 matching lines @@
   void next() {
     counter++;
   }
 };
 
 DebugProcessDebugMessagesData process_debug_messages_data;
 
 static void DebugProcessDebugMessagesHandler(
     const v8::Debug::Message& message) {
   v8::Handle<v8::String> json = message.GetJSON();
-  v8::String::AsciiValue ascii(json);
+  v8::String::Utf8Value utf8(json);
   EvaluateResult* array_item = process_debug_messages_data.current();
 
-  bool res = GetEvaluateStringResult(*ascii,
+  bool res = GetEvaluateStringResult(*utf8,
                                      array_item->buffer,
                                      EvaluateResult::kBufferSize);
   if (res) {
     process_debug_messages_data.next();
   }
 }
 
 
 // Test that the evaluation of expressions works even from ProcessDebugMessages
 // i.e. with empty stack.
 TEST(DebugEvaluateWithoutStack) {
   v8::Debug::SetMessageHandler2(DebugProcessDebugMessagesHandler);
 
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   const char* source =
       "var v1 = 'Pinguin';\n function getAnimal() { return 'Capy' + 'bara'; }";
 
-  v8::Script::Compile(v8::String::New(source))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), source))
+      ->Run();
 
   v8::Debug::ProcessDebugMessages();
 
   const int kBufferSize = 1000;
   uint16_t buffer[kBufferSize];
 
   const char* command_111 = "{\"seq\":111,"
       "\"type\":\"request\","
       "\"command\":\"evaluate\","
       "\"arguments\":{"
@@ skipping 755 matching lines @@
   v8::Debug::SetDebugEventListener2(DebugEventStep);
 
   // Create a function for testing stepping. Run it to allow it to get
   // optimized.
   const char* src = "function foo(x) { "
                     "  var a = {};"
                     "  with (a) {}"
                     "  with (b) {}"
                     "}"
                     "foo()";
-  env->Global()->Set(v8::String::New("b"), v8::Object::New());
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "b"),
+                     v8::Object::New());
   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
   v8::Handle<v8::Value> result;
   SetBreakPoint(foo, 8);  // "var a = {};"
 
   step_action = StepIn;
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(4, break_point_hit_count);
 
   // Get rid of the debug event listener.
@@ skipping 313 matching lines @@
   env.ExposeDebug();
 
   // Register a debug event listener which counts.
   v8::Debug::SetDebugEventListener2(DebugEventCounter);
 
   // Create a script that returns a function.
   const char* src = "(function (evt) {})";
   const char* script_name = "StepInHandlerTest";
 
   // Set breakpoint in the script.
-  SetScriptBreakPointByNameFromJS(script_name, 0, -1);
+  SetScriptBreakPointByNameFromJS(env->GetIsolate(), script_name, 0, -1);
   break_point_hit_count = 0;
 
-  v8::ScriptOrigin origin(v8::String::New(script_name), v8::Integer::New(0));
-  v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(src),
-                                                      &origin);
+  v8::ScriptOrigin origin(
+      v8::String::NewFromUtf8(env->GetIsolate(), script_name),
+      v8::Integer::New(0));
+  v8::Handle<v8::Script> script = v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(), src), &origin);
   v8::Local<v8::Value> r = script->Run();
 
   CHECK(r->IsFunction());
   CHECK_EQ(1, break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
@@ skipping 83 matching lines @@
   CHECK_EQ(0, uncaught_exception_hit_count);
   CHECK_EQ(0, message_callback_count);
   notCaught->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, exception_hit_count);
   CHECK_EQ(1, uncaught_exception_hit_count);
   CHECK_EQ(1, message_callback_count);
 
   // No break on exception using JavaScript
   DebugEventCounterClear();
   MessageCallbackCountClear();
-  ChangeBreakOnExceptionFromJS(false, false);
+  ChangeBreakOnExceptionFromJS(env->GetIsolate(), false, false);
   caught->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, exception_hit_count);
   CHECK_EQ(0, uncaught_exception_hit_count);
   CHECK_EQ(0, message_callback_count);
   notCaught->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, exception_hit_count);
   CHECK_EQ(0, uncaught_exception_hit_count);
   CHECK_EQ(1, message_callback_count);
 
   // Break on uncaught exception using JavaScript
   DebugEventCounterClear();
   MessageCallbackCountClear();
-  ChangeBreakOnExceptionFromJS(false, true);
+  ChangeBreakOnExceptionFromJS(env->GetIsolate(), false, true);
   caught->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, exception_hit_count);
   CHECK_EQ(0, uncaught_exception_hit_count);
   CHECK_EQ(0, message_callback_count);
   notCaught->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, exception_hit_count);
   CHECK_EQ(1, uncaught_exception_hit_count);
   CHECK_EQ(1, message_callback_count);
 
   // Break on exception and uncaught exception using JavaScript
   DebugEventCounterClear();
   MessageCallbackCountClear();
-  ChangeBreakOnExceptionFromJS(true, true);
+  ChangeBreakOnExceptionFromJS(env->GetIsolate(), true, true);
   caught->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, exception_hit_count);
   CHECK_EQ(0, message_callback_count);
   CHECK_EQ(0, uncaught_exception_hit_count);
   notCaught->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, exception_hit_count);
   CHECK_EQ(1, uncaught_exception_hit_count);
   CHECK_EQ(1, message_callback_count);
 
   // Break on exception using JavaScript
   DebugEventCounterClear();
   MessageCallbackCountClear();
-  ChangeBreakOnExceptionFromJS(true, false);
+  ChangeBreakOnExceptionFromJS(env->GetIsolate(), true, false);
   caught->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, exception_hit_count);
   CHECK_EQ(0, uncaught_exception_hit_count);
   CHECK_EQ(0, message_callback_count);
   notCaught->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, exception_hit_count);
   CHECK_EQ(1, uncaught_exception_hit_count);
   CHECK_EQ(1, message_callback_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
@@ skipping 23 matching lines @@
   DebugEventCounterClear();
   MessageCallbackCountClear();
 
   // Check initial state.
   CHECK_EQ(0, exception_hit_count);
   CHECK_EQ(0, uncaught_exception_hit_count);
   CHECK_EQ(0, message_callback_count);
   CHECK_EQ(-1, last_js_stack_height);
 
   // Throws SyntaxError: Unexpected end of input
-  v8::Script::Compile(v8::String::New("+++"));
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "+++"));
   CHECK_EQ(1, exception_hit_count);
   CHECK_EQ(1, uncaught_exception_hit_count);
   CHECK_EQ(1, message_callback_count);
   CHECK_EQ(0, last_js_stack_height);  // No JavaScript stack.
 
   // Throws SyntaxError: Unexpected identifier
-  v8::Script::Compile(v8::String::New("x x"));
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "x x"));
   CHECK_EQ(2, exception_hit_count);
   CHECK_EQ(2, uncaught_exception_hit_count);
   CHECK_EQ(2, message_callback_count);
   CHECK_EQ(0, last_js_stack_height);  // No JavaScript stack.
 
   // Throws SyntaxError: Unexpected end of input
-  v8::Script::Compile(v8::String::New("eval('+++')"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "eval('+++')"))
+      ->Run();
   CHECK_EQ(3, exception_hit_count);
   CHECK_EQ(3, uncaught_exception_hit_count);
   CHECK_EQ(3, message_callback_count);
   CHECK_EQ(1, last_js_stack_height);
 
   // Throws SyntaxError: Unexpected identifier
-  v8::Script::Compile(v8::String::New("eval('x x')"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "eval('x x')"))
+      ->Run();
   CHECK_EQ(4, exception_hit_count);
   CHECK_EQ(4, uncaught_exception_hit_count);
   CHECK_EQ(4, message_callback_count);
   CHECK_EQ(1, last_js_stack_height);
 }
 
 
 TEST(StepWithException) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
@@ skipping 206 matching lines @@
   CHECK_EQ(0, break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 static void NamedEnum(const v8::PropertyCallbackInfo<v8::Array>& info) {
   v8::Handle<v8::Array> result = v8::Array::New(3);
-  result->Set(v8::Integer::New(0), v8::String::New("a"));
-  result->Set(v8::Integer::New(1), v8::String::New("b"));
-  result->Set(v8::Integer::New(2), v8::String::New("c"));
+  result->Set(v8::Integer::New(0),
+              v8::String::NewFromUtf8(info.GetIsolate(), "a"));
+  result->Set(v8::Integer::New(1),
+              v8::String::NewFromUtf8(info.GetIsolate(), "b"));
+  result->Set(v8::Integer::New(2),
+              v8::String::NewFromUtf8(info.GetIsolate(), "c"));
   info.GetReturnValue().Set(result);
 }
 
 
 static void IndexedEnum(const v8::PropertyCallbackInfo<v8::Array>& info) {
   v8::Handle<v8::Array> result = v8::Array::New(2);
   result->Set(v8::Integer::New(0), v8::Number::New(1));
   result->Set(v8::Integer::New(1), v8::Number::New(10));
   info.GetReturnValue().Set(result);
 }
 
 
 static void NamedGetter(v8::Local<v8::String> name,
                         const v8::PropertyCallbackInfo<v8::Value>& info) {
   v8::String::Utf8Value n(name);
   if (strcmp(*n, "a") == 0) {
-    info.GetReturnValue().Set(v8::String::New("AA"));
+    info.GetReturnValue().Set(v8::String::NewFromUtf8(info.GetIsolate(), "AA"));
     return;
   } else if (strcmp(*n, "b") == 0) {
-    info.GetReturnValue().Set(v8::String::New("BB"));
+    info.GetReturnValue().Set(v8::String::NewFromUtf8(info.GetIsolate(), "BB"));
     return;
   } else if (strcmp(*n, "c") == 0) {
-    info.GetReturnValue().Set(v8::String::New("CC"));
+    info.GetReturnValue().Set(v8::String::NewFromUtf8(info.GetIsolate(), "CC"));
     return;
   } else {
     info.GetReturnValue().SetUndefined();
     return;
   }
   info.GetReturnValue().Set(name);
 }
 
 
 static void IndexedGetter(uint32_t index,
                           const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(static_cast<double>(index + 1));
 }
 
 
 TEST(InterceptorPropertyMirror) {
   // Create a V8 environment with debug access.
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   // Create object with named interceptor.
   v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
   named->SetNamedPropertyHandler(NamedGetter, NULL, NULL, NULL, NamedEnum);
-  env->Global()->Set(v8::String::New("intercepted_named"),
-                     named->NewInstance());
+  env->Global()->Set(
+      v8::String::NewFromUtf8(env->GetIsolate(), "intercepted_named"),
+      named->NewInstance());
 
   // Create object with indexed interceptor.
   v8::Handle<v8::ObjectTemplate> indexed = v8::ObjectTemplate::New();
   indexed->SetIndexedPropertyHandler(IndexedGetter,
                                      NULL,
                                      NULL,
                                      NULL,
                                      IndexedEnum);
-  env->Global()->Set(v8::String::New("intercepted_indexed"),
-                     indexed->NewInstance());
+  env->Global()->Set(
+      v8::String::NewFromUtf8(env->GetIsolate(), "intercepted_indexed"),
+      indexed->NewInstance());
 
   // Create object with both named and indexed interceptor.
   v8::Handle<v8::ObjectTemplate> both = v8::ObjectTemplate::New();
   both->SetNamedPropertyHandler(NamedGetter, NULL, NULL, NULL, NamedEnum);
   both->SetIndexedPropertyHandler(IndexedGetter, NULL, NULL, NULL, IndexedEnum);
-  env->Global()->Set(v8::String::New("intercepted_both"), both->NewInstance());
+  env->Global()->Set(
+      v8::String::NewFromUtf8(env->GetIsolate(), "intercepted_both"),
+      both->NewInstance());
 
   // Get mirrors for the three objects with interceptor.
   CompileRun(
       "var named_mirror = debug.MakeMirror(intercepted_named);"
       "var indexed_mirror = debug.MakeMirror(intercepted_indexed);"
       "var both_mirror = debug.MakeMirror(intercepted_both)");
   CHECK(CompileRun(
        "named_mirror instanceof debug.ObjectMirror")->BooleanValue());
   CHECK(CompileRun(
         "indexed_mirror instanceof debug.ObjectMirror")->BooleanValue());
@@ skipping 91 matching lines @@
 }
 
 
 TEST(HiddenPrototypePropertyMirror) {
   // Create a V8 environment with debug access.
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Handle<v8::FunctionTemplate> t0 = v8::FunctionTemplate::New();
-  t0->InstanceTemplate()->Set(v8::String::New("x"), v8::Number::New(0));
+  t0->InstanceTemplate()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "x"),
+                              v8::Number::New(0));
   v8::Handle<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New();
   t1->SetHiddenPrototype(true);
-  t1->InstanceTemplate()->Set(v8::String::New("y"), v8::Number::New(1));
+  t1->InstanceTemplate()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "y"),
+                              v8::Number::New(1));
   v8::Handle<v8::FunctionTemplate> t2 = v8::FunctionTemplate::New();
   t2->SetHiddenPrototype(true);
-  t2->InstanceTemplate()->Set(v8::String::New("z"), v8::Number::New(2));
+  t2->InstanceTemplate()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "z"),
+                              v8::Number::New(2));
   v8::Handle<v8::FunctionTemplate> t3 = v8::FunctionTemplate::New();
-  t3->InstanceTemplate()->Set(v8::String::New("u"), v8::Number::New(3));
+  t3->InstanceTemplate()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "u"),
+                              v8::Number::New(3));
 
   // Create object and set them on the global object.
   v8::Handle<v8::Object> o0 = t0->GetFunction()->NewInstance();
-  env->Global()->Set(v8::String::New("o0"), o0);
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "o0"), o0);
   v8::Handle<v8::Object> o1 = t1->GetFunction()->NewInstance();
-  env->Global()->Set(v8::String::New("o1"), o1);
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "o1"), o1);
   v8::Handle<v8::Object> o2 = t2->GetFunction()->NewInstance();
-  env->Global()->Set(v8::String::New("o2"), o2);
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "o2"), o2);
   v8::Handle<v8::Object> o3 = t3->GetFunction()->NewInstance();
-  env->Global()->Set(v8::String::New("o3"), o3);
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "o3"), o3);
 
   // Get mirrors for the four objects.
   CompileRun(
       "var o0_mirror = debug.MakeMirror(o0);"
       "var o1_mirror = debug.MakeMirror(o1);"
       "var o2_mirror = debug.MakeMirror(o2);"
       "var o3_mirror = debug.MakeMirror(o3)");
   CHECK(CompileRun("o0_mirror instanceof debug.ObjectMirror")->BooleanValue());
   CHECK(CompileRun("o1_mirror instanceof debug.ObjectMirror")->BooleanValue());
   CHECK(CompileRun("o2_mirror instanceof debug.ObjectMirror")->BooleanValue());
   CHECK(CompileRun("o3_mirror instanceof debug.ObjectMirror")->BooleanValue());
 
   // Check that each object has one property.
   CHECK_EQ(1, CompileRun(
               "o0_mirror.propertyNames().length")->Int32Value());
   CHECK_EQ(1, CompileRun(
               "o1_mirror.propertyNames().length")->Int32Value());
   CHECK_EQ(1, CompileRun(
               "o2_mirror.propertyNames().length")->Int32Value());
   CHECK_EQ(1, CompileRun(
               "o3_mirror.propertyNames().length")->Int32Value());
 
   // Set o1 as prototype for o0. o1 has the hidden prototype flag so all
   // properties on o1 should be seen on o0.
-  o0->Set(v8::String::New("__proto__"), o1);
+  o0->Set(v8::String::NewFromUtf8(env->GetIsolate(), "__proto__"), o1);
   CHECK_EQ(2, CompileRun(
               "o0_mirror.propertyNames().length")->Int32Value());
   CHECK_EQ(0, CompileRun(
               "o0_mirror.property('x').value().value()")->Int32Value());
   CHECK_EQ(1, CompileRun(
               "o0_mirror.property('y').value().value()")->Int32Value());
 
   // Set o2 as prototype for o0 (it will end up after o1 as o1 has the hidden
   // prototype flag. o2 also has the hidden prototype flag so all properties
   // on o2 should be seen on o0 as well as properties on o1.
-  o0->Set(v8::String::New("__proto__"), o2);
+  o0->Set(v8::String::NewFromUtf8(env->GetIsolate(), "__proto__"), o2);
   CHECK_EQ(3, CompileRun(
               "o0_mirror.propertyNames().length")->Int32Value());
   CHECK_EQ(0, CompileRun(
               "o0_mirror.property('x').value().value()")->Int32Value());
   CHECK_EQ(1, CompileRun(
               "o0_mirror.property('y').value().value()")->Int32Value());
   CHECK_EQ(2, CompileRun(
               "o0_mirror.property('z').value().value()")->Int32Value());
 
   // Set o3 as prototype for o0 (it will end up after o1 and o2 as both o1 and
   // o2 has the hidden prototype flag. o3 does not have the hidden prototype
   // flag so properties on o3 should not be seen on o0 whereas the properties
   // from o1 and o2 should still be seen on o0.
   // Final prototype chain: o0 -> o1 -> o2 -> o3
   // Hidden prototypes:           ^^    ^^
-  o0->Set(v8::String::New("__proto__"), o3);
+  o0->Set(v8::String::NewFromUtf8(env->GetIsolate(), "__proto__"), o3);
   CHECK_EQ(3, CompileRun(
               "o0_mirror.propertyNames().length")->Int32Value());
   CHECK_EQ(1, CompileRun(
               "o3_mirror.propertyNames().length")->Int32Value());
   CHECK_EQ(0, CompileRun(
               "o0_mirror.property('x').value().value()")->Int32Value());
   CHECK_EQ(1, CompileRun(
               "o0_mirror.property('y').value().value()")->Int32Value());
   CHECK_EQ(2, CompileRun(
               "o0_mirror.property('z').value().value()")->Int32Value());
@@ skipping 10 matching lines @@
   info.GetReturnValue().Set(10);
 }
 
 
 TEST(NativeGetterPropertyMirror) {
   // Create a V8 environment with debug access.
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
-  v8::Handle<v8::String> name = v8::String::New("x");
+  v8::Handle<v8::String> name = v8::String::NewFromUtf8(env->GetIsolate(), "x");
   // Create object with named accessor.
   v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
   named->SetAccessor(name, &ProtperyXNativeGetter, NULL,
       v8::Handle<v8::Value>(), v8::DEFAULT, v8::None);
 
   // Create object with named property getter.
-  env->Global()->Set(v8::String::New("instance"), named->NewInstance());
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "instance"),
+                     named->NewInstance());
   CHECK_EQ(10, CompileRun("instance.x")->Int32Value());
 
   // Get mirror for the object with property getter.
   CompileRun("var instance_mirror = debug.MakeMirror(instance);");
   CHECK(CompileRun(
       "instance_mirror instanceof debug.ObjectMirror")->BooleanValue());
 
   CompileRun("var named_names = instance_mirror.propertyNames();");
   CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
   CHECK(CompileRun("named_names[0] == 'x'")->BooleanValue());
@@ skipping 10 matching lines @@
   CompileRun("throw new Error('Error message');");
 }
 
 
 TEST(NativeGetterThrowingErrorPropertyMirror) {
   // Create a V8 environment with debug access.
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
-  v8::Handle<v8::String> name = v8::String::New("x");
+  v8::Handle<v8::String> name = v8::String::NewFromUtf8(env->GetIsolate(), "x");
   // Create object with named accessor.
   v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
   named->SetAccessor(name, &ProtperyXNativeGetterThrowingError, NULL,
       v8::Handle<v8::Value>(), v8::DEFAULT, v8::None);
 
   // Create object with named property getter.
-  env->Global()->Set(v8::String::New("instance"), named->NewInstance());
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "instance"),
+                     named->NewInstance());
 
   // Get mirror for the object with property getter.
   CompileRun("var instance_mirror = debug.MakeMirror(instance);");
   CHECK(CompileRun(
       "instance_mirror instanceof debug.ObjectMirror")->BooleanValue());
   CompileRun("named_names = instance_mirror.propertyNames();");
   CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
   CHECK(CompileRun("named_names[0] == 'x'")->BooleanValue());
   CHECK(CompileRun(
       "instance_mirror.property('x').value().isError()")->BooleanValue());
 
   // Check that the message is that passed to the Error constructor.
   CHECK(CompileRun(
       "instance_mirror.property('x').value().message() == 'Error message'")->
           BooleanValue());
 }
 
 
 // Test that hidden properties object is not returned as an unnamed property
 // among regular properties.
 // See http://crbug.com/26491
 TEST(NoHiddenProperties) {
   // Create a V8 environment with debug access.
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   // Create an object in the global scope.
   const char* source = "var obj = {a: 1};";
-  v8::Script::Compile(v8::String::New(source))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), source))
+      ->Run();
   v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(
-      env->Global()->Get(v8::String::New("obj")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "obj")));
   // Set a hidden property on the object.
-  obj->SetHiddenValue(v8::String::New("v8::test-debug::a"),
-                      v8::Int32::New(11));
+  obj->SetHiddenValue(
+      v8::String::NewFromUtf8(env->GetIsolate(), "v8::test-debug::a"),
+      v8::Int32::New(11));
 
   // Get mirror for the object with property getter.
   CompileRun("var obj_mirror = debug.MakeMirror(obj);");
   CHECK(CompileRun(
       "obj_mirror instanceof debug.ObjectMirror")->BooleanValue());
   CompileRun("var named_names = obj_mirror.propertyNames();");
   // There should be exactly one property. But there is also an unnamed
   // property whose value is hidden properties dictionary. The latter
   // property should not be in the list of reguar properties.
   CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
   CHECK(CompileRun("named_names[0] == 'a'")->BooleanValue());
   CHECK(CompileRun(
       "obj_mirror.property('a').value().value() == 1")->BooleanValue());
 
   // Object created by t0 will become hidden prototype of object 'obj'.
   v8::Handle<v8::FunctionTemplate> t0 = v8::FunctionTemplate::New();
-  t0->InstanceTemplate()->Set(v8::String::New("b"), v8::Number::New(2));
+  t0->InstanceTemplate()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "b"),
+                              v8::Number::New(2));
   t0->SetHiddenPrototype(true);
   v8::Handle<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New();
-  t1->InstanceTemplate()->Set(v8::String::New("c"), v8::Number::New(3));
+  t1->InstanceTemplate()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "c"),
+                              v8::Number::New(3));
 
   // Create proto objects, add hidden properties to them and set them on
   // the global object.
   v8::Handle<v8::Object> protoObj = t0->GetFunction()->NewInstance();
-  protoObj->SetHiddenValue(v8::String::New("v8::test-debug::b"),
-                           v8::Int32::New(12));
-  env->Global()->Set(v8::String::New("protoObj"), protoObj);
+  protoObj->SetHiddenValue(
+      v8::String::NewFromUtf8(env->GetIsolate(), "v8::test-debug::b"),
+      v8::Int32::New(12));
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "protoObj"),
+                     protoObj);
   v8::Handle<v8::Object> grandProtoObj = t1->GetFunction()->NewInstance();
-  grandProtoObj->SetHiddenValue(v8::String::New("v8::test-debug::c"),
-                                v8::Int32::New(13));
-  env->Global()->Set(v8::String::New("grandProtoObj"), grandProtoObj);
+  grandProtoObj->SetHiddenValue(
+      v8::String::NewFromUtf8(env->GetIsolate(), "v8::test-debug::c"),
+      v8::Int32::New(13));
+  env->Global()->Set(
+      v8::String::NewFromUtf8(env->GetIsolate(), "grandProtoObj"),
+      grandProtoObj);
 
   // Setting prototypes: obj->protoObj->grandProtoObj
-  protoObj->Set(v8::String::New("__proto__"), grandProtoObj);
-  obj->Set(v8::String::New("__proto__"), protoObj);
+  protoObj->Set(v8::String::NewFromUtf8(env->GetIsolate(), "__proto__"),
+                grandProtoObj);
+  obj->Set(v8::String::NewFromUtf8(env->GetIsolate(), "__proto__"), protoObj);
 
   // Get mirror for the object with property getter.
   CompileRun("var obj_mirror = debug.MakeMirror(obj);");
   CHECK(CompileRun(
       "obj_mirror instanceof debug.ObjectMirror")->BooleanValue());
   CompileRun("var named_names = obj_mirror.propertyNames();");
   // There should be exactly two properties - one from the object itself and
   // another from its hidden prototype.
   CHECK_EQ(2, CompileRun("named_names.length")->Int32Value());
   CHECK(CompileRun("named_names.sort(); named_names[0] == 'a' &&"
@@ skipping 165 matching lines @@
 class MessageQueueDebuggerThread : public v8::internal::Thread {
  public:
   MessageQueueDebuggerThread()
       : Thread("MessageQueueDebuggerThread") { }
   void Run();
 };
 
 
 static void MessageHandler(const v8::Debug::Message& message) {
   v8::Handle<v8::String> json = message.GetJSON();
-  v8::String::AsciiValue ascii(json);
-  if (IsBreakEventMessage(*ascii)) {
+  v8::String::Utf8Value utf8(json);
+  if (IsBreakEventMessage(*utf8)) {
     // Lets test script wait until break occurs to send commands.
     // Signals when a break is reported.
     message_queue_barriers.semaphore_2.Signal();
   }
 
   // Allow message handler to block on a semaphore, to test queueing of
   // messages while blocked.
   message_queue_barriers.semaphore_1.Wait();
 }
 
@@ skipping 285 matching lines @@
       "  }\n"
       "}\n"
       "\n"
       "foo();\n";
 
   v8::Isolate::Scope isolate_scope(CcTest::isolate());
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetMessageHandler2(&ThreadedMessageHandler);
   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
-  global_template->Set(v8::String::New("ThreadedAtBarrier1"),
-                       v8::FunctionTemplate::New(ThreadedAtBarrier1));
+  global_template->Set(
+      v8::String::NewFromUtf8(env->GetIsolate(), "ThreadedAtBarrier1"),
+      v8::FunctionTemplate::New(ThreadedAtBarrier1));
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate(),
                                                      NULL,
                                                      global_template);
   v8::Context::Scope context_scope(context);
 
   CompileRun(source);
 }
 
 
 void DebuggerThread::Run() {
@@ skipping 311 matching lines @@
   CHECK_EQ(args[0]->Int32Value(),
            v8::Debug::Call(frame_source_line)->Int32Value());
 }
 
 
 // Function to test passing an additional parameter to a JavaScript function
 // called in the debugger. It also tests that functions called in the debugger
 // can throw exceptions.
 static void CheckDataParameter(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::Handle<v8::String> data = v8::String::New("Test");
+  v8::Handle<v8::String> data =
+      v8::String::NewFromUtf8(args.GetIsolate(), "Test");
   CHECK(v8::Debug::Call(debugger_call_with_data, data)->IsString());
 
   CHECK(v8::Debug::Call(debugger_call_with_data).IsEmpty());
   CHECK(v8::Debug::Call(debugger_call_with_data).IsEmpty());
 
   v8::TryCatch catcher;
   v8::Debug::Call(debugger_call_with_data);
   CHECK(catcher.HasCaught());
   CHECK(catcher.Exception()->IsString());
 }
 
 
 // Function to test using a JavaScript with closure in the debugger.
 static void CheckClosure(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK(v8::Debug::Call(debugger_call_with_closure)->IsNumber());
   CHECK_EQ(3, v8::Debug::Call(debugger_call_with_closure)->Int32Value());
 }
 
 
 // Test functions called through the debugger.
 TEST(CallFunctionInDebugger) {
   // Create and enter a context with the functions CheckFrameCount,
   // CheckSourceLine and CheckDataParameter installed.
   v8::HandleScope scope(CcTest::isolate());
   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
-  global_template->Set(v8::String::New("CheckFrameCount"),
-                       v8::FunctionTemplate::New(CheckFrameCount));
-  global_template->Set(v8::String::New("CheckSourceLine"),
-                       v8::FunctionTemplate::New(CheckSourceLine));
-  global_template->Set(v8::String::New("CheckDataParameter"),
-                       v8::FunctionTemplate::New(CheckDataParameter));
-  global_template->Set(v8::String::New("CheckClosure"),
-                       v8::FunctionTemplate::New(CheckClosure));
+  global_template->Set(
+      v8::String::NewFromUtf8(CcTest::isolate(), "CheckFrameCount"),
+      v8::FunctionTemplate::New(CheckFrameCount));
+  global_template->Set(
+      v8::String::NewFromUtf8(CcTest::isolate(), "CheckSourceLine"),
+      v8::FunctionTemplate::New(CheckSourceLine));
+  global_template->Set(
+      v8::String::NewFromUtf8(CcTest::isolate(), "CheckDataParameter"),
+      v8::FunctionTemplate::New(CheckDataParameter));
+  global_template->Set(
+      v8::String::NewFromUtf8(CcTest::isolate(), "CheckClosure"),
+      v8::FunctionTemplate::New(CheckClosure));
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate(),
                                                      NULL,
                                                      global_template);
   v8::Context::Scope context_scope(context);
 
   // Compile a function for checking the number of JavaScript frames.
-  v8::Script::Compile(v8::String::New(frame_count_source))->Run();
-  frame_count = v8::Local<v8::Function>::Cast(
-      context->Global()->Get(v8::String::New("frame_count")));
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(CcTest::isolate(), frame_count_source))->Run();
+  frame_count = v8::Local<v8::Function>::Cast(context->Global()->Get(
+      v8::String::NewFromUtf8(CcTest::isolate(), "frame_count")));
 
   // Compile a function for returning the source line for the top frame.
-  v8::Script::Compile(v8::String::New(frame_source_line_source))->Run();
-  frame_source_line = v8::Local<v8::Function>::Cast(
-      context->Global()->Get(v8::String::New("frame_source_line")));
+  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+                                              frame_source_line_source))->Run();
+  frame_source_line = v8::Local<v8::Function>::Cast(context->Global()->Get(
+      v8::String::NewFromUtf8(CcTest::isolate(), "frame_source_line")));
 
   // Compile a function returning the data parameter.
-  v8::Script::Compile(v8::String::New(debugger_call_with_data_source))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+                                              debugger_call_with_data_source))
+      ->Run();
   debugger_call_with_data = v8::Local<v8::Function>::Cast(
-      context->Global()->Get(v8::String::New("debugger_call_with_data")));
+      context->Global()->Get(v8::String::NewFromUtf8(
+          CcTest::isolate(), "debugger_call_with_data")));
 
   // Compile a function capturing closure.
-  debugger_call_with_closure = v8::Local<v8::Function>::Cast(
-      v8::Script::Compile(
-          v8::String::New(debugger_call_with_closure_source))->Run());
+  debugger_call_with_closure =
+      v8::Local<v8::Function>::Cast(v8::Script::Compile(
+          v8::String::NewFromUtf8(CcTest::isolate(),
+                                  debugger_call_with_closure_source))->Run());
 
   // Calling a function through the debugger returns 0 frames if there are
   // no JavaScript frames.
   CHECK_EQ(v8::Integer::New(0), v8::Debug::Call(frame_count));
 
   // Test that the number of frames can be retrieved.
-  v8::Script::Compile(v8::String::New("CheckFrameCount(1)"))->Run();
-  v8::Script::Compile(v8::String::New("function f() {"
-                                      "  CheckFrameCount(2);"
-                                      "}; f()"))->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(CcTest::isolate(), "CheckFrameCount(1)"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+                                              "function f() {"
+                                              "  CheckFrameCount(2);"
+                                              "}; f()"))->Run();
 
   // Test that the source line can be retrieved.
-  v8::Script::Compile(v8::String::New("CheckSourceLine(0)"))->Run();
-  v8::Script::Compile(v8::String::New("function f() {\n"
-                                      "  CheckSourceLine(1)\n"
-                                      "  CheckSourceLine(2)\n"
-                                      "  CheckSourceLine(3)\n"
-                                      "}; f()"))->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(CcTest::isolate(), "CheckSourceLine(0)"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+                                              "function f() {\n"
+                                              "  CheckSourceLine(1)\n"
+                                              "  CheckSourceLine(2)\n"
+                                              "  CheckSourceLine(3)\n"
+                                              "}; f()"))->Run();
 
   // Test that a parameter can be passed to a function called in the debugger.
-  v8::Script::Compile(v8::String::New("CheckDataParameter()"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+                                              "CheckDataParameter()"))->Run();
 
   // Test that a function with closure can be run in the debugger.
-  v8::Script::Compile(v8::String::New("CheckClosure()"))->Run();
-
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(CcTest::isolate(), "CheckClosure()"))->Run();
 
   // Test that the source line is correct when there is a line offset.
-  v8::ScriptOrigin origin(v8::String::New("test"),
+  v8::ScriptOrigin origin(v8::String::NewFromUtf8(CcTest::isolate(), "test"),
                           v8::Integer::New(7));
-  v8::Script::Compile(v8::String::New("CheckSourceLine(7)"), &origin)->Run();
-  v8::Script::Compile(v8::String::New("function f() {\n"
-                                      "  CheckSourceLine(8)\n"
-                                      "  CheckSourceLine(9)\n"
-                                      "  CheckSourceLine(10)\n"
-                                      "}; f()"), &origin)->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(CcTest::isolate(), "CheckSourceLine(7)"), &origin)
+      ->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+                                              "function f() {\n"
+                                              "  CheckSourceLine(8)\n"
+                                              "  CheckSourceLine(9)\n"
+                                              "  CheckSourceLine(10)\n"
+                                              "}; f()"),
+                      &origin)->Run();
 }
 
 
 // Debugger message handler which counts the number of breaks.
 static void SendContinueCommand();
 static void MessageHandlerBreakPointHitCount(
     const v8::Debug::Message& message) {
   if (message.IsEvent() && message.GetEvent() == v8::Break) {
     // Count the number of breaks.
     break_point_hit_count++;
@@ skipping 42 matching lines @@
   CheckDebuggerUnloaded(true);
 
   // Now set a debug message handler.
   break_point_hit_count = 0;
   v8::Debug::SetMessageHandler2(MessageHandlerBreakPointHitCount);
   {
     v8::HandleScope scope(env->GetIsolate());
 
     // Get the test functions again.
     v8::Local<v8::Function> foo(v8::Local<v8::Function>::Cast(
-        env->Global()->Get(v8::String::New("foo"))));
+        env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo"))));
 
     foo->Call(env->Global(), 0, NULL);
     CHECK_EQ(0, break_point_hit_count);
 
     // Set break points and run again.
     SetBreakPoint(foo, 0);
     SetBreakPoint(foo, 4);
     foo->Call(env->Global(), 0, NULL);
     CHECK_EQ(2, break_point_hit_count);
   }
@@ skipping 475 matching lines @@
   CompileRun(
       "var scripts = %DebugGetLoadedScripts();"
       "var count = scripts.length;"
       "for (var i = 0; i < count; ++i) {"
       "  scripts[i].line_ends;"
       "}");
   // Must not crash while accessing line_ends.
   i::FLAG_allow_natives_syntax = allow_natives_syntax;
 
   // Some scripts are retrieved - at least the number of native scripts.
-  CHECK_GT((*env)->Global()->Get(v8::String::New("count"))->Int32Value(), 8);
+  CHECK_GT((*env)
+               ->Global()
+               ->Get(v8::String::NewFromUtf8(env->GetIsolate(), "count"))
+               ->Int32Value(),
+           8);
 }
 
 
 // Test script break points set on lines.
 TEST(ScriptNameAndData) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   // Create functions for retrieving script name and data for the function on
   // the top frame when hitting a break point.
   frame_script_name = CompileFunction(&env,
                                       frame_script_name_source,
                                       "frame_script_name");
   frame_script_data = CompileFunction(&env,
                                       frame_script_data_source,
                                       "frame_script_data");
   compiled_script_data = CompileFunction(&env,
                                          compiled_script_data_source,
                                          "compiled_script_data");
 
   v8::Debug::SetDebugEventListener2(DebugEventBreakPointHitCount);
 
   // Test function source.
-  v8::Local<v8::String> script = v8::String::New(
-    "function f() {\n"
-    "  debugger;\n"
-    "}\n");
+  v8::Local<v8::String> script = v8::String::NewFromUtf8(env->GetIsolate(),
+                                                         "function f() {\n"
+                                                         "  debugger;\n"
+                                                         "}\n");
 
-  v8::ScriptOrigin origin1 = v8::ScriptOrigin(v8::String::New("name"));
+  v8::ScriptOrigin origin1 =
+      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "name"));
   v8::Handle<v8::Script> script1 = v8::Script::Compile(script, &origin1);
-  script1->SetData(v8::String::New("data"));
+  script1->SetData(v8::String::NewFromUtf8(env->GetIsolate(), "data"));
   script1->Run();
   v8::Local<v8::Function> f;
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
 
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   CHECK_EQ("name", last_script_name_hit);
   CHECK_EQ("data", last_script_data_hit);
 
   // Compile the same script again without setting data. As the compilation
   // cache is disabled when debugging expect the data to be missing.
   v8::Script::Compile(script, &origin1)->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
   CHECK_EQ("name", last_script_name_hit);
   CHECK_EQ("", last_script_data_hit);  // Undefined results in empty string.
 
-  v8::Local<v8::String> data_obj_source = v8::String::New(
-    "({ a: 'abc',\n"
-    "  b: 123,\n"
-    "  toString: function() { return this.a + ' ' + this.b; }\n"
-    "})\n");
+  v8::Local<v8::String> data_obj_source = v8::String::NewFromUtf8(
+      env->GetIsolate(),
+      "({ a: 'abc',\n"
+      "  b: 123,\n"
+      "  toString: function() { return this.a + ' ' + this.b; }\n"
+      "})\n");
   v8::Local<v8::Value> data_obj = v8::Script::Compile(data_obj_source)->Run();
-  v8::ScriptOrigin origin2 = v8::ScriptOrigin(v8::String::New("new name"));
+  v8::ScriptOrigin origin2 =
+      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "new name"));
   v8::Handle<v8::Script> script2 = v8::Script::Compile(script, &origin2);
   script2->Run();
   script2->SetData(data_obj->ToString());
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(3, break_point_hit_count);
   CHECK_EQ("new name", last_script_name_hit);
   CHECK_EQ("abc 123", last_script_data_hit);
 
-  v8::Handle<v8::Script> script3 =
-      v8::Script::Compile(script, &origin2, NULL,
-                          v8::String::New("in compile"));
+  v8::Handle<v8::Script> script3 = v8::Script::Compile(
+      script, &origin2, NULL,
+      v8::String::NewFromUtf8(env->GetIsolate(), "in compile"));
   CHECK_EQ("in compile", last_script_data_hit);
   script3->Run();
-  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(4, break_point_hit_count);
   CHECK_EQ("in compile", last_script_data_hit);
 }
 
 
 static v8::Handle<v8::Context> expected_context;
 static v8::Handle<v8::Value> expected_context_data;
 
 
@@ skipping 31 matching lines @@
   context_1 = v8::Context::New(isolate, NULL, global_template, global_object);
   context_2 = v8::Context::New(isolate, NULL, global_template, global_object);
 
   v8::Debug::SetMessageHandler2(ContextCheckMessageHandler);
 
   // Default data value is undefined.
   CHECK(context_1->GetEmbedderData(0)->IsUndefined());
   CHECK(context_2->GetEmbedderData(0)->IsUndefined());
 
   // Set and check different data values.
-  v8::Handle<v8::String> data_1 = v8::String::New("1");
-  v8::Handle<v8::String> data_2 = v8::String::New("2");
+  v8::Handle<v8::String> data_1 = v8::String::NewFromUtf8(isolate, "1");
+  v8::Handle<v8::String> data_2 = v8::String::NewFromUtf8(isolate, "2");
   context_1->SetEmbedderData(0, data_1);
   context_2->SetEmbedderData(0, data_2);
   CHECK(context_1->GetEmbedderData(0)->StrictEquals(data_1));
   CHECK(context_2->GetEmbedderData(0)->StrictEquals(data_2));
 
   // Simple test function which causes a break.
   const char* source = "function f() { debugger; }";
 
   // Enter and run function in the first context.
   {
     v8::Context::Scope context_scope(context_1);
     expected_context = context_1;
     expected_context_data = data_1;
-    v8::Local<v8::Function> f = CompileFunction(source, "f");
+    v8::Local<v8::Function> f = CompileFunction(isolate, source, "f");
     f->Call(context_1->Global(), 0, NULL);
   }
 
 
   // Enter and run function in the second context.
   {
     v8::Context::Scope context_scope(context_2);
     expected_context = context_2;
     expected_context_data = data_2;
-    v8::Local<v8::Function> f = CompileFunction(source, "f");
+    v8::Local<v8::Function> f = CompileFunction(isolate, source, "f");
     f->Call(context_2->Global(), 0, NULL);
   }
 
   // Two times compile event and two times break event.
   CHECK_GT(message_handler_hit_count, 4);
 
   v8::Debug::SetMessageHandler2(NULL);
   CheckDebuggerUnloaded();
 }
 
@@ skipping 20 matching lines @@
 // Test that a debug break can be scheduled while in a message handler.
 TEST(DebugBreakInMessageHandler) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   v8::Debug::SetMessageHandler2(DebugBreakMessageHandler);
 
   // Test functions.
   const char* script = "function f() { debugger; g(); } function g() { }";
   CompileRun(script);
-  v8::Local<v8::Function> f =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
-  v8::Local<v8::Function> g =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
+  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
+  v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
 
   // Call f then g. The debugger statement in f will casue a break which will
   // cause another break.
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, message_handler_break_hit_count);
   // Calling g will not cause any additional breaks.
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, message_handler_break_hit_count);
 }
 
@@ skipping 42 matching lines @@
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
                                         "frame_function_name");
 
   // Test RegExp which matches white spaces and comments at the begining of a
   // source line.
   const char* script =
     "var sourceLineBeginningSkip = /^(?:[ \\v\\h]*(?:\\/\\*.*?\\*\\/)*)*/;\n"
     "function f(s) { return s.match(sourceLineBeginningSkip)[0].length; }";
 
-  v8::Local<v8::Function> f = CompileFunction(script, "f");
+  v8::Local<v8::Function> f = CompileFunction(env->GetIsolate(), script, "f");
   const int argc = 1;
-  v8::Handle<v8::Value> argv[argc] = { v8::String::New("  /* xxx */ a=0;") };
+  v8::Handle<v8::Value> argv[argc] = {
+      v8::String::NewFromUtf8(env->GetIsolate(), "  /* xxx */ a=0;")};
   v8::Local<v8::Value> result = f->Call(env->Global(), argc, argv);
   CHECK_EQ(12, result->Int32Value());
 
   v8::Debug::SetDebugEventListener2(DebugEventDebugBreak);
   v8::Debug::DebugBreak(env->GetIsolate());
   result = f->Call(env->Global(), argc, argv);
 
   // Check that there was only one break event. Matching RegExp should not
   // cause Break events.
   CHECK_EQ(1, break_point_hit_count);
@@ skipping 11 matching lines @@
       v8::Handle<v8::ObjectTemplate>();
   context_1 =
       v8::Context::New(CcTest::isolate(), NULL, global_template);
 
   v8::Debug::SetMessageHandler2(message_handler);
 
   // Default data value is undefined.
   CHECK(context_1->GetEmbedderData(0)->IsUndefined());
 
   // Set and check a data value.
-  v8::Handle<v8::String> data_1 = v8::String::New("1");
+  v8::Handle<v8::String> data_1 =
+      v8::String::NewFromUtf8(CcTest::isolate(), "1");
   context_1->SetEmbedderData(0, data_1);
   CHECK(context_1->GetEmbedderData(0)->StrictEquals(data_1));
 
   // Simple test function with eval that causes a break.
   const char* source = "function f() { eval('debugger;'); }";
 
   // Enter and run function in the context.
   {
     v8::Context::Scope context_scope(context_1);
     expected_context = context_1;
     expected_context_data = data_1;
-    v8::Local<v8::Function> f = CompileFunction(source, "f");
+    v8::Local<v8::Function> f = CompileFunction(CcTest::isolate(), source, "f");
     f->Call(context_1->Global(), 0, NULL);
   }
 
   v8::Debug::SetMessageHandler2(NULL);
 }
 
 
 // Test which creates a context and sets embedder data on it. Checks that this
 // data is set correctly and that when the debug message handler is called for
 // break event in an eval statement the expected context is the one returned by
@@ skipping 100 matching lines @@
   // Request the loaded scripts to initialize the debugger script cache.
   debug->GetLoadedScripts();
 
   // Do garbage collection to ensure that only the script in this test will be
   // collected afterwards.
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
 
   script_collected_count = 0;
   v8::Debug::SetDebugEventListener2(DebugEventScriptCollectedEvent);
   {
-    v8::Script::Compile(v8::String::New("eval('a=1')"))->Run();
-    v8::Script::Compile(v8::String::New("eval('a=2')"))->Run();
+    v8::Script::Compile(
+        v8::String::NewFromUtf8(env->GetIsolate(), "eval('a=1')"))->Run();
+    v8::Script::Compile(
+        v8::String::NewFromUtf8(env->GetIsolate(), "eval('a=2')"))->Run();
   }
 
   // Do garbage collection to collect the script above which is no longer
   // referenced.
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
 
   CHECK_EQ(2, script_collected_count);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
@@ skipping 38 matching lines @@
   }
 
   // Request the loaded scripts to initialize the debugger script cache.
   debug->GetLoadedScripts();
 
   // Do garbage collection to ensure that only the script in this test will be
   // collected afterwards.
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
 
   v8::Debug::SetMessageHandler2(ScriptCollectedMessageHandler);
-  v8::Script::Compile(v8::String::New("eval('a=1')"))->Run();
-  v8::Script::Compile(v8::String::New("eval('a=2')"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate, "eval('a=1')"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate, "eval('a=2')"))->Run();
 
   // Leave context
   {
     v8::HandleScope scope(isolate);
     v8::Local<v8::Context> local_context =
         v8::Local<v8::Context>::New(isolate, context);
     local_context->Exit();
   }
-  context.Dispose();
+  context.Reset();
 
   // Do garbage collection to collect the script above which is no longer
   // referenced.
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
 
   CHECK_EQ(2, script_collected_message_count);
 
   v8::Debug::SetMessageHandler2(NULL);
 }
 
@@ skipping 14 matching lines @@
 
 // Tests that after compile event is sent as many times as there are scripts
 // compiled.
 TEST(AfterCompileMessageWhenMessageHandlerIsReset) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   after_compile_message_count = 0;
   const char* script = "var a=1";
 
   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
-  v8::Script::Compile(v8::String::New(script))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), script))
+      ->Run();
   v8::Debug::SetMessageHandler2(NULL);
 
   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
   v8::Debug::DebugBreak(env->GetIsolate());
-  v8::Script::Compile(v8::String::New(script))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), script))
+      ->Run();
 
   // Setting listener to NULL should cause debugger unload.
   v8::Debug::SetMessageHandler2(NULL);
   CheckDebuggerUnloaded();
 
   // Compilation cache should be disabled when debugger is active.
   CHECK_EQ(2, after_compile_message_count);
 }
 
 
 // Tests that break event is sent when message handler is reset.
 TEST(BreakMessageWhenMessageHandlerIsReset) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   after_compile_message_count = 0;
   const char* script = "function f() {};";
 
   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
-  v8::Script::Compile(v8::String::New(script))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), script))
+      ->Run();
   v8::Debug::SetMessageHandler2(NULL);
 
   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
   v8::Debug::DebugBreak(env->GetIsolate());
-  v8::Local<v8::Function> f =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
   f->Call(env->Global(), 0, NULL);
 
   // Setting message handler to NULL should cause debugger unload.
   v8::Debug::SetMessageHandler2(NULL);
   CheckDebuggerUnloaded();
 
   // Compilation cache should be disabled when debugger is active.
   CHECK_EQ(1, after_compile_message_count);
 }
 
@@ skipping 12 matching lines @@
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // For this test, we want to break on uncaught exceptions:
   ChangeBreakOnException(false, true);
 
   exception_event_count = 0;
   const char* script = "function f() {throw new Error()};";
 
   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
-  v8::Script::Compile(v8::String::New(script))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), script))
+      ->Run();
   v8::Debug::SetMessageHandler2(NULL);
 
   v8::Debug::SetMessageHandler2(ExceptionMessageHandler);
-  v8::Local<v8::Function> f =
-      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
   f->Call(env->Global(), 0, NULL);
 
   // Setting message handler to NULL should cause debugger unload.
   v8::Debug::SetMessageHandler2(NULL);
   CheckDebuggerUnloaded();
 
   CHECK_EQ(1, exception_event_count);
 }
 
 
 // Tests after compile event is sent when there are some provisional
 // breakpoints out of the scripts lines range.
 TEST(ProvisionalBreakpointOnLineOutOfRange) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
   const char* script = "function f() {};";
   const char* resource_name = "test_resource";
 
   // Set a couple of provisional breakpoint on lines out of the script lines
   // range.
-  int sbp1 = SetScriptBreakPointByNameFromJS(resource_name, 3,
-                                             -1 /* no column */);
-  int sbp2 = SetScriptBreakPointByNameFromJS(resource_name, 5, 5);
+  int sbp1 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), resource_name,
+                                             3, -1 /* no column */);
+  int sbp2 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), resource_name, 5, 5);
 
   after_compile_message_count = 0;
   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
 
   v8::ScriptOrigin origin(
-      v8::String::New(resource_name),
+      v8::String::NewFromUtf8(env->GetIsolate(), resource_name),
       v8::Integer::New(10),
       v8::Integer::New(1));
   // Compile a script whose first line number is greater than the breakpoints'
   // lines.
-  v8::Script::Compile(v8::String::New(script), &origin)->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), script),
+                      &origin)->Run();
 
   // If the script is compiled successfully there is exactly one after compile
   // event. In case of an exception in debugger code after compile event is not
   // sent.
   CHECK_EQ(1, after_compile_message_count);
 
-  ClearBreakPointFromJS(sbp1);
-  ClearBreakPointFromJS(sbp2);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
   v8::Debug::SetMessageHandler2(NULL);
 }
 
 
 static void BreakMessageHandler(const v8::Debug::Message& message) {
   i::Isolate* isolate = CcTest::i_isolate();
   if (message.IsEvent() && message.GetEvent() == v8::Break) {
     // Count the number of breaks.
     break_point_hit_count++;
 
@@ skipping 137 matching lines @@
   // Check backtrace from ProcessDebugMessages.
   BacktraceData::frame_counter = -10;
   v8::Debug::SendCommand(
       isolate,
       buffer,
       AsciiToUtf16(scripts_command, buffer),
       NULL);
   v8::Debug::ProcessDebugMessages();
   CHECK_EQ(BacktraceData::frame_counter, 0);
 
-  v8::Handle<v8::String> void0 = v8::String::New("void(0)");
+  v8::Handle<v8::String> void0 =
+      v8::String::NewFromUtf8(env->GetIsolate(), "void(0)");
   v8::Handle<v8::Script> script = v8::Script::Compile(void0, void0);
 
   // Check backtrace from "void(0)" script.
   BacktraceData::frame_counter = -10;
   v8::Debug::SendCommand(
       isolate,
       buffer,
       AsciiToUtf16(scripts_command, buffer),
       NULL);
   script->Run();
   CHECK_EQ(BacktraceData::frame_counter, 1);
 
   // Get rid of the debug message handler.
   v8::Debug::SetMessageHandler2(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 TEST(GetMirror) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<v8::Value> obj = v8::Debug::GetMirror(v8::String::New("hodja"));
-  v8::Handle<v8::Function> run_test = v8::Handle<v8::Function>::Cast(
-      v8::Script::New(
-          v8::String::New(
+  v8::Handle<v8::Value> obj =
+      v8::Debug::GetMirror(v8::String::NewFromUtf8(env->GetIsolate(), "hodja"));
+  v8::Handle<v8::Function> run_test =
+      v8::Handle<v8::Function>::Cast(v8::Script::New(
+          v8::String::NewFromUtf8(
+              env->GetIsolate(),
               "function runTest(mirror) {"
               "  return mirror.isString() && (mirror.length() == 5);"
               "}"
               ""
               "runTest;"))->Run());
   v8::Handle<v8::Value> result = run_test->Call(env->Global(), 1, &obj);
   CHECK(result->IsTrue());
 }
 
 
@@ skipping 80 matching lines @@
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   // Save handles to the debugger and debugee contexts to be used in
   // NamedGetterWithCallingContextCheck.
   debugee_context = env.context();
   debugger_context = v8::Utils::ToLocal(debug->debug_context());
 
   // Create object with 'a' property accessor.
   v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
-  named->SetAccessor(v8::String::New("a"),
+  named->SetAccessor(v8::String::NewFromUtf8(env->GetIsolate(), "a"),
                      NamedGetterWithCallingContextCheck);
-  env->Global()->Set(v8::String::New("obj"),
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "obj"),
                      named->NewInstance());
 
   // Register the debug event listener
   v8::Debug::SetDebugEventListener2(DebugEventGetAtgumentPropertyValue);
 
   // Create a function that invokes debugger.
   v8::Local<v8::Function> foo = CompileFunction(
       &env,
       "function bar(x) { debugger; }"
       "function foo(){ bar(obj); }",
@@ skipping 27 matching lines @@
 
 // Check that event details contain context where debug event occured.
 TEST(DebugEventContext) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   expected_callback_data = v8::Int32::New(2010);
   expected_context = v8::Context::New(isolate);
   v8::Debug::SetDebugEventListener2(DebugEventContextChecker,
                                     expected_callback_data);
   v8::Context::Scope context_scope(expected_context);
-  v8::Script::Compile(v8::String::New("(function(){debugger;})();"))->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(isolate, "(function(){debugger;})();"))->Run();
   expected_context.Clear();
   v8::Debug::SetDebugEventListener2(NULL);
   expected_context_data = v8::Handle<v8::Value>();
   CheckDebuggerUnloaded();
 }
 
 
 static void* expected_break_data;
 static bool was_debug_break_called;
 static bool was_debug_event_called;
@@ skipping 14 matching lines @@
   v8::HandleScope scope(isolate);
   v8::Debug::SetDebugEventListener2(DebugEventBreakDataChecker);
 
   TestClientData::constructor_call_counter = 0;
   TestClientData::destructor_call_counter = 0;
 
   expected_break_data = NULL;
   was_debug_event_called = false;
   was_debug_break_called = false;
   v8::Debug::DebugBreakForCommand(NULL, isolate);
-  v8::Script::Compile(v8::String::New("(function(x){return x;})(1);"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                              "(function(x){return x;})(1);"))
+      ->Run();
   CHECK(was_debug_event_called);
   CHECK(!was_debug_break_called);
 
   TestClientData* data1 = new TestClientData();
   expected_break_data = data1;
   was_debug_event_called = false;
   was_debug_break_called = false;
   v8::Debug::DebugBreakForCommand(data1, isolate);
-  v8::Script::Compile(v8::String::New("(function(x){return x+1;})(1);"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                              "(function(x){return x+1;})(1);"))
+      ->Run();
   CHECK(was_debug_event_called);
   CHECK(!was_debug_break_called);
 
   expected_break_data = NULL;
   was_debug_event_called = false;
   was_debug_break_called = false;
   v8::Debug::DebugBreak(isolate);
-  v8::Script::Compile(v8::String::New("(function(x){return x+2;})(1);"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                              "(function(x){return x+2;})(1);"))
+      ->Run();
   CHECK(!was_debug_event_called);
   CHECK(was_debug_break_called);
 
   TestClientData* data2 = new TestClientData();
   expected_break_data = data2;
   was_debug_event_called = false;
   was_debug_break_called = false;
   v8::Debug::DebugBreak(isolate);
   v8::Debug::DebugBreakForCommand(data2, isolate);
-  v8::Script::Compile(v8::String::New("(function(x){return x+3;})(1);"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                              "(function(x){return x+3;})(1);"))
+      ->Run();
   CHECK(was_debug_event_called);
   CHECK(was_debug_break_called);
 
   CHECK_EQ(2, TestClientData::constructor_call_counter);
   CHECK_EQ(TestClientData::constructor_call_counter,
            TestClientData::destructor_call_counter);
 
   v8::Debug::SetDebugEventListener2(NULL);
   CheckDebuggerUnloaded();
 }
@@ skipping 42 matching lines @@
 
 
   // Set a debug event listener which will keep interrupting execution until
   // debug break. When inside function bar it will deoptimize all functions.
   // This tests lazy deoptimization bailout for the stack check, as the first
   // time in function bar when using debug break and no break points will be at
   // the initial stack check.
   v8::Debug::SetDebugEventListener2(DebugEventBreakDeoptimize);
 
   // Compile and run function bar which will optimize it for some flag settings.
-  v8::Script::Compile(v8::String::New("function bar(){}; bar()"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(
+                          env->GetIsolate(), "function bar(){}; bar()"))->Run();
 
   // Set debug break and call bar again.
   v8::Debug::DebugBreak(env->GetIsolate());
-  v8::Script::Compile(v8::String::New("bar()"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "bar()"))
+      ->Run();
 
   CHECK(debug_event_break_deoptimize_done);
 
   v8::Debug::SetDebugEventListener2(NULL);
 }
 
 
 static void DebugEventBreakWithOptimizedStack(
     const v8::Debug::EventDetails& event_details) {
+  v8::Isolate* isolate = event_details.GetEventContext()->GetIsolate();
   v8::DebugEvent event = event_details.GetEvent();
   v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();
   if (event == v8::Break) {
     if (!frame_function_name.IsEmpty()) {
       for (int i = 0; i < 2; i++) {
         const int argc = 2;
         v8::Handle<v8::Value> argv[argc] = { exec_state, v8::Integer::New(i) };
         // Get the name of the function in frame i.
         v8::Handle<v8::Value> result =
             frame_function_name->Call(exec_state, argc, argv);
         CHECK(result->IsString());
         v8::Handle<v8::String> function_name(result->ToString());
-        CHECK(function_name->Equals(v8::String::New("loop")));
+        CHECK(function_name->Equals(v8::String::NewFromUtf8(isolate, "loop")));
         // Get the name of the first argument in frame i.
         result = frame_argument_name->Call(exec_state, argc, argv);
         CHECK(result->IsString());
         v8::Handle<v8::String> argument_name(result->ToString());
-        CHECK(argument_name->Equals(v8::String::New("count")));
+        CHECK(argument_name->Equals(v8::String::NewFromUtf8(isolate, "count")));
         // Get the value of the first argument in frame i. If the
         // funtion is optimized the value will be undefined, otherwise
         // the value will be '1 - i'.
         //
         // TODO(3141533): We should be able to get the real value for
         // optimized frames.
         result = frame_argument_value->Call(exec_state, argc, argv);
         CHECK(result->IsUndefined() || (result->Int32Value() == 1 - i));
         // Get the name of the first local variable.
         result = frame_local_name->Call(exec_state, argc, argv);
         CHECK(result->IsString());
         v8::Handle<v8::String> local_name(result->ToString());
-        CHECK(local_name->Equals(v8::String::New("local")));
+        CHECK(local_name->Equals(v8::String::NewFromUtf8(isolate, "local")));
         // Get the value of the first local variable. If the function
         // is optimized the value will be undefined, otherwise it will
         // be 42.
         //
         // TODO(3141533): We should be able to get the real value for
         // optimized frames.
         result = frame_local_value->Call(exec_state, argc, argv);
         CHECK(result->IsUndefined() || (result->Int32Value() == 42));
       }
     }
@@ skipping 28 matching lines @@
   v8::Handle<v8::Function> schedule_break =
       schedule_break_template->GetFunction();
   env->Global()->Set(v8_str("scheduleBreak"), schedule_break);
 
   const char* src =
       "function loop(count) {"
       "  var local = 42;"
       "  if (count < 1) { scheduleBreak(); loop(count + 1); }"
       "}"
       "loop(0);";
-  v8::Script::Compile(v8::String::New(src))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), src))->Run();
 }
 
 
 // Test that setting the terminate execution flag during debug break processing.
 static void TestDebugBreakInLoop(const char* loop_head,
                                  const char** loop_bodies,
                                  const char* loop_tail) {
   // Receive 100 breaks for each test and then terminate JavaScript execution.
   static const int kBreaksPerTest = 100;
 
@@ skipping 123 matching lines @@
       "  debug(b)                      \n"
       "};                              \n"
       "function g(b) {                 \n"
       "  f(b);                         \n"
       "};                              \n"
       "g(false);                       \n"
       "g(false);                       \n"
       "%OptimizeFunctionOnNextCall(g); \n"
       "g(true);";
   v8::Debug::SetDebugEventListener2(DebugBreakInlineListener);
-  inline_script = v8::Script::Compile(v8::String::New(source));
+  inline_script =
+      v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), source));
   inline_script->Run();
 }
 
 
 static void DebugEventStepNext(
     const v8::Debug::EventDetails& event_details) {
   v8::DebugEvent event = event_details.GetEvent();
   if (event == v8::Break) {
     PrepareStep(StepNext);
   }
@@ skipping 71 matching lines @@
 TEST(LiveEditDisabled) {
   v8::internal::FLAG_allow_natives_syntax = true;
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetLiveEditEnabled(false), env->GetIsolate();
   CompileRun("%LiveEditCompareStrings('', '')");
 }
 
 
 #endif  // ENABLE_DEBUGGER_SUPPORT