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 11 matching lines @@
     // Get function.
     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) ||
+    if (ServiceIsolate::IsServiceIsolateDescendant(isolate) ||
         (isolate == Dart::vm_isolate())) {
-      // We do not register the service or vm isolate.
+      // 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 174 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::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 (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_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 (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 33 matching lines @@
   MonitorLocker ml(monitor_);
   port_ = port;
 }
 
 
 void ServiceIsolate::SetServiceIsolate(Isolate* isolate) {
   MonitorLocker ml(monitor_);
   isolate_ = isolate;
   if (isolate_ != NULL) {
     isolate_->is_service_isolate_ = true;
+    origin_ = isolate_->origin_id();
+  } else {
+    origin_ = ILLEGAL_PORT;
   }
 }
 
 void ServiceIsolate::SetLoadPort(Dart_Port port) {
   MonitorLocker ml(monitor_);
   load_port_ = port;
 }
 
 
 void ServiceIsolate::MaybeInjectVMServiceLibrary(Isolate* isolate) {
@@ skipping 270 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