Make d8 stop using to-be-deprecated APIs

BUG=v8:4134
LOG=n
R=yangguo@chromium.org

Review URL: https://codereview.chromium.org/1239053004

Cr-Commit-Position: refs/heads/master@{#29726}

src/d8-debug.cc

@@ -29,24 +29,30 @@ void HandleDebugEvent(const Debug::EventDetails& event_details) {
 
   // Get the toJSONProtocol function on the event and get the JSON format.
   Local<String> to_json_fun_name =
-      String::NewFromUtf8(isolate, "toJSONProtocol");
-  Handle<Object> event_data = event_details.GetEventData();
+      String::NewFromUtf8(isolate, "toJSONProtocol", NewStringType::kNormal)
+          .ToLocalChecked();
+  Local<Object> event_data = event_details.GetEventData();
   Local<Function> to_json_fun =
-      Local<Function>::Cast(event_data->Get(to_json_fun_name));
-  Local<Value> event_json = to_json_fun->Call(event_data, 0, NULL);
-  if (try_catch.HasCaught()) {
+      Local<Function>::Cast(event_data->Get(isolate->GetCurrentContext(),
+                                            to_json_fun_name).ToLocalChecked());
+  Local<Value> event_json;
+  if (!to_json_fun->Call(isolate->GetCurrentContext(), event_data, 0, NULL)
+           .ToLocal(&event_json)) {
     Shell::ReportException(isolate, &try_catch);
     return;
   }
 
   // Print the event details.
-  Handle<Object> details =
-      Shell::DebugMessageDetails(isolate, Handle<String>::Cast(event_json));
+  Local<Object> details =
+      Shell::DebugMessageDetails(isolate, Local<String>::Cast(event_json));
   if (try_catch.HasCaught()) {
     Shell::ReportException(isolate, &try_catch);
     return;
   }
-  String::Utf8Value str(details->Get(String::NewFromUtf8(isolate, "text")));
+  String::Utf8Value str(
+      details->Get(isolate->GetCurrentContext(),
+                   String::NewFromUtf8(isolate, "text", NewStringType::kNormal)
+                       .ToLocalChecked()).ToLocalChecked());
   if (str.length() == 0) {
     // Empty string is used to signal not to process this event.
     return;
@@ -55,15 +61,18 @@ void HandleDebugEvent(const Debug::EventDetails& event_details) {
 
   // Get the debug command processor.
   Local<String> fun_name =
-      String::NewFromUtf8(isolate, "debugCommandProcessor");
-  Handle<Object> exec_state = event_details.GetExecutionState();
-  Local<Function> fun = Local<Function>::Cast(exec_state->Get(fun_name));
-  Local<Object> cmd_processor =
-      Local<Object>::Cast(fun->Call(exec_state, 0, NULL));
-  if (try_catch.HasCaught()) {
+      String::NewFromUtf8(isolate, "debugCommandProcessor",
+                          NewStringType::kNormal).ToLocalChecked();
+  Local<Object> exec_state = event_details.GetExecutionState();
+  Local<Function> fun = Local<Function>::Cast(
+      exec_state->Get(isolate->GetCurrentContext(), fun_name).ToLocalChecked());
+  Local<Value> cmd_processor_value;
+  if (!fun->Call(isolate->GetCurrentContext(), exec_state, 0, NULL)
+           .ToLocal(&cmd_processor_value)) {
     Shell::ReportException(isolate, &try_catch);
     return;
   }
+  Local<Object> cmd_processor = Local<Object>::Cast(cmd_processor_value);
 
   static const int kBufferSize = 256;
   bool running = false;
@@ -79,8 +88,9 @@ void HandleDebugEvent(const Debug::EventDetails& event_details) {
     TryCatch try_catch(isolate);
 
     // Convert the debugger command to a JSON debugger request.
-    Handle<Value> request = Shell::DebugCommandToJSONRequest(
-        isolate, String::NewFromUtf8(isolate, command));
+    Local<Value> request = Shell::DebugCommandToJSONRequest(
+        isolate, String::NewFromUtf8(isolate, command, NewStringType::kNormal)
+                     .ToLocalChecked());
     if (try_catch.HasCaught()) {
       Shell::ReportException(isolate, &try_catch);
       continue;
@@ -92,39 +102,50 @@ void HandleDebugEvent(const Debug::EventDetails& event_details) {
       continue;
     }
 
-    Handle<String> fun_name;
-    Handle<Function> fun;
+    Local<String> fun_name;
+    Local<Function> fun;
     // All the functions used below take one argument.
     static const int kArgc = 1;
-    Handle<Value> args[kArgc];
+    Local<Value> args[kArgc];
 
     // Invoke the JavaScript to convert the debug command line to a JSON
     // request, invoke the JSON request and convert the JSON respose to a text
     // representation.
-    fun_name = String::NewFromUtf8(isolate, "processDebugRequest");
-    fun = Handle<Function>::Cast(cmd_processor->Get(fun_name));
+    fun_name = String::NewFromUtf8(isolate, "processDebugRequest",
+                                   NewStringType::kNormal).ToLocalChecked();
+    fun = Local<Function>::Cast(cmd_processor->Get(isolate->GetCurrentContext(),
+                                                   fun_name).ToLocalChecked());
     args[0] = request;
-    Handle<Value> response_val = fun->Call(cmd_processor, kArgc, args);
-    if (try_catch.HasCaught()) {
+    Local<Value> response_val;
+    if (!fun->Call(isolate->GetCurrentContext(), cmd_processor, kArgc, args)
+             .ToLocal(&response_val)) {
       Shell::ReportException(isolate, &try_catch);
       continue;
     }
-    Handle<String> response = Handle<String>::Cast(response_val);
+    Local<String> response = Local<String>::Cast(response_val);
 
     // Convert the debugger response into text details and the running state.
-    Handle<Object> response_details =
+    Local<Object> response_details =
         Shell::DebugMessageDetails(isolate, response);
     if (try_catch.HasCaught()) {
       Shell::ReportException(isolate, &try_catch);
       continue;
     }
     String::Utf8Value text_str(
-        response_details->Get(String::NewFromUtf8(isolate, "text")));
+        response_details->Get(isolate->GetCurrentContext(),
+                              String::NewFromUtf8(isolate, "text",
+                                                  NewStringType::kNormal)
+                                  .ToLocalChecked()).ToLocalChecked());
     if (text_str.length() > 0) {
       printf("%s\n", *text_str);
     }
-    running = response_details->Get(String::NewFromUtf8(isolate, "running"))
-                  ->ToBoolean(isolate)
+    running = response_details->Get(isolate->GetCurrentContext(),
+                                    String::NewFromUtf8(isolate, "running",
+                                                        NewStringType::kNormal)
+                                        .ToLocalChecked())
+                  .ToLocalChecked()
+                  ->ToBoolean(isolate->GetCurrentContext())
+                  .ToLocalChecked()
                   ->Value();
   }
 }

src/d8-readline.cc

@@ -25,7 +25,7 @@ namespace v8 {
 class ReadLineEditor: public LineEditor {
  public:
   ReadLineEditor() : LineEditor(LineEditor::READLINE, "readline") { }
-  virtual Handle<String> Prompt(const char* prompt);
+  virtual Local<String> Prompt(const char* prompt);
   virtual bool Open(Isolate* isolate);
   virtual bool Close();
   virtual void AddHistory(const char* str);
@@ -80,10 +80,10 @@ bool ReadLineEditor::Close() {
 }
 
 
-Handle<String> ReadLineEditor::Prompt(const char* prompt) {
+Local<String> ReadLineEditor::Prompt(const char* prompt) {
   char* result = NULL;
   result = readline(prompt);
-  if (result == NULL) return Handle<String>();
+  if (result == NULL) return Local<String>();
   AddHistory(result);
   return String::NewFromUtf8(isolate_, result);
 }
@@ -118,10 +118,10 @@ char** ReadLineEditor::AttemptedCompletion(const char* text,
 
 char* ReadLineEditor::CompletionGenerator(const char* text, int state) {
   static unsigned current_index;
-  static Persistent<Array> current_completions;
+  static Global<Array> current_completions;
   Isolate* isolate = read_line_editor.isolate_;
   HandleScope scope(isolate);
-  Handle<Array> completions;
+  Local<Array> completions;
   if (state == 0) {
     Local<String> full_text = String::NewFromUtf8(isolate,
                                                   rl_line_buffer,
@@ -136,8 +136,8 @@ char* ReadLineEditor::CompletionGenerator(const char* text, int state) {
     completions = Local<Array>::New(isolate, current_completions);
   }
   if (current_index < completions->Length()) {
-    Handle<Integer> index = Integer::New(isolate, current_index);
-    Handle<Value> str_obj = completions->Get(index);
+    Local<Integer> index = Integer::New(isolate, current_index);
+    Local<Value> str_obj = completions->Get(index);
     current_index++;
     String::Utf8Value str(str_obj);
     return strdup(*str);

src/d8-windows.cc

@@ -8,8 +8,7 @@
 namespace v8 {
 
 
-void Shell::AddOSMethods(Isolate* isolate, Handle<ObjectTemplate> os_templ) {
-}
+void Shell::AddOSMethods(Isolate* isolate, Local<ObjectTemplate> os_templ) {}
 
 
 }  // namespace v8

src/d8.gyp

@@ -53,6 +53,10 @@
         'startup-data-util.h',
         'startup-data-util.cc'
       ],
+      'defines': [
+        # TODO(jochen): Remove again after this is globally turned on.
+        'V8_IMMINENT_DEPRECATION_WARNINGS',
+      ],
       'conditions': [
         [ 'want_separate_host_toolset==1', {
           'toolsets': [ '<(v8_toolset_for_d8)', ],

src/d8.h

@@ -99,7 +99,7 @@ class LineEditor {
   LineEditor(Type type, const char* name);
   virtual ~LineEditor() { }
 
-  virtual Handle<String> Prompt(const char* prompt) = 0;
+  virtual Local<String> Prompt(const char* prompt) = 0;
   virtual bool Open(Isolate* isolate) { return true; }
   virtual bool Close() { return true; }
   virtual void AddHistory(const char* str) { }
@@ -163,7 +163,7 @@ class SourceGroup {
 #endif  // !V8_SHARED
 
   void ExitShell(int exit_code);
-  Handle<String> ReadFile(Isolate* isolate, const char* name);
+  Local<String> ReadFile(Isolate* isolate, const char* name);
 
   const char** argv_;
   int begin_offset_;
@@ -349,17 +349,17 @@ class Shell : public i::AllStatic {
  public:
   enum SourceType { SCRIPT, MODULE };
 
-  static Local<Script> CompileString(
+  static MaybeLocal<Script> CompileString(
       Isolate* isolate, Local<String> source, Local<Value> name,
       v8::ScriptCompiler::CompileOptions compile_options,
       SourceType source_type);
-  static bool ExecuteString(Isolate* isolate, Handle<String> source,
-                            Handle<Value> name, bool print_result,
+  static bool ExecuteString(Isolate* isolate, Local<String> source,
+                            Local<Value> name, bool print_result,
                             bool report_exceptions,
                             SourceType source_type = SCRIPT);
   static const char* ToCString(const v8::String::Utf8Value& value);
   static void ReportException(Isolate* isolate, TryCatch* try_catch);
-  static Handle<String> ReadFile(Isolate* isolate, const char* name);
+  static Local<String> ReadFile(Isolate* isolate, const char* name);
   static Local<Context> CreateEvaluationContext(Isolate* isolate);
   static int RunMain(Isolate* isolate, int argc, char* argv[]);
   static int Main(int argc, char* argv[]);
@@ -371,8 +371,8 @@ class Shell : public i::AllStatic {
 #ifndef V8_SHARED
   // TODO(binji): stupid implementation for now. Is there an easy way to hash an
   // object for use in i::HashMap? By pointer?
-  typedef i::List<Handle<Object>> ObjectList;
-  static bool SerializeValue(Isolate* isolate, Handle<Value> value,
+  typedef i::List<Local<Object>> ObjectList;
+  static bool SerializeValue(Isolate* isolate, Local<Value> value,
                              const ObjectList& to_transfer,
                              ObjectList* seen_objects,
                              SerializationData* out_data);
@@ -380,9 +380,8 @@ class Shell : public i::AllStatic {
                                             const SerializationData& data,
                                             int* offset);
   static void CleanupWorkers();
-  static Handle<Array> GetCompletions(Isolate* isolate,
-                                      Handle<String> text,
-                                      Handle<String> full);
+  static Local<Array> GetCompletions(Isolate* isolate, Local<String> text,
+                                     Local<String> full);
   static int* LookupCounter(const char* name);
   static void* CreateHistogram(const char* name,
                                int min,
@@ -392,9 +391,9 @@ class Shell : public i::AllStatic {
   static void MapCounters(v8::Isolate* isolate, const char* name);
 
   static Local<Object> DebugMessageDetails(Isolate* isolate,
-                                           Handle<String> message);
+                                           Local<String> message);
   static Local<Value> DebugCommandToJSONRequest(Isolate* isolate,
-                                                Handle<String> command);
+                                                Local<String> command);
 
   static void PerformanceNow(const v8::FunctionCallbackInfo<v8::Value>& args);
 #endif  // !V8_SHARED
@@ -419,7 +418,7 @@ class Shell : public i::AllStatic {
   static void Version(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Read(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ReadBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static Handle<String> ReadFromStdin(Isolate* isolate);
+  static Local<String> ReadFromStdin(Isolate* isolate);
   static void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args) {
     args.GetReturnValue().Set(ReadFromStdin(args.GetIsolate()));
   }
@@ -464,17 +463,17 @@ class Shell : public i::AllStatic {
   static void RemoveDirectory(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void AddOSMethods(v8::Isolate* isolate,
-                           Handle<ObjectTemplate> os_template);
+                           Local<ObjectTemplate> os_template);
 
   static const char* kPrompt;
   static ShellOptions options;
   static ArrayBuffer::Allocator* array_buffer_allocator;
 
  private:
-  static Persistent<Context> evaluation_context_;
+  static Global<Context> evaluation_context_;
   static base::OnceType quit_once_;
 #ifndef V8_SHARED
-  static Persistent<Context> utility_context_;
+  static Global<Context> utility_context_;
   static CounterMap* counter_map_;
   // We statically allocate a set of local counters to be used if we
   // don't want to store the stats in a memory-mapped file
@@ -496,7 +495,7 @@ class Shell : public i::AllStatic {
   static void InitializeDebugger(Isolate* isolate);
   static void RunShell(Isolate* isolate);
   static bool SetOptions(int argc, char* argv[]);
-  static Handle<ObjectTemplate> CreateGlobalTemplate(Isolate* isolate);
+  static Local<ObjectTemplate> CreateGlobalTemplate(Isolate* isolate);
 };