Fix debugging module(replace int with intptr_t) so it works on Windows x64.

runtime/bin/dbg_message.h

 // 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.
 
 #ifndef BIN_DBG_MESSAGE_H_
 #define BIN_DBG_MESSAGE_H_
 
 #include "bin/builtin.h"
 #include "bin/utils.h"
 
@@ skipping 45 matching lines @@
   int buf_length_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageParser);
 };
 
 
 // Class which represents a debug command message and handles it.
 class DbgMessage {
  public:
   DbgMessage(int32_t cmd_idx, const char* start,
-             const char* end, int debug_fd)
+             const char* end, intptr_t debug_fd)
       : next_(NULL), cmd_idx_(cmd_idx),
         buffer_(NULL), buffer_len_(end - start),
         debug_fd_(debug_fd) {
     buffer_ = reinterpret_cast<char*>(malloc(buffer_len_));
     ASSERT(buffer_ != NULL);
     memmove(buffer_, start, buffer_len_);
   }
   ~DbgMessage() {
     next_ = NULL;
     free(buffer_);
   }
 
   // Accessors.
   DbgMessage* next() const { return next_; }
   void set_next(DbgMessage* next) { next_ = next; }
   char* buffer() const { return buffer_; }
   int32_t buffer_len() const { return buffer_len_; }
-  int debug_fd() const { return debug_fd_; }
+  intptr_t debug_fd() const { return debug_fd_; }
 
   // Handle debugger command message.
   // Returns true if the execution needs to resume after this message is
   // handled, false otherwise.
   bool HandleMessage();
 
   // Send reply after successful handling of command.
   void SendReply(dart::TextBuffer* msg);
 
   // Reply error returned by the command handler.
@@ skipping 19 matching lines @@
   static bool HandleGetStackTraceCmd(DbgMessage* msg);
   static bool HandlePauseOnExcCmd(DbgMessage* msg);
   static bool HandleSetBpCmd(DbgMessage* msg);
   static bool HandleRemBpCmd(DbgMessage* msg);
 
  private:
   DbgMessage* next_;  // Next message in the queue.
   int32_t cmd_idx_;  // Isolate specific debugger command index.
   char* buffer_;  // Debugger command message.
   int32_t buffer_len_;  // Length of the debugger command message.
-  int debug_fd_;  // Debugger connection on which replies are to be sent.
+  intptr_t debug_fd_;  // Debugger connection on which replies are to be sent.
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(DbgMessage);
 };
 
 
 // Class which represents a queue of debug command messages sent to an isolate.
 class DbgMsgQueue {
  public:
   DbgMsgQueue(Dart_IsolateId isolate_id, DbgMsgQueue* next)
       : is_running_(true),
@@ skipping 18 matching lines @@
 
   // Accessors.
   Dart_IsolateId isolate_id() const { return isolate_id_; }
   DbgMsgQueue* next() const { return next_; }
   void set_next(DbgMsgQueue* next) { next_ = next; }
 
   // Add specified debug command message to the queue.
   void AddMessage(int32_t cmd_idx,
                   const char* start,
                   const char* end,
-                  int debug_fd);
+                  intptr_t debug_fd);
 
   // Notify an isolate of a pending vmservice message.
   void Notify();
 
   // Run a message loop which handles messages as they arrive until
   // normal program execution resumes.
   void MessageLoop();
 
   // Handle any pending debug command messages in the queue.  Return
   // value indicates whether a resume has been requested.
@@ skipping 51 matching lines @@
   // Parses the input message and returns the command index if the message
   // contains a valid isolate specific command.
   // It returns kInvalidCommand otherwise.
   static int32_t LookupIsolateCommand(const char* buf, int32_t buflen);
 
   // Queue debugger message targetted for the isolate.
   static bool AddIsolateMessage(Dart_IsolateId isolate_id,
                                 int32_t cmd_idx,
                                 const char* start,
                                 const char* end,
-                                int debug_fd);
+                                intptr_t debug_fd);
 
   // Notify an isolate of a pending vmservice message.
   static void NotifyIsolate(Dart_Isolate isolate);
 
   // Interrupt isolate.
   static bool InterruptIsolate(Dart_IsolateId isolate_id);
 
   // Add Debugger Message Queue corresponding to the Isolate.
   static DbgMsgQueue* AddIsolateMsgQueue(Dart_IsolateId isolate_id);
 
@@ skipping 27 matching lines @@
   static dart::Mutex* msg_queue_list_lock_;
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(DbgMsgQueueList);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_DBG_MESSAGE_H_