Delete NativeMessageHandler once a native port closes.

runtime/vm/message_handler.cc

 // Copyright (c) 2011, 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/message_handler.h"
 
 #include "vm/dart.h"
 #include "vm/lockers.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 46 matching lines @@
 MessageHandler::MessageHandler()
     : queue_(new MessageQueue()),
       oob_queue_(new MessageQueue()),
       oob_message_handling_allowed_(true),
       live_ports_(0),
       paused_(0),
       should_pause_on_start_(false),
       should_pause_on_exit_(false),
       is_paused_on_start_(false),
       is_paused_on_exit_(false),
+      delete_me_(false),
       paused_timestamp_(-1),
       pool_(NULL),
       task_(NULL),
       start_callback_(NULL),
       end_callback_(NULL),
       callback_data_(0) {
   ASSERT(queue_ != NULL);
   ASSERT(oob_queue_ != NULL);
 }
 
 
 MessageHandler::~MessageHandler() {
   delete queue_;
   delete oob_queue_;
+  queue_ = NULL;
+  oob_queue_ = NULL;
+  pool_ = NULL;
+  task_ = NULL;
 }
 
 
 const char* MessageHandler::name() const {
   return "<unnamed>";
 }
 
 
 #if defined(DEBUG)
 void MessageHandler::CheckAccess() {
@@ skipping 12 matching lines @@
                          EndCallback end_callback,
                          CallbackData data) {
   bool task_running;
   MonitorLocker ml(&monitor_);
   if (FLAG_trace_isolates) {
     OS::Print("[+] Starting message handler:\n"
               "\thandler:    %s\n",
               name());
   }
   ASSERT(pool_ == NULL);
+  ASSERT(!delete_me_);
   pool_ = pool;
   start_callback_ = start_callback;
   end_callback_ = end_callback;
   callback_data_ = data;
   task_ = new MessageHandlerTask(this);
   task_running = pool_->Run(task_);
   ASSERT(task_running);
 }
 
 
@@ skipping 18 matching lines @@
 
     saved_priority = message->priority();
     if (message->IsOOB()) {
       oob_queue_->Enqueue(message, before_events);
     } else {
       queue_->Enqueue(message, before_events);
     }
     message = NULL;  // Do not access message.  May have been deleted.
 
     if ((pool_ != NULL) && (task_ == NULL)) {
+      ASSERT(!delete_me_);
       task_ = new MessageHandlerTask(this);
       task_running = pool_->Run(task_);
     }
   }
   ASSERT(task_running);
 
   // Invoke any custom message notification.
   MessageNotify(saved_priority);
 }
 
@@ skipping 83 matching lines @@
   }
   return max_status;
 }
 
 
 MessageHandler::MessageStatus MessageHandler::HandleNextMessage() {
   // We can only call HandleNextMessage when this handler is not
   // assigned to a thread pool.
   MonitorLocker ml(&monitor_);
   ASSERT(pool_ == NULL);
+  ASSERT(!delete_me_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   return HandleMessages(&ml, true, false);
 }
 
 
 MessageHandler::MessageStatus MessageHandler::HandleAllMessages() {
   // We can only call HandleAllMessages when this handler is not
   // assigned to a thread pool.
   MonitorLocker ml(&monitor_);
   ASSERT(pool_ == NULL);
+  ASSERT(!delete_me_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   return HandleMessages(&ml, true, true);
 }
 
 
 MessageHandler::MessageStatus MessageHandler::HandleOOBMessages() {
   if (!oob_message_handling_allowed_) {
     return kOK;
   }
   MonitorLocker ml(&monitor_);
+  ASSERT(!delete_me_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   return HandleMessages(&ml, false, false);
 }
 
 
 bool MessageHandler::ShouldPauseOnStart(MessageStatus status) const {
   Isolate* owning_isolate = isolate();
   if (owning_isolate == NULL) {
@@ skipping 21 matching lines @@
 bool MessageHandler::HasOOBMessages() {
   MonitorLocker ml(&monitor_);
   return !oob_queue_->IsEmpty();
 }
 
 
 void MessageHandler::TaskCallback() {
   ASSERT(Isolate::Current() == NULL);
   MessageStatus status = kOK;
   bool run_end_callback = false;
+  bool delete_me = false;
   {
     // We will occasionally release and reacquire this monitor in this
     // function. Whenever we reacquire the monitor we *must* process
     // all pending OOB messages, or we may miss a request for vm
     // shutdown.
     MonitorLocker ml(&monitor_);
     if (ShouldPauseOnStart(kOK)) {
       if (!is_paused_on_start()) {
         PausedOnStartLocked(&ml, true);
       }
@@ skipping 59 matching lines @@
                     "\terror:    %s\n",
                     MessageStatusString(status), name(), error.ToCString());
         } else {
           OS::Print("[-] Stopping message handler (%s):\n"
                     "\thandler:    %s\n",
                     MessageStatusString(status), name());
         }
       }
       pool_ = NULL;
       run_end_callback = true;
+      delete_me = delete_me_;
     }
 
     // Clear the task_ last.  This allows other tasks to potentially start
     // for this message handler.
     ASSERT(oob_queue_->IsEmpty());
     task_ = NULL;
   }
+
+  // Message handlers either use delete_me or end_callback but not both.
+  ASSERT(!delete_me || end_callback_ == NULL);
+
   if (run_end_callback && end_callback_ != NULL) {
     end_callback_(callback_data_);
     // The handler may have been deleted after this point.
   }
+  if (delete_me) {
+    delete this;
+  }
 }
 
 
 void MessageHandler::ClosePort(Dart_Port port) {
   MonitorLocker ml(&monitor_);
   if (FLAG_trace_isolates) {
     OS::Print("[-] Closing port:\n"
               "\thandler:    %s\n"
               "\tport:       %" Pd64 "\n"
               "\tports:      live(%" Pd ")\n",
               name(), port, live_ports_);
   }
 }
 
 
 void MessageHandler::CloseAllPorts() {
   MonitorLocker ml(&monitor_);
   if (FLAG_trace_isolates) {
     OS::Print("[-] Closing all ports:\n"
               "\thandler:    %s\n",
               name());
   }
   queue_->Clear();
   oob_queue_->Clear();
 }
 
 
+void MessageHandler::RequestDeletion() {
+  ASSERT(OwnedByPortMap());
+  {
+    MonitorLocker ml(&monitor_);
+    if (task_ != NULL) {
+      // This message handler currently has a task running on the thread pool.
+      delete_me_ = true;
+      return;
+    }
+  }
+
+  // This message handler has no current task.  Delete it.
+  delete this;
+}
+
+
 void MessageHandler::increment_live_ports() {
   MonitorLocker ml(&monitor_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   live_ports_++;
 }
 
 
 void MessageHandler::decrement_live_ports() {
@@ skipping 84 matching lines @@
   handler_->oob_message_handling_allowed_ = false;
 }
 
 
 MessageHandler::AcquiredQueues::~AcquiredQueues() {
   ASSERT(handler_ != NULL);
   handler_->oob_message_handling_allowed_ = true;
 }
 
 }  // namespace dart