- Remove deprecated StackZone constructor with Isolate parameter.

runtime/vm/service_isolate.cc

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/service_isolate.h"
 
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/native_entry.h"
 #include "vm/native_arguments.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/service.h"
 #include "vm/symbols.h"
 #include "vm/thread_pool.h"
 
 namespace dart {
 
+#define Z (T->zone())
+
+
 DEFINE_FLAG(bool, trace_service, false, "Trace VM service requests.");
 DEFINE_FLAG(bool, trace_service_pause_events, false,
             "Trace VM service isolate pause events.");
 
 struct ResourcesEntry {
   const char* path_;
   const char* resource_;
   int length_;
 };
 
@@ skipping 484 matching lines @@
     origin_ = ILLEGAL_PORT;
   }
 }
 
 void ServiceIsolate::SetLoadPort(Dart_Port port) {
   MonitorLocker ml(monitor_);
   load_port_ = port;
 }
 
 
-void ServiceIsolate::MaybeInjectVMServiceLibrary(Isolate* isolate) {
-  Thread* thread = Thread::Current();
-  ASSERT(isolate == thread->isolate());
-  ASSERT(isolate != NULL);
-  ASSERT(isolate->name() != NULL);
-  if (!ServiceIsolate::NameEquals(isolate->name())) {
+void ServiceIsolate::MaybeInjectVMServiceLibrary(Isolate* I) {
+  Thread* T = Thread::Current();
+  ASSERT(I == T->isolate());
+  ASSERT(I != NULL);
+  ASSERT(I->name() != NULL);
+  if (!ServiceIsolate::NameEquals(I->name())) {
     // Not service isolate.
     return;
   }
   if (Exists()) {
     // Service isolate already exists.
     return;
   }
-  SetServiceIsolate(isolate);
+  SetServiceIsolate(I);
 
-  StackZone zone(isolate);
-  HANDLESCOPE(thread);
+  StackZone zone(T);
+  HANDLESCOPE(T);
 
   // Register dart:vmservice library.
-  const String& url_str = String::Handle(Symbols::DartVMService().raw());
-  const Library& library = Library::Handle(Library::New(url_str));
+  const String& url_str = String::Handle(Z, Symbols::DartVMService().raw());

[srdjan, 2015/09/02 22:24:09]

ditto

[Ivan Posva, 2015/09/02 22:59:26]

ditto

+  const Library& library = Library::Handle(Z, Library::New(url_str));
   library.Register();
   library.set_native_entry_resolver(ServiceNativeResolver);
 
   // Temporarily install our library tag handler.
-  isolate->set_library_tag_handler(LibraryTagHandler);
+  I->set_library_tag_handler(LibraryTagHandler);
 
   // Get script source.
   const char* resource = NULL;
   const char* path = "/vmservice.dart";
   intptr_t r = Resources::ResourceLookup(path, &resource);
   ASSERT(r != Resources::kNoSuchInstance);
   ASSERT(resource != NULL);
-  const String& source_str = String::Handle(
+  const String& source_str = String::Handle(Z,
       String::FromUTF8(reinterpret_cast<const uint8_t*>(resource), r));
   ASSERT(!source_str.IsNull());
-  const Script& script = Script::Handle(
-    isolate, Script::New(url_str, source_str, RawScript::kLibraryTag));
+  const Script& script = Script::Handle(Z,
+      Script::New(url_str, source_str, RawScript::kLibraryTag));
 
   // Compile script.
   Dart_EnterScope();  // Need to enter scope for tag handler.
   library.SetLoadInProgress();
-  const Error& error = Error::Handle(isolate,
-                                     Compiler::Compile(library, script));
+  const Error& error = Error::Handle(Z, Compiler::Compile(library, script));
   if (!error.IsNull()) {
     OS::PrintErr("vm-service: Isolate creation error: %s\n",
           error.ToErrorCString());
   }
   ASSERT(error.IsNull());
   Dart_Handle result = Dart_FinalizeLoading(false);
   ASSERT(!Dart_IsError(result));
   Dart_ExitScope();
 
   // Uninstall our library tag handler.
-  isolate->set_library_tag_handler(NULL);
+  I->set_library_tag_handler(NULL);
 }
 
 
-void ServiceIsolate::ConstructExitMessageAndCache(Isolate* isolate) {
+void ServiceIsolate::ConstructExitMessageAndCache(Isolate* I) {
   // Construct and cache exit message here so we can send it without needing an
   // isolate.
-  StartIsolateScope iso_scope(isolate);
-  Thread* thread = Thread::Current();
-  ASSERT(isolate == thread->isolate());
-  ASSERT(isolate != NULL);
-  StackZone zone(isolate);
-  HANDLESCOPE(thread);
+  StartIsolateScope iso_scope(I);
+  Thread* T = Thread::Current();
+  ASSERT(I == T->isolate());
+  ASSERT(I != NULL);
+  StackZone zone(T);
+  HANDLESCOPE(T);
   ASSERT(exit_message_ == NULL);
   ASSERT(exit_message_length_ == 0);
-  const Array& list = Array::Handle(MakeServiceExitMessage());
+  const Array& list = Array::Handle(Z, MakeServiceExitMessage());
   ASSERT(!list.IsNull());
   MessageWriter writer(&exit_message_, &allocator, false);
   writer.WriteMessage(list);
   exit_message_length_ = writer.BytesWritten();
   ASSERT(exit_message_ != NULL);
   ASSERT(exit_message_length_ != 0);
 }
 
 
 void ServiceIsolate::FinishedExiting() {
@@ skipping 55 matching lines @@
     ServiceIsolate::FinishedInitializing();
 
     isolate->message_handler()->Run(Dart::thread_pool(),
                                     NULL,
                                     ShutdownIsolate,
                                     reinterpret_cast<uword>(isolate));
   }
 
  protected:
   static void ShutdownIsolate(uword parameter) {
-    Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
-    ASSERT(ServiceIsolate::IsServiceIsolate(isolate));
+    Isolate* I = reinterpret_cast<Isolate*>(parameter);
+    ASSERT(ServiceIsolate::IsServiceIsolate(I));
     {
       // Print the error if there is one.  This may execute dart code to
       // print the exception object, so we need to use a StartIsolateScope.
-      StartIsolateScope start_scope(isolate);
-      Thread* thread = Thread::Current();
-      ASSERT(isolate == thread->isolate());
-      StackZone zone(isolate);
-      HandleScope handle_scope(thread);
-      Error& error = Error::Handle();
-      error = isolate->object_store()->sticky_error();
+      StartIsolateScope start_scope(I);
+      Thread* T = Thread::Current();
+      ASSERT(I == T->isolate());
+      StackZone zone(T);
+      HandleScope handle_scope(T);
+      Error& error = Error::Handle(Z);
+      error = I->object_store()->sticky_error();
       if (!error.IsNull()) {
         OS::PrintErr("vm-service: Error: %s\n", error.ToErrorCString());
       }
       Dart::RunShutdownCallback();
     }
     {
       // Shut the isolate down.
-      SwitchIsolateScope switch_scope(isolate);
+      SwitchIsolateScope switch_scope(I);
       Dart::ShutdownIsolate();
     }
     ServiceIsolate::SetServiceIsolate(NULL);
     ServiceIsolate::SetServicePort(ILLEGAL_PORT);
     if (FLAG_trace_service) {
       OS::Print("vm-service: Shutdown.\n");
     }
     ServiceIsolate::FinishedExiting();
   }
 
-  void RunMain(Isolate* isolate) {
-    StartIsolateScope iso_scope(isolate);
-    Thread* thread = Thread::Current();
-    ASSERT(isolate == thread->isolate());
-    StackZone zone(isolate);
-    HANDLESCOPE(thread);
+  void RunMain(Isolate* I) {
+    StartIsolateScope iso_scope(I);
+    Thread* T = Thread::Current();
+    ASSERT(I == T->isolate());
+    StackZone zone(T);
+    HANDLESCOPE(T);
     // Invoke main which will return the loadScriptPort.
-    const Library& root_library =
-        Library::Handle(isolate, isolate->object_store()->root_library());
+    const Library& root_library = Library::Handle(Z,
+        I->object_store()->root_library());
     if (root_library.IsNull()) {
       if (FLAG_trace_service) {
         OS::Print("vm-service: Embedder did not install a script.");
       }
       // Service isolate is not supported by embedder.
       return;
     }
     ASSERT(!root_library.IsNull());
-    const String& entry_name = String::Handle(isolate, String::New("main"));
+    const String& entry_name = String::Handle(Z, String::New("main"));
     ASSERT(!entry_name.IsNull());
-    const Function& entry =
-        Function::Handle(isolate,
-                         root_library.LookupFunctionAllowPrivate(entry_name));
+    const Function& entry = Function::Handle(Z,
+        root_library.LookupFunctionAllowPrivate(entry_name));
     if (entry.IsNull()) {
       // Service isolate is not supported by embedder.
       if (FLAG_trace_service) {
         OS::Print("vm-service: Embedder did not provide a main function.");
       }
       return;
     }
     ASSERT(!entry.IsNull());
-    const Object& result =
-        Object::Handle(isolate,
-                       DartEntry::InvokeFunction(entry,
-                                                 Object::empty_array()));
+    const Object& result = Object::Handle(Z,
+        DartEntry::InvokeFunction(entry, Object::empty_array()));
     ASSERT(!result.IsNull());
     if (result.IsError()) {
       // Service isolate did not initialize properly.
       if (FLAG_trace_service) {
         const Error& error = Error::Cast(result);
         OS::Print("vm-service: Calling main resulted in an error: %s",
                   error.ToErrorCString());
       }
       return;
     }
@@ skipping 73 matching lines @@
     return result;
   }
   Dart_Handle source = GetSource(url_string);
   if (Dart_IsError(source)) {
     return source;
   }
   return Dart_LoadSource(library, url, source, 0, 0);
 }
 
 }  // namespace dart