Fix handling of long JSON messages

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/dartutils.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
@@ skipping 184 matching lines @@
 
 
 static bool IsValidJSON(const char* msg) {
   dart::JSONReader r(msg);
   return r.EndOfObject() != NULL;
 }
 
 
 void DebuggerConnectionHandler::SendMsg(dart::TextBuffer* msg) {
   ASSERT(debugger_fd_ >= 0);
-  Socket::Write(debugger_fd_, msg->buf(), msg->length());
+  ASSERT(IsValidJSON(msg->buf()));
+  // 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;
+      if (piece_len > max_piece_len) {
+        piece_len = max_piece_len;
+      }
+      intptr_t written =
+        Socket::Write(debugger_fd_, msg->buf() + sent, piece_len);
+      ASSERT(written == piece_len);
+      sent += written;
+      remaining -= written;
+      // Wait briefly so the OS does not coalesce message fragments.
+      {
+        MonitorLocker ml(&sleep);
+        ml.Wait(10);
+      }
+    }
+    return;
+  }
+  intptr_t bytes_written =
+      Socket::Write(debugger_fd_, msg->buf(), msg->length());
+  ASSERT(msg->length() == bytes_written);
   // TODO(hausner): Error checking. Probably just shut down the debugger
   // session if we there is an error while writing.
 }
 
 
 void DebuggerConnectionHandler::QueueMsg(dart::TextBuffer* msg) {
   queued_messages_.Printf("%s", msg->buf());
 }
 
 
@@ skipping 502 matching lines @@
   }
 }
 
 
 void DebuggerConnectionHandler::SendBreakpointEvent(Dart_Breakpoint bpt,
                                                     Dart_StackTrace trace) {
   dart::TextBuffer msg(128);
   msg.Printf("{ \"event\": \"paused\", \"params\": { ");
   FormatCallFrames(&msg, trace);
   msg.Printf("}}");
-  Socket::Write(debugger_fd_, msg.buf(), msg.length());
-  ASSERT(IsValidJSON(msg.buf()));
+  SendMsg(&msg);
 }
 
 
 void DebuggerConnectionHandler::BreakpointHandler(Dart_Breakpoint bpt,
                                                   Dart_StackTrace trace) {
   {
     MonitorLocker ml(&is_connected_);
     while (!IsConnected()) {
       printf("Waiting for debugger connection...\n");
       dart::Monitor::WaitResult res = ml.Wait(dart::Monitor::kNoTimeout);
@@ skipping 60 matching lines @@
   handler_started_ = true;
   DebuggerConnectionImpl::StartHandler(port_number);
   Dart_SetBreakpointHandler(BreakpointHandler);
   Dart_SetBreakpointResolvedHandler(BptResolvedHandler);
 }
 
 
 DebuggerConnectionHandler::~DebuggerConnectionHandler() {
   CloseDbgConnection();
 }