1. Create a port when a debugger object is created for an isolate, use this

vm/debugger.cc

 // Copyright (c) 2012, 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/debugger.h"
 
+#include "include/dart_api.h"
+
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
+#include "vm/port.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, verbose_debug, false, "Verbose debugger messages");
 
@@ skipping 125 matching lines @@
     ASSERT(isolate != NULL);
     const Code& code = Code::Handle(Code::LookupCode(pc_));
     function_ = code.function();
   }
   return function_;
 }
 
 
 void Debugger::SignalIsolateEvent(EventType type) {
   if (event_handler_ != NULL) {
+    Debugger* debugger = Isolate::Current()->debugger();
+    ASSERT(debugger != NULL);
     DebuggerEvent event;
     event.type = type;
-    event.isolate = Isolate::Current();
+    event.isolate_id = debugger->GetIsolateId();
+    ASSERT(event.isolate_id != ILLEGAL_ISOLATE_ID);
     (*event_handler_)(&event);
   }
 }
 
 
 const char* Debugger::QualifiedFunctionName(const Function& func) {
   const String& func_name = String::Handle(func.name());
   Class& func_class = Class::Handle(func.Owner());
   String& class_name = String::Handle(func_class.Name());
 
@@ skipping 449 matching lines @@
 
 
 RawObject* RemoteObjectCache::GetObj(intptr_t obj_id) const {
   ASSERT(IsValidId(obj_id));
   return objs_->At(obj_id);
 }
 
 
 Debugger::Debugger()
     : isolate_(NULL),
+      isolate_id_(ILLEGAL_ISOLATE_ID),
       initialized_(false),
       next_id_(1),
       stack_trace_(NULL),
       obj_cache_(NULL),
       src_breakpoints_(NULL),
       code_breakpoints_(NULL),
       resume_action_(kContinue),
       last_bpt_line_(-1),
       ignore_breakpoints_(false),
       exc_pause_info_(kNoPauseOnExceptions) {
 }
 
 
 Debugger::~Debugger() {
+  PortMap::ClosePort(isolate_id_);
+  isolate_id_ = ILLEGAL_ISOLATE_ID;
   ASSERT(src_breakpoints_ == NULL);
   ASSERT(code_breakpoints_ == NULL);
   ASSERT(stack_trace_ == NULL);
   ASSERT(obj_cache_ == NULL);
 }
 
 
 void Debugger::Shutdown() {
   while (src_breakpoints_ != NULL) {
     SourceBreakpoint* bpt = src_breakpoints_;
     src_breakpoints_ = src_breakpoints_->next();
     delete bpt;
   }
   while (code_breakpoints_ != NULL) {
     CodeBreakpoint* bpt = code_breakpoints_;
     code_breakpoints_ = code_breakpoints_->next();
     bpt->Disable();
     delete bpt;
   }
+  // Signal isolate shutdown event.
+  SignalIsolateEvent(Debugger::kIsolateShutdown);
 }
 
 
 bool Debugger::IsActive() {
   // TODO(hausner): The code generator uses this function to prevent
   // generation of optimized code when Dart code is being debugged.
   // This is probably not conservative enough (we could set the first
   // breakpoint after optimized code has already been produced).
   // Long-term, we need to be able to de-optimize code.
   return (src_breakpoints_ != NULL) ||
@@ skipping 732 matching lines @@
     }
   }
 }
 
 
 void Debugger::Initialize(Isolate* isolate) {
   if (initialized_) {
     return;
   }
   isolate_ = isolate;
+  // Create a port here, we don't expect to receive any messages on this port.
+  // This port will be used as a unique ID to represet the isolate in the
+  // debugger wire protocol messages.
+  // NOTE: SetLive is never called on this port.
+  isolate_id_ = PortMap::CreatePort(isolate->message_handler());
   initialized_ = true;
+
+  // Signal isolate creation event.
+  SignalIsolateEvent(Debugger::kIsolateCreated);
 }
 
 
 void Debugger::NotifyCompilation(const Function& func) {
   if (src_breakpoints_ == NULL) {
     // Return with minimal overhead if there are no breakpoints.
     return;
   }
   Function& lookup_function = Function::Handle(func.raw());
   if (func.IsImplicitClosureFunction()) {
@@ skipping 152 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart