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

samples/lineprocessor.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 80 matching lines @@
  * is called again. See how "--callback" command-line parameter in this sample
  * fixes this issue.
  */
 
 enum MainCycleType {
   CycleInCpp,
   CycleInJs
 };
 
 const char* ToCString(const v8::String::Utf8Value& value);
-void ReportException(v8::TryCatch* handler);
+void ReportException(v8::Isolate* isolate, v8::TryCatch* handler);
 v8::Handle<v8::String> ReadFile(const char* name);
 v8::Handle<v8::String> ReadLine();
 
 v8::Handle<v8::Value> Print(const v8::Arguments& args);
 v8::Handle<v8::Value> ReadLine(const v8::Arguments& args);
-bool RunCppCycle(v8::Handle<v8::Script> script, v8::Local<v8::Context> context,
+bool RunCppCycle(v8::Handle<v8::Script> script,
+                 v8::Local<v8::Context> context,
                  bool report_exceptions);
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 v8::Persistent<v8::Context> debug_message_context;
 
 void DispatchDebugMessages() {
   // We are in some random thread. We should already have v8::Locker acquired
   // (we requested this when registered this callback). We was called
   // because new debug messages arrived; they may have already been processed,
   // but we shouldn't worry about this.
   //
   // All we have to do is to set context and call ProcessDebugMessages.
   //
   // We should decide which V8 context to use here. This is important for
   // "evaluate" command, because it must be executed some context.
   // In our sample we have only one context, so there is nothing really to
   // think about.
   v8::Context::Scope scope(debug_message_context);
 
   v8::Debug::ProcessDebugMessages();
 }
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 int RunMain(int argc, char* argv[]) {
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
-  v8::HandleScope handle_scope;
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope handle_scope(isolate);
 
   v8::Handle<v8::String> script_source(NULL);
   v8::Handle<v8::Value> script_name(NULL);
   int script_param_counter = 0;
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   int port_number = -1;
   bool wait_for_connection = false;
   bool support_callback = false;
 #endif  // ENABLE_DEBUGGER_SUPPORT
@@ skipping 60 matching lines @@
   }
 
   // Create a new execution environment containing the built-in
   // functions
   v8::Handle<v8::Context> context = v8::Context::New(NULL, global);
   // Enter the newly created execution environment.
   v8::Context::Scope context_scope(context);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   debug_message_context =
-      v8::Persistent<v8::Context>::New(context->GetIsolate(), context);
+      v8::Persistent<v8::Context>::New(isolate, context);
 
-  v8::Locker locker(context->GetIsolate());
+  v8::Locker locker(isolate);
 
   if (support_callback) {
     v8::Debug::SetDebugMessageDispatchHandler(DispatchDebugMessages, true);
   }
 
   if (port_number != -1) {
     v8::Debug::EnableAgent("lineprocessor", port_number, wait_for_connection);
   }
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
   bool report_exceptions = true;
 
   v8::Handle<v8::Script> script;
   {
     // Compile script in try/catch context.
     v8::TryCatch try_catch;
     script = v8::Script::Compile(script_source, script_name);
     if (script.IsEmpty()) {
       // Print errors that happened during compilation.
       if (report_exceptions)
-        ReportException(&try_catch);
+        ReportException(isolate, &try_catch);
       return 1;
     }
   }
 
   {
     v8::TryCatch try_catch;
 
     script->Run();
     if (try_catch.HasCaught()) {
       if (report_exceptions)
-        ReportException(&try_catch);
+        ReportException(isolate, &try_catch);
       return 1;
     }
   }
 
   if (cycle_type == CycleInCpp) {
-    bool res = RunCppCycle(script, v8::Context::GetCurrent(),
+    bool res = RunCppCycle(script,
+                           v8::Context::GetCurrent(),
                            report_exceptions);
     return !res;
   } else {
     // All is already done.
   }
   return 0;
 }
 
 
-bool RunCppCycle(v8::Handle<v8::Script> script, v8::Local<v8::Context> context,
+bool RunCppCycle(v8::Handle<v8::Script> script,
+                 v8::Local<v8::Context> context,
                  bool report_exceptions) {
+  v8::Isolate* isolate = context->GetIsolate();
 #ifdef ENABLE_DEBUGGER_SUPPORT
-  v8::Locker lock(v8::Isolate::GetCurrent());
+  v8::Locker lock(isolate);
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
   v8::Handle<v8::String> fun_name = v8::String::New("ProcessLine");
-  v8::Handle<v8::Value> process_val =
-      v8::Context::GetCurrent()->Global()->Get(fun_name);
+  v8::Handle<v8::Value> process_val = context->Global()->Get(fun_name);
 
   // If there is no Process function, or if it is not a function,
   // bail out
   if (!process_val->IsFunction()) {
     printf("Error: Script does not declare 'ProcessLine' global function.\n");
     return 1;
   }
 
   // It is a function; cast it to a Function
   v8::Handle<v8::Function> process_fun =
       v8::Handle<v8::Function>::Cast(process_val);
 
 
   while (!feof(stdin)) {
-    v8::HandleScope handle_scope;
+    v8::HandleScope handle_scope(isolate);
 
     v8::Handle<v8::String> input_line = ReadLine();
     if (input_line == v8::Undefined()) {
       continue;
     }
 
     const int argc = 1;
     v8::Handle<v8::Value> argv[argc] = { input_line };
 
     v8::Handle<v8::Value> result;
     {
       v8::TryCatch try_catch;
       result = process_fun->Call(v8::Context::GetCurrent()->Global(),
                                  argc, argv);
       if (try_catch.HasCaught()) {
         if (report_exceptions)
-          ReportException(&try_catch);
+          ReportException(isolate, &try_catch);
         return false;
       }
     }
     v8::String::Utf8Value str(result);
     const char* cstr = ToCString(str);
     printf("%s\n", cstr);
   }
 
   return true;
 }
@@ skipping 26 matching lines @@
     int read = static_cast<int>(fread(&chars[i], 1, size - i, file));
     i += read;
   }
   fclose(file);
   v8::Handle<v8::String> result = v8::String::New(chars, size);
   delete[] chars;
   return result;
 }
 
 
-void ReportException(v8::TryCatch* try_catch) {
-  v8::HandleScope handle_scope;
+void ReportException(v8::Isolate* isolate, v8::TryCatch* try_catch) {
+  v8::HandleScope handle_scope(isolate);
   v8::String::Utf8Value exception(try_catch->Exception());
   const char* exception_string = ToCString(exception);
   v8::Handle<v8::Message> message = try_catch->Message();
   if (message.IsEmpty()) {
     // V8 didn't provide any extra information about this error; just
     // print the exception.
     printf("%s\n", exception_string);
   } else {
     // Print (filename):(line number): (message).
     v8::String::Utf8Value filename(message->GetScriptResourceName());
@@ skipping 17 matching lines @@
   }
 }
 
 
 // The callback that is invoked by v8 whenever the JavaScript 'print'
 // function is called.  Prints its arguments on stdout separated by
 // spaces and ending with a newline.
 v8::Handle<v8::Value> Print(const v8::Arguments& args) {
   bool first = true;
   for (int i = 0; i < args.Length(); i++) {
-    v8::HandleScope handle_scope;
+    v8::HandleScope handle_scope(args.GetIsolate());
     if (first) {
       first = false;
     } else {
       printf(" ");
     }
     v8::String::Utf8Value str(args[i]);
     const char* cstr = ToCString(str);
     printf("%s", cstr);
   }
   printf("\n");
@@ skipping 28 matching lines @@
   }
   // Remove newline char
   for (char* pos = buffer; *pos != '\0'; pos++) {
     if (*pos == '\n') {
       *pos = '\0';
       break;
     }
   }
   return v8::String::New(buffer);
 }