Process all complete packets present during Read callbacks, instead of a single packet at a time.

Having packets in the 64-192byte range with kReadBufferSize of 4k but processing
a single packet per Read callback practically guarantees falling behind (with a
fast sender), causing read_buffer_ to grow, causing future memmove's to have to
do more work.  Rinse, lather, repeat.

With this change, WebRTC over TCP performs as well as UDP (AFAICT) in the demo
attached to the linked bug. (--use-fake-device-for-media-stream makes it easy to
evaluate lag/sync issues visually).

BUG=webrtc:817


Review URL: https://chromiumcodereview.appspot.com/11299217

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@169943 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 19 insertions, 14 deletions

diff --git a/content/browser/renderer_host/p2p/socket_host_tcp.cc b/content/browser/renderer_host/p2p/socket_host_tcp.cc
index 3f0d525..910574f 100644
--- a/content/browser/renderer_host/p2p/socket_host_tcp.cc
+++ b/content/browser/renderer_host/p2p/socket_host_tcp.cc
@@ -164,21 +164,26 @@ void P2PSocketHostTcp::DidCompleteRead(int result) {
   }
 
   read_buffer_->set_offset(read_buffer_->offset() + result);
-  if (read_buffer_->offset() > kPacketHeaderSize) {
+  char* head = read_buffer_->StartOfBuffer();  // Purely a convenience.
+  int consumed = 0;
+  while (consumed + kPacketHeaderSize <= read_buffer_->offset() &&
+         state_ == STATE_OPEN) {
     int packet_size = base::NetToHost16(
-        *reinterpret_cast<uint16*>(read_buffer_->StartOfBuffer()));
-    if (packet_size + kPacketHeaderSize <= read_buffer_->offset()) {
-      // We've got a full packet!
-      char* start = read_buffer_->StartOfBuffer() + kPacketHeaderSize;
-      std::vector<char> data(start, start + packet_size);
-      OnPacket(data);
-
-      // Move remaining data to the start of the buffer.
-      memmove(read_buffer_->StartOfBuffer(), start + packet_size,
-              read_buffer_->offset() - packet_size - kPacketHeaderSize);
-      read_buffer_->set_offset(read_buffer_->offset() - packet_size -
-                               kPacketHeaderSize);
-    }
+        *reinterpret_cast<uint16*>(head + consumed));
+    if (consumed + packet_size + kPacketHeaderSize > read_buffer_->offset())
+      break;
+    // We've got a full packet!
+    consumed += kPacketHeaderSize;
+    char* cur = head + consumed;
+    std::vector<char> data(cur, cur + packet_size);
+    OnPacket(data);
+    consumed += packet_size;
+  }
+  // We've consumed all complete packets from the buffer; now move any remaining
+  // bytes to the head of the buffer and set offset to reflect this.
+  if (consumed && consumed <= read_buffer_->offset()) {
+    memmove(head, head + consumed, read_buffer_->offset() - consumed);
+    read_buffer_->set_offset(read_buffer_->offset() - consumed);
   }
 }