Do not register service isolate descendants with service

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"
@@ skipping 131 matching lines @@
   const Integer& code_int = Integer::Handle(Integer::New(code));
   list.SetAt(0, code_int);
   return list.raw();
 }
 
 
 const char* ServiceIsolate::kName = "vm-service";
 Isolate* ServiceIsolate::isolate_ = NULL;
 Dart_Port ServiceIsolate::port_ = ILLEGAL_PORT;
 Dart_Port ServiceIsolate::load_port_ = ILLEGAL_PORT;
+Dart_Port ServiceIsolate::origin_ = ILLEGAL_PORT;
 Dart_IsolateCreateCallback ServiceIsolate::create_callback_ = NULL;
 uint8_t* ServiceIsolate::exit_message_ = NULL;
 intptr_t ServiceIsolate::exit_message_length_ = 0;
 Monitor* ServiceIsolate::monitor_ = NULL;
 bool ServiceIsolate::initializing_ = true;
 bool ServiceIsolate::shutting_down_ = false;
 
 
 class RegisterRunningIsolatesVisitor : public IsolateVisitor {
  public:
@@ skipping 12 matching lines @@
     const String& function_name =
         String::Handle(String::New("_registerIsolate"));
     ASSERT(!function_name.IsNull());
     register_function_ = library.LookupFunctionAllowPrivate(function_name);
     ASSERT(!register_function_.IsNull());
   }
 
   virtual void VisitIsolate(Isolate* isolate) {
     ASSERT(ServiceIsolate::IsServiceIsolate(Isolate::Current()));
     if (ServiceIsolate::IsServiceIsolate(isolate) ||
-        (isolate == Dart::vm_isolate())) {
-      // We do not register the service or vm isolate.
+        (isolate == Dart::vm_isolate()) ||
+        (isolate->origin_id() == ServiceIsolate::Origin())) {

[turnidge, 2015/04/01 19:57:34]

Can this whole test get replaces by ServiceIsolate:IsServiceIsolateBlah?

[Cutch, 2015/04/01 20:19:04]

Done.

+      // We do not register the service (and descendants) or the vm-isolate.
       return;
     }
     // Setup arguments for call.
     Dart_Port port_id = isolate->main_port();
     const Integer& port_int = Integer::Handle(Integer::New(port_id));
     ASSERT(!port_int.IsNull());
     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));
@@ skipping 78 matching lines @@
       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);
       ServiceIsolate::SetServicePort(port);
+      ServiceIsolate::SetOrigin(isolate->origin_id());
       Dart_ExitScope();
     }
 
     {
       if (FLAG_trace_service) {
         OS::Print("vm-service: Registering running isolates.\n");
       }
       // Register running isolates with service.
       RegisterRunningIsolatesVisitor register_isolates(isolate);
       Isolate::VisitIsolates(&register_isolates);
@@ skipping 76 matching lines @@
   return (port_ != ILLEGAL_PORT) && (isolate_ != NULL);
 }
 
 
 bool ServiceIsolate::IsServiceIsolate(Isolate* isolate) {
   MonitorLocker ml(monitor_);
   return isolate == isolate_;
 }
 
 
+bool ServiceIsolate::IsServiceIsolateDescendant(Isolate* isolate) {
+  MonitorLocker ml(monitor_);
+  return isolate->origin_id() == origin_;
+}
+
+
 Dart_Port ServiceIsolate::Port() {
   MonitorLocker ml(monitor_);
   return port_;
 }
 
+Dart_Port ServiceIsolate::Origin() {
+  MonitorLocker ml(monitor_);
+  return origin_;
+}
+
 
 Dart_Port ServiceIsolate::WaitForLoadPort() {
   MonitorLocker ml(monitor_);
 
   while (initializing_ && (load_port_ == ILLEGAL_PORT)) {
     ml.Wait();
   }
 
   return load_port_;
 }
 
 
 Dart_Port ServiceIsolate::LoadPort() {
   MonitorLocker ml(monitor_);
   return load_port_;
 }
 
 
 bool ServiceIsolate::SendIsolateStartupMessage() {
   if (!IsRunning()) {
     return false;
   }
   Isolate* isolate = Isolate::Current();
-  if (IsServiceIsolate(isolate)) {
+  if (IsServiceIsolate(isolate) || IsServiceIsolateDescendant(isolate)) {

[turnidge, 2015/04/01 19:57:34]

Collapse and ditto below.

[Cutch, 2015/04/01 20:19:04]

Done.

     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));
@@ skipping 10 matching lines @@
   return PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
 bool ServiceIsolate::SendIsolateShutdownMessage() {
   if (!IsRunning()) {
     return false;
   }
   Isolate* isolate = Isolate::Current();
-  if (IsServiceIsolate(isolate)) {
+  if (IsServiceIsolate(isolate) || IsServiceIsolateDescendant(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));
@@ skipping 22 matching lines @@
   if (FLAG_trace_service) {
     OS::Print("vm-service: sending service exit message.\n");
   }
   PortMap::PostMessage(new Message(port_,
                                    exit_message_,
                                    exit_message_length_,
                                    Message::kNormalPriority));
 }
 
 
+void ServiceIsolate::SetOrigin(Dart_Port origin) {
+  MonitorLocker ml(monitor_);
+  origin_ = origin;
+}
+
+
 void ServiceIsolate::SetServicePort(Dart_Port port) {
   MonitorLocker ml(monitor_);
   port_ = port;
 }
 
 
 void ServiceIsolate::SetServiceIsolate(Isolate* isolate) {
   MonitorLocker ml(monitor_);
   isolate_ = isolate;
   if (isolate_ != NULL) {
@@ skipping 11 matching lines @@
   ASSERT(isolate != NULL);
   ASSERT(isolate->name() != NULL);
   if (!ServiceIsolate::NameEquals(isolate->name())) {
     // Not service isolate.
     return;
   }
   if (Exists()) {
     // Service isolate already exists.
     return;
   }
   SetServiceIsolate(isolate);

[turnidge, 2015/04/01 19:57:34]

Consider having this call set the origin as well, as discussed.

[Cutch, 2015/04/01 20:19:04]

Done.

 
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
 
   // Register dart:vmservice library.
   const String& url_str = String::Handle(Symbols::DartVMService().raw());
   const Library& library = Library::Handle(Library::New(url_str));
   library.Register();
   library.set_native_entry_resolver(ServiceNativeResolver);
 
@@ skipping 118 matching lines @@
       }
       Dart::RunShutdownCallback();
     }
     {
       // Shut the isolate down.
       SwitchIsolateScope switch_scope(isolate);
       Dart::ShutdownIsolate();
     }
     ServiceIsolate::SetServiceIsolate(NULL);
     ServiceIsolate::SetServicePort(ILLEGAL_PORT);
+    ServiceIsolate::SetOrigin(ILLEGAL_PORT);
     if (FLAG_trace_service) {
       OS::Print("vm-service: Shutdown.\n");
     }
     ServiceIsolate::FinishedExiting();
   }
 
   void RunMain(Isolate* isolate) {
     StartIsolateScope iso_scope(isolate);
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
@@ skipping 111 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