Remove usage of deprecated APIs from samples

samples/shell.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 40 matching lines @@
 bool ExecuteString(v8::Isolate* isolate,
                    v8::Handle<v8::String> source,
                    v8::Handle<v8::Value> name,
                    bool print_result,
                    bool report_exceptions);
 void Print(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Read(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Load(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Quit(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Version(const v8::FunctionCallbackInfo<v8::Value>& args);
-v8::Handle<v8::String> ReadFile(const char* name);
+v8::Handle<v8::String> ReadFile(v8::Isolate* isolate, const char* name);
 void ReportException(v8::Isolate* isolate, v8::TryCatch* handler);
 
 
 static bool run_shell;
 
 
 int main(int argc, char* argv[]) {
   v8::V8::InitializeICU();
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
@@ skipping 21 matching lines @@
   return *value ? *value : "<string conversion failed>";
 }
 
 
 // Creates a new execution environment containing the built-in
 // functions.
 v8::Handle<v8::Context> CreateShellContext(v8::Isolate* isolate) {
   // Create a template for the global object.
   v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
   // Bind the global 'print' function to the C++ Print callback.
-  global->Set(v8::String::New("print"), v8::FunctionTemplate::New(Print));
+  global->Set(v8::String::NewFromUtf8(isolate, "print"),
+              v8::FunctionTemplate::New(Print));
   // Bind the global 'read' function to the C++ Read callback.
-  global->Set(v8::String::New("read"), v8::FunctionTemplate::New(Read));
+  global->Set(v8::String::NewFromUtf8(isolate, "read"),
+              v8::FunctionTemplate::New(Read));
   // Bind the global 'load' function to the C++ Load callback.
-  global->Set(v8::String::New("load"), v8::FunctionTemplate::New(Load));
+  global->Set(v8::String::NewFromUtf8(isolate, "load"),
+              v8::FunctionTemplate::New(Load));
   // Bind the 'quit' function
-  global->Set(v8::String::New("quit"), v8::FunctionTemplate::New(Quit));
+  global->Set(v8::String::NewFromUtf8(isolate, "quit"),
+              v8::FunctionTemplate::New(Quit));
   // Bind the 'version' function
-  global->Set(v8::String::New("version"), v8::FunctionTemplate::New(Version));
+  global->Set(v8::String::NewFromUtf8(isolate, "version"),
+              v8::FunctionTemplate::New(Version));
 
   return v8::Context::New(isolate, NULL, global);
 }
 
 
 // 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.
 void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
   bool first = true;
@@ skipping 12 matching lines @@
   fflush(stdout);
 }
 
 
 // The callback that is invoked by v8 whenever the JavaScript 'read'
 // function is called.  This function loads the content of the file named in
 // the argument into a JavaScript string.
 void Read(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1) {
     args.GetIsolate()->ThrowException(
-        v8::String::New("Bad parameters"));
+        v8::String::NewFromUtf8(args.GetIsolate(), "Bad parameters"));
     return;
   }
   v8::String::Utf8Value file(args[0]);
   if (*file == NULL) {
     args.GetIsolate()->ThrowException(
-        v8::String::New("Error loading file"));
+        v8::String::NewFromUtf8(args.GetIsolate(), "Error loading file"));
     return;
   }
-  v8::Handle<v8::String> source = ReadFile(*file);
+  v8::Handle<v8::String> source = ReadFile(args.GetIsolate(), *file);
   if (source.IsEmpty()) {
     args.GetIsolate()->ThrowException(
-        v8::String::New("Error loading file"));
+        v8::String::NewFromUtf8(args.GetIsolate(), "Error loading file"));
     return;
   }
   args.GetReturnValue().Set(source);
 }
 
 
 // The callback that is invoked by v8 whenever the JavaScript 'load'
 // function is called.  Loads, compiles and executes its argument
 // JavaScript file.
 void Load(const v8::FunctionCallbackInfo<v8::Value>& args) {
   for (int i = 0; i < args.Length(); i++) {
     v8::HandleScope handle_scope(args.GetIsolate());
     v8::String::Utf8Value file(args[i]);
     if (*file == NULL) {
       args.GetIsolate()->ThrowException(
-          v8::String::New("Error loading file"));
+          v8::String::NewFromUtf8(args.GetIsolate(), "Error loading file"));
       return;
     }
-    v8::Handle<v8::String> source = ReadFile(*file);
+    v8::Handle<v8::String> source = ReadFile(args.GetIsolate(), *file);
     if (source.IsEmpty()) {
       args.GetIsolate()->ThrowException(
-           v8::String::New("Error loading file"));
+           v8::String::NewFromUtf8(args.GetIsolate(), "Error loading file"));
       return;
     }
     if (!ExecuteString(args.GetIsolate(),
                        source,
-                       v8::String::New(*file),
+                       v8::String::NewFromUtf8(args.GetIsolate(), *file),
                        false,
                        false)) {
       args.GetIsolate()->ThrowException(
-          v8::String::New("Error executing file"));
+          v8::String::NewFromUtf8(args.GetIsolate(), "Error executing file"));
       return;
     }
   }
 }
 
 
 // The callback that is invoked by v8 whenever the JavaScript 'quit'
 // function is called.  Quits.
 void Quit(const v8::FunctionCallbackInfo<v8::Value>& args) {
   // If not arguments are given args[0] will yield undefined which
   // converts to the integer value 0.
   int exit_code = args[0]->Int32Value();
   fflush(stdout);
   fflush(stderr);
   exit(exit_code);
 }
 
 
 void Version(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  args.GetReturnValue().Set(v8::String::New(v8::V8::GetVersion()));
+  args.GetReturnValue().Set(
+      v8::String::NewFromUtf8(args.GetIsolate(), v8::V8::GetVersion()));
 }
 
 
 // Reads a file into a v8 string.
-v8::Handle<v8::String> ReadFile(const char* name) {
+v8::Handle<v8::String> ReadFile(v8::Isolate* isolate, const char* name) {
   FILE* file = fopen(name, "rb");
   if (file == NULL) return v8::Handle<v8::String>();
 
   fseek(file, 0, SEEK_END);
   int size = ftell(file);
   rewind(file);
 
   char* chars = new char[size + 1];
   chars[size] = '\0';
   for (int i = 0; i < size;) {
     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);
+  v8::Handle<v8::String> result =
+      v8::String::NewFromUtf8(isolate, chars, v8::String::kNormalString, size);
   delete[] chars;
   return result;
 }
 
 
 // Process remaining command line arguments and execute files
 int RunMain(v8::Isolate* isolate, int argc, char* argv[]) {
   for (int i = 1; i < argc; i++) {
     const char* str = argv[i];
     if (strcmp(str, "--shell") == 0) {
       run_shell = true;
     } else if (strcmp(str, "-f") == 0) {
       // Ignore any -f flags for compatibility with the other stand-
       // alone JavaScript engines.
       continue;
     } else if (strncmp(str, "--", 2) == 0) {
       fprintf(stderr,
               "Warning: unknown flag %s.\nTry --help for options\n", str);
     } else if (strcmp(str, "-e") == 0 && i + 1 < argc) {
       // Execute argument given to -e option directly.
-      v8::Handle<v8::String> file_name = v8::String::New("unnamed");
-      v8::Handle<v8::String> source = v8::String::New(argv[++i]);
+      v8::Handle<v8::String> file_name =
+          v8::String::NewFromUtf8(isolate, "unnamed");
+      v8::Handle<v8::String> source =
+          v8::String::NewFromUtf8(isolate, argv[++i]);
       if (!ExecuteString(isolate, source, file_name, false, true)) return 1;
     } else {
       // Use all other arguments as names of files to load and run.
-      v8::Handle<v8::String> file_name = v8::String::New(str);
-      v8::Handle<v8::String> source = ReadFile(str);
+      v8::Handle<v8::String> file_name = v8::String::NewFromUtf8(isolate, str);
+      v8::Handle<v8::String> source = ReadFile(isolate, str);
       if (source.IsEmpty()) {
         fprintf(stderr, "Error reading '%s'\n", str);
         continue;
       }
       if (!ExecuteString(isolate, source, file_name, false, true)) return 1;
     }
   }
   return 0;
 }
 
 
 // The read-eval-execute loop of the shell.
 void RunShell(v8::Handle<v8::Context> context) {
   fprintf(stderr, "V8 version %s [sample shell]\n", v8::V8::GetVersion());
   static const int kBufferSize = 256;
   // Enter the execution environment before evaluating any code.
   v8::Context::Scope context_scope(context);
-  v8::Local<v8::String> name(v8::String::New("(shell)"));
+  v8::Local<v8::String> name(
+      v8::String::NewFromUtf8(context->GetIsolate(), "(shell)"));
   while (true) {
     char buffer[kBufferSize];
     fprintf(stderr, "> ");
     char* str = fgets(buffer, kBufferSize, stdin);
     if (str == NULL) break;
     v8::HandleScope handle_scope(context->GetIsolate());
     ExecuteString(context->GetIsolate(),
-                  v8::String::New(str),
+                  v8::String::NewFromUtf8(context->GetIsolate(), str),
                   name,
                   true,
                   true);
   }
   fprintf(stderr, "\n");
 }
 
 
 // Executes a string within the current v8 context.
 bool ExecuteString(v8::Isolate* isolate,
@@ skipping 61 matching lines @@
       fprintf(stderr, "^");
     }
     fprintf(stderr, "\n");
     v8::String::Utf8Value stack_trace(try_catch->StackTrace());
     if (stack_trace.length() > 0) {
       const char* stack_trace_string = ToCString(stack_trace);
       fprintf(stderr, "%s\n", stack_trace_string);
     }
   }
 }