Refactor isolate interrupts to use OOB messages instead of interrupt bits.

runtime/vm/isolate.h

 // 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.
 
 #ifndef VM_ISOLATE_H_
 #define VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/atomic.h"
@@ skipping 95 matching lines @@
   V(Instance)                                                                  \
   V(Library)                                                                   \
   V(Object)                                                                    \
   V(PcDescriptors)                                                             \
   V(String)                                                                    \
   V(TypeArguments)                                                             \
   V(TypeParameter)                                                             \
 
 class Isolate : public BaseIsolate {
  public:
+  // Keep both these enums in sync with isolate_patch.dart.
+  // The different Isolate API message types.
+  enum LibMsgId {
+    kPauseMsg = 1,
+    kResumeMsg = 2,
+    kPingMsg = 3,
+    kKillMsg = 4,
+    kAddExitMsg = 5,
+    kDelExitMsg = 6,
+    kAddErrorMsg = 7,
+    kDelErrorMsg = 8,
+    kErrorFatalMsg = 9,
+    kInterruptMsg = 10,
+  };
+  // The different Isolate API message priorities for ping and kill messages.
+  enum LibMsgPriority {
+    kImmediateAction = 0,
+    kBeforeNextEventAction = 1,
+    kAsEventAction = 2
+  };
+
   ~Isolate();
 
   static inline Isolate* Current() {
     Thread* thread = Thread::Current();
     return thread == NULL ? NULL : thread->isolate();
   }
 
   // Register a newly introduced class.
   void RegisterClass(const Class& cls);
   void RegisterClassAt(intptr_t index, const Class& cls);
@@ skipping 52 matching lines @@
            (origin_id_ == main_port_));
     origin_id_ = id;
   }
   void set_pause_capability(uint64_t value) { pause_capability_ = value; }
   uint64_t pause_capability() const { return pause_capability_; }
   void set_terminate_capability(uint64_t value) {
     terminate_capability_ = value;
   }
   uint64_t terminate_capability() const { return terminate_capability_; }
 
+  void SendInternalLibMessage(LibMsgId msg_id, uint64_t capability);
+
   Heap* heap() const { return heap_; }
   void set_heap(Heap* value) { heap_ = value; }
   static intptr_t heap_offset() { return OFFSET_OF(Isolate, heap_); }
 
   ObjectStore* object_store() const { return object_store_; }
   void set_object_store(ObjectStore* value) { object_store_ = value; }
   static intptr_t object_store_offset() {
     return OFFSET_OF(Isolate, object_store_);
   }
 
@@ skipping 114 matching lines @@
 
   // Retrieve the stack address bounds for profiler.
   bool GetProfilerStackBounds(uword* lower, uword* upper) const;
 
   static uword GetSpecifiedStackSize();
 
   static const intptr_t kStackSizeBuffer = (4 * KB * kWordSize);
 
   // Interrupt bits.
   enum {
-    kApiInterrupt = 0x1,      // An interrupt from Dart_InterruptIsolate.
+    kVMInterrupt = 0x1,  // Internal VM checks: safepoints, store buffers, etc.
     kMessageInterrupt = 0x2,  // An interrupt to process an out of band message.
-    kVMInterrupt = 0x4,  // Internal VM checks: safepoints, store buffers, etc.
 
-    kInterruptsMask =
-        kApiInterrupt |
-        kMessageInterrupt |
-        kVMInterrupt,
+    kInterruptsMask = (kVMInterrupt | kMessageInterrupt),
   };
 
   void ScheduleInterrupts(uword interrupt_bits);
+  RawError* HandleInterrupts();
   uword GetAndClearInterrupts();
 
   // Marks all libraries as loaded.
   void DoneLoading();
 
   bool MakeRunnable();
   void Run();
 
   MessageHandler* message_handler() const { return message_handler_; }
   void set_message_handler(MessageHandler* value) { message_handler_ = value; }
@@ skipping 784 matching lines @@
   uint8_t* serialized_message_;
   intptr_t serialized_message_len_;
   Isolate::Flags isolate_flags_;
   bool paused_;
   bool errors_are_fatal_;
 };
 
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_