Revert r43217, r43215, r43208, r43207, and r43202.

runtime/vm/service.cc

 // Copyright (c) 2013, 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.h"
 
 #include "include/dart_api.h"
 #include "platform/globals.h"
 
 #include "vm/compiler.h"
 #include "vm/coverage.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.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_graph.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/port.h"
@@ skipping 213 matching lines @@
 static void SendRootServiceMessage(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, message, arguments->NativeArgAt(0));
   Service::HandleRootMessage(message);
 }
 
 
-Dart_Port Service::WaitForLoadPort() {
-  MonitorLocker ml(monitor_);
-
-  while (initializing_ && (load_port_ == ILLEGAL_PORT)) {
-    ml.Wait();
-  }
-
-  return load_port_;
-}
-
-
-Dart_Port Service::LoadPort() {
-  MonitorLocker ml(monitor_);
-  return load_port_;
-}
-
-
-void Service::SetLoadPort(Dart_Port port) {
-  MonitorLocker ml(monitor_);
-  load_port_ = port;
-}
-
-
 void Service::SetEventMask(uint32_t mask) {
   event_mask_ = mask;
 }
 
 
 static void SetEventMask(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
@@ skipping 57 matching lines @@
     const SendPort& send_port = SendPort::Handle(SendPort::New(port_id));
     const String& name = String::Handle(String::New(isolate->name()));
     ASSERT(!name.IsNull());
     const Array& args = Array::Handle(Array::New(3));
     ASSERT(!args.IsNull());
     args.SetAt(0, port_int);
     args.SetAt(1, send_port);
     args.SetAt(2, name);
     Object& r = Object::Handle(service_isolate_);
     r = DartEntry::InvokeFunction(register_function_, args);
-    if (FLAG_trace_service) {
-      OS::Print("Isolate %s %" Pd64 " registered with service \n",
-                name.ToCString(),
-                port_id);
-    }
     ASSERT(!r.IsError());
   }
 
  private:
   Function& register_function_;
   Isolate* service_isolate_;
 };
 
 
 static Dart_Port ExtractPort(Isolate* isolate, Dart_Handle receivePort) {
   const ReceivePort& rp = Api::UnwrapReceivePortHandle(isolate, receivePort);
   if (rp.IsNull()) {
     return ILLEGAL_PORT;
   }
   return rp.Id();
 }
 
 
 static void OnStart(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
   {
-    if (FLAG_trace_service) {
-      OS::Print("Booting dart:vmservice library\n");
-    }
     // Boot the dart:vmservice library.
     Dart_EnterScope();
     Dart_Handle url_str =
         Dart_NewStringFromCString(Symbols::Name(Symbols::kDartVMServiceId));
     Dart_Handle library = Dart_LookupLibrary(url_str);
     ASSERT(Dart_IsLibrary(library));
     Dart_Handle result =
         Dart_Invoke(library, Dart_NewStringFromCString("boot"), 0, NULL);
     ASSERT(!Dart_IsError(result));
     Dart_Port port = ExtractPort(isolate, result);
     ASSERT(port != ILLEGAL_PORT);
     Service::set_port(port);
     Dart_ExitScope();
   }
-
   {
-    if (FLAG_trace_service) {
-      OS::Print("Registering running isolates\n");
-    }
     // Register running isolates with service.
     RegisterRunningIsolatesVisitor register_isolates(isolate);
     Isolate::VisitIsolates(&register_isolates);
   }
 }
 
 
 struct VmServiceNativeEntry {
   const char* name;
   int num_arguments;
@@ skipping 25 matching lines @@
   for (intptr_t i = 0; i < n; i++) {
     VmServiceNativeEntry entry = _VmServiceNativeEntries[i];
     if ((strcmp(function_name, entry.name) == 0) &&
         (num_arguments == entry.num_arguments)) {
       return entry.function;
     }
   }
   return NULL;
 }
 
-const char* Service::kServiceIsolateName = "vm-service";
+
 EmbedderServiceHandler* Service::isolate_service_handler_head_ = NULL;
 EmbedderServiceHandler* Service::root_service_handler_head_ = NULL;
 Isolate* Service::service_isolate_ = NULL;
+Dart_LibraryTagHandler Service::embedder_provided_handler_ = NULL;
 Dart_Port Service::port_ = ILLEGAL_PORT;
-Dart_Port Service::load_port_ = ILLEGAL_PORT;
-Monitor* Service::monitor_ = NULL;
-bool Service::initializing_ = true;
 uint32_t Service::event_mask_ = 0;
 
+Isolate* Service::GetServiceIsolate(void* callback_data) {
+  if (service_isolate_ != NULL) {
+    // Already initialized, return service isolate.
+    return service_isolate_;
+  }
+  Dart_ServiceIsolateCreateCalback create_callback =
+    Isolate::ServiceCreateCallback();
+  if (create_callback == NULL) {
+    return NULL;
+  }
+  Isolate::SetCurrent(NULL);
+  char* error = NULL;
+  Isolate* isolate =
+      reinterpret_cast<Isolate*>(create_callback(callback_data, &error));
+  if (isolate == NULL) {
+    return NULL;
+  }
+  StartIsolateScope isolate_scope(isolate);
+  {
+    // Install the dart:vmservice library.
+    StackZone zone(isolate);
+    HANDLESCOPE(isolate);
+    Library& library =
+        Library::Handle(isolate, isolate->object_store()->root_library());
+    // Isolate is empty.
+    ASSERT(library.IsNull());
+    // Grab embedder tag handler.
+    embedder_provided_handler_ = isolate->library_tag_handler();
+    // Temporarily install our own.
+    isolate->set_library_tag_handler(LibraryTagHandler);
+    // Get script resource.
+    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(
+        String::FromUTF8(reinterpret_cast<const uint8_t*>(resource), r));
+    ASSERT(!source_str.IsNull());
+    const String& url_str = String::Handle(Symbols::DartVMService().raw());
+    library ^= Library::LookupLibrary(url_str);
+    ASSERT(library.IsNull());
+    // Setup library.
+    library = Library::New(url_str);
+    library.Register();
+    const Script& script = Script::Handle(
+      isolate, Script::New(url_str, source_str, RawScript::kLibraryTag));
+    library.SetLoadInProgress();
+    Dart_EnterScope();  // Need to enter scope for tag handler.
+    const Error& error = Error::Handle(isolate,
+                                       Compiler::Compile(library, script));
+    ASSERT(error.IsNull());
+    Dart_Handle result = Dart_FinalizeLoading(false);
+    ASSERT(!Dart_IsError(result));
+    Dart_ExitScope();
 
-bool Service::IsServiceIsolateName(const char* name) {
-  ASSERT(name != NULL);
-  return strcmp(name, kServiceIsolateName) == 0;
+    // Install embedder default library tag handler again.
+    isolate->set_library_tag_handler(embedder_provided_handler_);
+    embedder_provided_handler_ = NULL;
+    library.set_native_entry_resolver(VmServiceNativeResolver);
+  }
+  service_isolate_ = reinterpret_cast<Isolate*>(isolate);
+  return service_isolate_;
 }
 
 
 bool Service::SendIsolateStartupMessage() {
   if (!IsRunning()) {
     return false;
   }
   Isolate* isolate = Isolate::Current();
-  if (IsServiceIsolate(isolate)) {
-    return false;
-  }
   ASSERT(isolate != NULL);
   HANDLESCOPE(isolate);
   const String& name = String::Handle(String::New(isolate->name()));
   ASSERT(!name.IsNull());
   const Array& list = Array::Handle(
       MakeServiceControlMessage(Dart_GetMainPortId(),
                                 VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID,
                                 name));
   ASSERT(!list.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
     OS::Print("Isolate %s %" Pd64 " registered with service \n",
               name.ToCString(),
               Dart_GetMainPortId());
   }
   return PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
 bool Service::SendIsolateShutdownMessage() {
   if (!IsRunning()) {
     return false;
   }
   Isolate* isolate = Isolate::Current();
-  if (IsServiceIsolate(isolate)) {
-    return false;
-  }
   ASSERT(isolate != NULL);
   HANDLESCOPE(isolate);
   const String& name = String::Handle(String::New(isolate->name()));
   ASSERT(!name.IsNull());
   const Array& list = Array::Handle(
       MakeServiceControlMessage(Dart_GetMainPortId(),
                                 VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID,
                                 name));
   ASSERT(!list.IsNull());
   uint8_t* data = NULL;
@@ skipping 25 matching lines @@
       const uint8_t* str = Resources::Resource(i);
       intptr_t length = Resources::Length(i);
       return Dart_NewStringFromUTF8(str, length);
     }
     i++;
   }
   return Dart_Null();
 }
 
 
-Dart_Handle Service::LibraryTagHandler(Dart_LibraryTag tag,
-                                       Dart_Handle library,
+Dart_Handle Service::LibraryTagHandler(Dart_LibraryTag tag, Dart_Handle library,
                                        Dart_Handle url) {
   if (!Dart_IsLibrary(library)) {
     return Dart_NewApiError("not a library");
   }
   if (!Dart_IsString(url)) {
     return Dart_NewApiError("url is not a string");
   }
   const char* url_string = NULL;
   Dart_Handle result = Dart_StringToCString(url, &url_string);
   if (Dart_IsError(result)) {
     return result;
   }
   if (tag == Dart_kImportTag) {
-    OS::Print("Attempting to import %s\n", url_string);
-    return Dart_NewApiError("Unable to import module as no library tag "
-                            "is available");
+    // Embedder handles all requests for external libraries.
+    if (embedder_provided_handler_ == NULL) {
+      return Dart_NewApiError("Unable to import module as no library tag "
+                              "handler has been provided by embedder");
+    }
+    return embedder_provided_handler_(tag, library, url);
   }
   ASSERT((tag == Dart_kSourceTag) || (tag == Dart_kCanonicalizeUrl));
   if (tag == Dart_kCanonicalizeUrl) {
     // url is already canonicalized.
     return url;
   }
   Dart_Handle source = GetSource(url_string);
   if (Dart_IsError(source)) {
     return source;
   }
   return Dart_LoadSource(library, url, source, 0, 0);
 }
 
 
-void Service::MaybeInjectVMServiceLibrary(Isolate* isolate) {
-  if (service_isolate_ != NULL) {
-    // Service isolate already exists.
-    return;
-  }
-  if (!Service::IsServiceIsolateName(isolate->name())) {
-    // Not service isolate.
-    return;
-  }
-  service_isolate_ = isolate;
-  ASSERT(isolate != NULL);
-  StackZone zone(isolate);
-  HANDLESCOPE(isolate);
-
-  // Verify that isolate has no root library.
-  Library& library =
-      Library::Handle(isolate, isolate->object_store()->root_library());
-  ASSERT(library.IsNull());
-
-  // Verify that isolate doesn't have the dart:vmservice library.
-  const String& url_str = String::Handle(Symbols::DartVMService().raw());
-  library ^= Library::LookupLibrary(url_str);
-  ASSERT(library.IsNull());
-
-  // Register dart:vmservice library.
-  library = Library::New(url_str);
-  library.Register();
-  library.set_native_entry_resolver(VmServiceNativeResolver);
-
-  // Temporarily install our library tag handler.
-  isolate->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(
-      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));
-
-  // Compile script.
-  Dart_EnterScope();  // Need to enter scope for tag handler.
-  library.SetLoadInProgress();
-  const Error& error = Error::Handle(isolate,
-                                     Compiler::Compile(library, script));
-  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);
-}
-
-
-void Service::FinishedInitializing() {
-  MonitorLocker ml(monitor_);
-  initializing_ = false;
-  ml.NotifyAll();
-}
-
-
-static void ShutdownIsolate(uword parameter) {
-  Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
-  {
-    // 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);
-    StackZone zone(isolate);
-    HandleScope handle_scope(isolate);
-    Error& error = Error::Handle();
-    error = isolate->object_store()->sticky_error();
-    if (!error.IsNull()) {
-      OS::PrintErr("Service shutting down: %s\n", error.ToErrorCString());
-    }
-    Dart::RunShutdownCallback();
-  }
-  {
-    // Shut the isolate down.
-    SwitchIsolateScope switch_scope(isolate);
-    Dart::ShutdownIsolate();
-  }
-}
-
-
-class RunServiceTask : public ThreadPool::Task {
- public:
-  virtual void Run() {
-    ASSERT(Isolate::Current() == NULL);
-
-    Dart_IsolateCreateCallback create_callback = Isolate::CreateCallback();
-    if (create_callback == NULL) {
-      Service::FinishedInitializing();
-      return;
-    }
-
-    char* error = NULL;
-    Isolate* isolate =
-        reinterpret_cast<Isolate*>(create_callback(Service::kServiceIsolateName,
-                                                   NULL,
-                                                   NULL,
-                                                   NULL,
-                                                   &error));
-    Isolate::SetCurrent(NULL);
-
-    if (isolate == NULL) {
-      OS::PrintErr("Service startup error: %s\n", error);
-      Service::FinishedInitializing();
-      return;
-    }
-
-    RunMain(isolate);
-
-    Service::FinishedInitializing();
-
-    isolate->message_handler()->Run(Dart::thread_pool(),
-                                    NULL,
-                                    ShutdownIsolate,
-                                    reinterpret_cast<uword>(isolate));
-  }
-
- protected:
-  void RunMain(Isolate* isolate) {
-    StartIsolateScope iso_scope(isolate);
-    StackZone zone(isolate);
-    HANDLESCOPE(isolate);
-    // Invoke main which will return the loadScriptPort.
-    const Library& root_library =
-        Library::Handle(isolate, isolate->object_store()->root_library());
-    if (root_library.IsNull()) {
-      // Service isolate is not supported by embedder.
-      return;
-    }
-    ASSERT(!root_library.IsNull());
-    const String& entry_name = String::Handle(isolate, String::New("main"));
-    ASSERT(!entry_name.IsNull());
-    const Function& entry =
-        Function::Handle(isolate,
-                         root_library.LookupFunctionAllowPrivate(entry_name));
-    if (entry.IsNull()) {
-      // Service isolate is not supported by embedder.
-      return;
-    }
-    ASSERT(!entry.IsNull());
-    const Object& result =
-        Object::Handle(isolate,
-                       DartEntry::InvokeFunction(entry,
-                                                 Object::empty_array()));
-    ASSERT(!result.IsNull());
-    if (result.IsError()) {
-      // Service isolate did not initialize properly.
-      return;
-    }
-    ASSERT(result.IsReceivePort());
-    const ReceivePort& rp = ReceivePort::Cast(result);
-    Service::SetLoadPort(rp.Id());
-  }
-};
-
-
-void Service::RunService() {
-  ASSERT(monitor_ == NULL);
-  monitor_ = new Monitor();
-  ASSERT(monitor_ != NULL);
-  Dart::thread_pool()->Run(new RunServiceTask());
-}
-
 // A handler for a per-isolate request.
 //
 // If a handler returns true, the reply is complete and ready to be
 // posted.  If a handler returns false, then it is responsible for
 // posting the reply (this can be used for asynchronous delegation of
 // the response handling).
 typedef bool (*IsolateMessageHandler)(Isolate* isolate, JSONStream* stream);
 
 struct IsolateMessageHandlerEntry {
   const char* command;
@@ skipping 2173 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart