Add an option to trace the debug protocol to the dart binary:

runtime/bin/dbg_connection.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 "bin/dbg_connection.h"
 #include "bin/dbg_message.h"
 #include "bin/dartutils.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
 #include "platform/globals.h"
 #include "platform/json.h"
 #include "platform/thread.h"
 #include "platform/utils.h"
 
 #include "include/dart_api.h"
 
 
 namespace dart {
 namespace bin {
 
+extern bool trace_debug_protocol;
+
 int DebuggerConnectionHandler::listener_fd_ = -1;
 dart::Monitor* DebuggerConnectionHandler::handler_lock_ = new dart::Monitor();
 
 // TODO(asiva): Remove this once we have support for multiple debugger
 // connections. For now we just store the single debugger connection
 // handler in a static variable.
 static DebuggerConnectionHandler* singleton_handler = NULL;
 
+// The maximum message length to print when --trace_debug_protocol is
+// specified.
+static const int kMaxPrintMessageLen = 1024;
 
 class MessageBuffer {
  public:
   explicit MessageBuffer(int fd);
   ~MessageBuffer();
   void ReadData();
   bool IsValidMessage() const;
   void PopMessage();
   int MessageId() const;
   char* buf() const { return buf_; }
@@ skipping 147 matching lines @@
 
   for (;;) {
     // Read a message.
     while (!msgbuf_->IsValidMessage() && msgbuf_->Alive()) {
       msgbuf_->ReadData();
     }
     if (!msgbuf_->Alive()) {
       return;
     }
 
+    if (trace_debug_protocol) {
+      dart::JSONReader r(msgbuf_->buf());
+      const char* msg_end = r.EndOfObject();
+      if (msg_end != NULL) {
+        intptr_t msg_len = msg_end - msgbuf_->buf();
+        int print_len = ((msg_len > kMaxPrintMessageLen)
+                         ? kMaxPrintMessageLen : msg_len);
+        Log::Print("[<<<] Receiving message from debug fd %d:\n%.*s%s\n",
+                   debug_fd_, print_len, msgbuf_->buf(),
+                   ((msg_len > print_len) ? "..." : ""));
+      }
+    }
+
     // Parse out the command portion from the message.
     dart::JSONReader r(msgbuf_->buf());
     bool found = r.Seek("command");
     if (r.Error()) {
       FATAL("Illegal JSON message received");
     }
     if (!found) {
       Log::Print("'command' not found in JSON message: '%s'\n",
                       msgbuf_->buf());
       msgbuf_->PopMessage();
@@ skipping 128 matching lines @@
   // we need to send the message to all of them.
   ASSERT(singleton_handler != NULL);
   SendMsgHelper(singleton_handler->debug_fd(), msg);
 }
 
 
 void DebuggerConnectionHandler::SendMsgHelper(int debug_fd,
                                               dart::TextBuffer* msg) {
   ASSERT(debug_fd >= 0);
   ASSERT(IsValidJSON(msg->buf()));
+
+  if (trace_debug_protocol) {
+    int print_len = ((msg->length() > kMaxPrintMessageLen)
+                     ? kMaxPrintMessageLen : msg->length());
+    Log::Print("[>>>] Sending message to debug fd %d:\n%.*s%s\n",
+               debug_fd, print_len, msg->buf(),
+               ((msg->length() > print_len) ? "..." : ""));
+  }
+
   // Sending messages in short pieces can be used to stress test the
   // debugger front-end's message handling code.
   const bool send_in_pieces = false;
   if (send_in_pieces) {
     intptr_t remaining = msg->length();
     intptr_t sent = 0;
     const intptr_t max_piece_len = 122;  // Pretty arbitrary, not a power of 2.
     dart::Monitor sleep;
     while (remaining > 0) {
       intptr_t piece_len = remaining;
@@ skipping 100 matching lines @@
 
 
 bool DebuggerConnectionHandler::IsConnected() {
   // TODO(asiva): Support multiple debugger connections.
   // Return true if a connection has been established.
   return singleton_handler != NULL;
 }
 
 }  // namespace bin
 }  // namespace dart