VM: [Kernel] Revert changes to the native ports that introduced peers.

runtime/vm/kernel_isolate.cc

 // Copyright (c) 2016, 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/kernel_isolate.h"
 
 #include "vm/compiler.h"
 #include "include/dart_native_api.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ skipping 259 matching lines @@
   return kernel_port_;
 }
 
 
 class KernelCompilationRequest : public ValueObject {
  public:
   KernelCompilationRequest()
       : monitor_(new Monitor()),
         port_(Dart_NewNativePort("kernel-compilation-port",
                                  &HandleResponse,
-                                 false,
-                                 this)) {
+                                 false)),
+        next_(NULL),
+        prev_(NULL) {
+    ASSERT(port_ != ILLEGAL_PORT);
+    RegisterRequest(this);
     result_.status = Dart_KernelCompilationStatus_Unknown;
     result_.error = NULL;
     result_.kernel = NULL;
     result_.kernel_size = 0;
   }
 
   ~KernelCompilationRequest() {
+    UnregisterRequest(this);
     Dart_CloseNativePort(port_);
     delete monitor_;
   }
 
   Dart_KernelCompilationResult SendAndWaitForResponse(Dart_Port kernel_port,
                                                       const char* script_uri) {
     // Build the [null, send_port, script_uri] message for the Kernel isolate:
     // null tag tells it that request came from this code, instead of Loader
     // so that it can given a more informative response.
     Dart_CObject tag;
@@ skipping 58 matching lines @@
     } else {
       ASSERT(result_.status == Dart_KernelCompilationStatus_Crash ||
              result_.status == Dart_KernelCompilationStatus_Error);
       // This is an error.
       ASSERT(response[1]->type == Dart_CObject_kString);
       result_.error = strdup(response[1]->value.as_string);
     }
     ml.Notify();
   }
 
-  static void HandleResponse(Dart_Port dest_port_id,
-                             Dart_CObject* message,
-                             void* peer) {
-    static_cast<KernelCompilationRequest*>(peer)->HandleResponseImpl(message);
+  static void HandleResponse(Dart_Port port, Dart_CObject* message) {
+    MonitorLocker locker(requests_monitor_);
+    KernelCompilationRequest* rq = FindRequestLocked(port);
+    if (rq == NULL) {
+      return;
+    }
+    rq->HandleResponseImpl(message);
   }
 
+  static void RegisterRequest(KernelCompilationRequest* rq) {
+    MonitorLocker locker(requests_monitor_);
+    rq->next_ = requests_;
+    requests_ = rq;
+  }
+
+  static void UnregisterRequest(KernelCompilationRequest* rq) {
+    MonitorLocker locker(requests_monitor_);
+    if (rq->next_ != NULL) {
+      rq->next_->prev_ = rq->prev_;
+    }
+    if (rq->prev_ != NULL) {
+      rq->prev_->next_ = rq->next_;
+    } else {
+      requests_ = rq->next_;
+    }
+  }
+
+  // Note: Caller must hold requests_monitor_.
+  static KernelCompilationRequest* FindRequestLocked(Dart_Port port) {
+    for (KernelCompilationRequest* rq = requests_; rq != NULL; rq = rq->next_) {
+      if (rq->port_ == port) {
+        return rq;
+      }
+    }
+    return NULL;
+  }
+
+  // This monitor must be held whenever linked list of requests is accessed.
+  static Monitor* requests_monitor_;
+
+  // Linked list of all active requests. Used to find a request by port number.
+  // Guarded by requests_monitor_ lock.
+  static KernelCompilationRequest* requests_;
+
   Monitor* monitor_;
   Dart_Port port_;
 
+  // Linked list of active requests. Guarded by requests_monitor_ lock.
+  KernelCompilationRequest* next_;
+  KernelCompilationRequest* prev_;
+
   Dart_KernelCompilationResult result_;
 };
 
+Monitor* KernelCompilationRequest::requests_monitor_ = new Monitor();
+KernelCompilationRequest* KernelCompilationRequest::requests_ = NULL;
 
 Dart_KernelCompilationResult KernelIsolate::CompileToKernel(
     const char* script_uri) {
   // This must be the main script to be loaded. Wait for Kernel isolate
   // to finish initialization.
   Dart_Port kernel_port = WaitForKernelPort();
   if (kernel_port == ILLEGAL_PORT) {
     Dart_KernelCompilationResult result;
     result.status = Dart_KernelCompilationStatus_Unknown;
     result.error = strdup("Error while initializing Kernel isolate");
     return result;
   }
 
   KernelCompilationRequest request;
   return request.SendAndWaitForResponse(kernel_port, script_uri);
 }
 
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart