Merge ReliableQuicStream::WriteData with

net/quic/reliable_quic_stream.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/reliable_quic_stream.h"
 
 #include "net/quic/quic_session.h"
 #include "net/quic/quic_spdy_decompressor.h"
 #include "net/spdy/write_blocked_list.h"
 
@@ skipping 23 matching lines @@
     StringPiece(data, data_len).AppendToString(partial_data_buffer);
     return data_len;
   }
   StringPiece(data, missing_size).AppendToString(partial_data_buffer);
   DCHECK_EQ(4u, partial_data_buffer->length());
   memcpy(result, partial_data_buffer->data(), 4);
   partial_data_buffer->clear();
   return missing_size;
 }
 
+struct iovec MakeIovec(StringPiece data) {
+  struct iovec iov = {const_cast<char*>(data.data()),
+                      static_cast<size_t>(data.size())};
+  return iov;
+}
+
 }  // namespace
 
 ReliableQuicStream::ReliableQuicStream(QuicStreamId id,
                                        QuicSession* session)
     : sequencer_(this),
       id_(id),
       session_(session),
       visitor_(NULL),
       stream_bytes_read_(0),
       stream_bytes_written_(0),
@@ skipping 131 matching lines @@
 }
 
 QuicSpdyCompressor* ReliableQuicStream::compressor() {
   return session_->compressor();
 }
 
 bool ReliableQuicStream::GetSSLInfo(SSLInfo* ssl_info) {
   return session_->GetSSLInfo(ssl_info);
 }
 
-QuicConsumedData ReliableQuicStream::WriteData(StringPiece data, bool fin) {
-  DCHECK(data.size() > 0 || fin);
-  return WriteOrBuffer(data, fin);
-}
-
-
 void ReliableQuicStream::set_priority(QuicPriority priority) {
   DCHECK_EQ(0u, stream_bytes_written_);
   priority_ = priority;
 }
 
-QuicConsumedData ReliableQuicStream::WriteOrBuffer(StringPiece data, bool fin) {
+void ReliableQuicStream::WriteOrBufferData(StringPiece data, bool fin) {
+  DCHECK(data.size() > 0 || fin);
   DCHECK(!fin_buffered_);
 
   QuicConsumedData consumed_data(0, false);
   fin_buffered_ = fin;
 
   if (queued_data_.empty()) {
-    consumed_data = WriteDataInternal(string(data.data(), data.length()), fin);
+    struct iovec iov(MakeIovec(data));
+    consumed_data = WritevData(&iov, 1, fin, NULL);
     DCHECK_LE(consumed_data.bytes_consumed, data.length());
   }
 
   // If there's unconsumed data or an unconsumed fin, queue it.
   if (consumed_data.bytes_consumed < data.length() ||
       (fin && !consumed_data.fin_consumed)) {
     queued_data_.push_back(
         string(data.data() + consumed_data.bytes_consumed,
                data.length() - consumed_data.bytes_consumed));
   }
-
-  return QuicConsumedData(data.size(), true);
 }
 
 void ReliableQuicStream::OnCanWrite() {
   bool fin = false;
   while (!queued_data_.empty()) {
     const string& data = queued_data_.front();
     if (queued_data_.size() == 1 && fin_buffered_) {
       fin = true;
     }
-    QuicConsumedData consumed_data = WriteDataInternal(data, fin);
+    struct iovec iov(MakeIovec(data));
+    QuicConsumedData consumed_data = WritevData(&iov, 1, fin, NULL);
     if (consumed_data.bytes_consumed == data.size() &&
         fin == consumed_data.fin_consumed) {
       queued_data_.pop_front();
     } else {
       queued_data_.front().erase(0, consumed_data.bytes_consumed);
       break;
     }
   }
 }
 
-QuicConsumedData ReliableQuicStream::WriteDataInternal(
-    StringPiece data, bool fin) {
-  struct iovec iov = {const_cast<char*>(data.data()),
-                      static_cast<size_t>(data.size())};
-  return WritevDataInternal(&iov, 1, fin, NULL);
-}
-
-QuicConsumedData ReliableQuicStream::WritevDataInternal(
+QuicConsumedData ReliableQuicStream::WritevData(
     const struct iovec* iov,
     int iov_count,
     bool fin,
     QuicAckNotifier::DelegateInterface* ack_notifier_delegate) {
   if (write_side_closed_) {
     DLOG(ERROR) << ENDPOINT << "Attempt to write when the write side is closed";
     return QuicConsumedData(0, false);
   }
 
   size_t write_length = 0u;
@@ skipping 247 matching lines @@
   if (data_len > 0 && headers_id_ == 0u) {
     // The headers ID has not yet been read.  Strip it from the beginning of
     // the data stream.
     total_bytes_parsed += StripUint32(
         data, data_len, &headers_id_and_priority_buffer_, &headers_id_);
   }
   return total_bytes_parsed;
 }
 
 }  // namespace net