Remove usage of deprecated APIs from samples

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 81 matching lines @@
  * fixes this issue.
  */
 
 enum MainCycleType {
   CycleInCpp,
   CycleInJs
 };
 
 const char* ToCString(const v8::String::Utf8Value& value);
 void ReportException(v8::Isolate* isolate, v8::TryCatch* handler);
-v8::Handle<v8::String> ReadFile(const char* name);
+v8::Handle<v8::String> ReadFile(v8::Isolate* isolate, const char* name);
 v8::Handle<v8::String> ReadLine();
 
 void Print(const v8::FunctionCallbackInfo<v8::Value>& args);
 void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args);
 bool RunCppCycle(v8::Handle<v8::Script> script,
                  v8::Local<v8::Context> context,
                  bool report_exceptions);
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
@@ skipping 54 matching lines @@
       support_callback = true;
     } else if (strcmp(str, "--wait-for-connection") == 0) {
       wait_for_connection = true;
     } else if (strcmp(str, "-p") == 0 && i + 1 < argc) {
       port_number = atoi(argv[i + 1]);  // NOLINT
       i++;
 #endif  // ENABLE_DEBUGGER_SUPPORT
     } else if (strncmp(str, "--", 2) == 0) {
       printf("Warning: unknown flag %s.\nTry --help for options\n", str);
     } else if (strcmp(str, "-e") == 0 && i + 1 < argc) {
-      script_source = v8::String::New(argv[i + 1]);
-      script_name = v8::String::New("unnamed");
+      script_source = v8::String::NewFromUtf8(isolate, argv[i + 1]);
+      script_name = v8::String::NewFromUtf8(isolate, "unnamed");
       i++;
       script_param_counter++;
     } else {
       // Use argument as a name of file to load.
-      script_source = ReadFile(str);
-      script_name = v8::String::New(str);
+      script_source = ReadFile(isolate, str);
+      script_name = v8::String::NewFromUtf8(isolate, str);
       if (script_source.IsEmpty()) {
         printf("Error reading '%s'\n", str);
         return 1;
       }
       script_param_counter++;
     }
   }
 
   if (script_param_counter == 0) {
     printf("Script is not specified\n");
     return 1;
   }
   if (script_param_counter != 1) {
     printf("Only one script may be specified\n");
     return 1;
   }
 
   // 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));
 
   if (cycle_type == CycleInJs) {
     // Bind the global 'read_line' function to the C++ Print callback.
-    global->Set(v8::String::New("read_line"),
+    global->Set(v8::String::NewFromUtf8(isolate, "read_line"),
                 v8::FunctionTemplate::New(ReadLine));
   }
 
   // Create a new execution environment containing the built-in
   // functions
   v8::Handle<v8::Context> context = v8::Context::New(isolate, NULL, global);
   // Enter the newly created execution environment.
   v8::Context::Scope context_scope(context);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
@@ skipping 49 matching lines @@
 
 
 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(isolate);
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
-  v8::Handle<v8::String> fun_name = v8::String::New("ProcessLine");
+  v8::Handle<v8::String> fun_name =
+      v8::String::NewFromUtf8(isolate, "ProcessLine");
   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
@@ skipping 40 matching lines @@
 }
 
 
 // Extracts a C string from a V8 Utf8Value.
 const char* ToCString(const v8::String::Utf8Value& value) {
   return *value ? *value : "<string conversion failed>";
 }
 
 
 // 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;
 }
 
 
 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();
@@ skipping 43 matching lines @@
   }
   printf("\n");
   fflush(stdout);
 }
 
 
 // The callback that is invoked by v8 whenever the JavaScript 'read_line'
 // function is called. Reads a string from standard input and returns.
 void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() > 0) {
-    args.GetIsolate()->ThrowException(v8::String::New("Unexpected arguments"));
+    args.GetIsolate()->ThrowException(
+        v8::String::NewFromUtf8(args.GetIsolate(), "Unexpected arguments"));
     return;
   }
   args.GetReturnValue().Set(ReadLine());
 }
 
 
 v8::Handle<v8::String> ReadLine() {
   const int kBufferSize = 1024 + 1;
   char buffer[kBufferSize];
 
   char* res;
   {
 #ifdef ENABLE_DEBUGGER_SUPPORT
     v8::Unlocker unlocker(v8::Isolate::GetCurrent());
 #endif  // ENABLE_DEBUGGER_SUPPORT
     res = fgets(buffer, kBufferSize, stdin);
   }
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
   if (res == NULL) {
-    v8::Handle<v8::Primitive> t = v8::Undefined(v8::Isolate::GetCurrent());
+    v8::Handle<v8::Primitive> t = v8::Undefined(isolate);
     return v8::Handle<v8::String>::Cast(t);
   }
   // Remove newline char
   for (char* pos = buffer; *pos != '\0'; pos++) {
     if (*pos == '\n') {
       *pos = '\0';
       break;
     }
   }
-  return v8::String::New(buffer);
+  return v8::String::NewFromUtf8(isolate, buffer);
 }