Split ByteBuffer into writer/reader objects.

webrtc/libjingle/xmpp/xmppsocket.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 63 matching lines @@
 #endif  // USE_SSLSTREAM
 }
 
 #ifndef USE_SSLSTREAM
 void XmppSocket::OnReadEvent(rtc::AsyncSocket * socket) {
   SignalRead();
 }
 
 void XmppSocket::OnWriteEvent(rtc::AsyncSocket * socket) {
   // Write bytes if there are any
-  while (buffer_.Length() != 0) {
-    int written = cricket_socket_->Send(buffer_.Data(), buffer_.Length());
+  while (buffer_.size() > 0) {
+    int written = cricket_socket_->Send(buffer_.data(), buffer_.size());
     if (written > 0) {
-      buffer_.Consume(written);
+      ASSERT(static_cast<size_t>(written) <= buffer_.size());
+      memmove(buffer_.data(), buffer_.data() + written,
+          buffer_.size() - written);
+      buffer_.SetSize(buffer_.size() - written);
       continue;
     }
     if (!cricket_socket_->IsBlocking())
       LOG(LS_ERROR) << "Send error: " << cricket_socket_->GetError();
     return;
   }
 }
 
 void XmppSocket::OnConnectEvent(rtc::AsyncSocket * socket) {
 #if defined(FEATURE_ENABLE_SSL)
@@ skipping 26 matching lines @@
 #endif
     {
       state_ = buzz::AsyncSocket::STATE_OPEN;
       SignalConnected();
     }
   }
   if ((events & rtc::SE_READ))
     SignalRead();
   if ((events & rtc::SE_WRITE)) {
     // Write bytes if there are any
-    while (buffer_.Length() != 0) {
+    while (buffer_.size() > 0) {
       rtc::StreamResult result;
       size_t written;
       int error;
-      result = stream_->Write(buffer_.Data(), buffer_.Length(),
+      result = stream_->Write(buffer_.data(), buffer_.size(),
                               &written, &error);
       if (result == rtc::SR_ERROR) {
         LOG(LS_ERROR) << "Send error: " << error;
         return;
       }
       if (result == rtc::SR_BLOCK)
         return;
       ASSERT(result == rtc::SR_SUCCESS);
       ASSERT(written > 0);
-      buffer_.Shift(written);
+      ASSERT(written <= buffer_.size());
+      memmove(buffer_.data(), buffer_.data() + written,
+          buffer_.size() - written);
+      buffer_.SetSize(buffer_.size() - written);
     }
   }
   if ((events & rtc::SE_CLOSE))
     SignalCloseEvent(err);
 }
 #endif  // USE_SSLSTREAM
 
 buzz::AsyncSocket::State XmppSocket::state() {
   return state_;
 }
@@ skipping 25 matching lines @@
   }
 #else  // USE_SSLSTREAM
   rtc::StreamResult result = stream_->Read(data, len, len_read, NULL);
   if (result == rtc::SR_SUCCESS)
     return true;
 #endif  // USE_SSLSTREAM
   return false;
 }
 
 bool XmppSocket::Write(const char * data, size_t len) {
-  buffer_.WriteBytes(data, len);
+  buffer_.AppendData(data, len);
 #ifndef USE_SSLSTREAM
   OnWriteEvent(cricket_socket_);
 #else  // USE_SSLSTREAM
   OnEvent(stream_, rtc::SE_WRITE, 0);
 #endif  // USE_SSLSTREAM
   return true;
 }
 
 bool XmppSocket::Close() {
   if (state_ != buzz::AsyncSocket::STATE_OPEN)
@@ skipping 30 matching lines @@
 #endif  // USE_SSLSTREAM
   state_ = buzz::AsyncSocket::STATE_TLS_CONNECTING;
   return true;
 #else  // !defined(FEATURE_ENABLE_SSL)
   return false;
 #endif  // !defined(FEATURE_ENABLE_SSL)
 }
 
 }  // namespace buzz