Rename the QUIC stream frame fields frame_buffer and frame_length to data_buffer and data_length be…

net/quic/quic_protocol.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/quic_protocol.h"
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
@@ skipping 115 matching lines @@
     : QuicStreamFrame(stream_id,
                       fin,
                       offset,
                       data.data(),
                       data.length(),
                       nullptr) {}
 
 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
                                  bool fin,
                                  QuicStreamOffset offset,
-                                 QuicPacketLength frame_length,
+                                 QuicPacketLength data_length,
                                  UniqueStreamBuffer buffer)
     : QuicStreamFrame(stream_id,
                       fin,
                       offset,
                       nullptr,
-                      frame_length,
+                      data_length,
                       std::move(buffer)) {
   DCHECK(this->buffer != nullptr);
-  DCHECK_EQ(frame_buffer, this->buffer.get());
+  DCHECK_EQ(data_buffer, this->buffer.get());
 }
 
 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
                                  bool fin,
                                  QuicStreamOffset offset,
-                                 const char* frame_buffer,
-                                 QuicPacketLength frame_length,
+                                 const char* data_buffer,
+                                 QuicPacketLength data_length,
                                  UniqueStreamBuffer buffer)
     : stream_id(stream_id),
       fin(fin),
-      frame_length(frame_length),
-      frame_buffer(frame_buffer),
+      data_length(data_length),
+      data_buffer(data_buffer),
       offset(offset),
       buffer(std::move(buffer)) {
   if (this->buffer != nullptr) {
-    DCHECK(frame_buffer == nullptr);
-    this->frame_buffer = this->buffer.get();
+    DCHECK(data_buffer == nullptr);
+    this->data_buffer = this->buffer.get();
   }
 }
 
 QuicStreamFrame::~QuicStreamFrame() {}
 
 uint32_t MakeQuicTag(char a, char b, char c, char d) {
   return static_cast<uint32_t>(a) | static_cast<uint32_t>(b) << 8 |
          static_cast<uint32_t>(c) << 16 | static_cast<uint32_t>(d) << 24;
 }
 
@@ skipping 494 matching lines @@
 
 ostream& operator<<(ostream& os, const QuicPathCloseFrame& path_close_frame) {
   os << "path_id { " << path_close_frame.path_id << " }\n";
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicStreamFrame& stream_frame) {
   os << "stream_id { " << stream_frame.stream_id << " } "
      << "fin { " << stream_frame.fin << " } "
      << "offset { " << stream_frame.offset << " } "
-     << "length { " << stream_frame.frame_length << " }\n";
+     << "length { " << stream_frame.data_length << " }\n";
   return os;
 }
 
 QuicGoAwayFrame::QuicGoAwayFrame()
     : error_code(QUIC_NO_ERROR), last_good_stream_id(0) {}
 
 QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code,
                                  QuicStreamId last_good_stream_id,
                                  const string& reason)
     : error_code(error_code),
@@ skipping 163 matching lines @@
       is_unackable(false),
       has_crypto_handshake(has_crypto_handshake),
       num_padding_bytes(num_padding_bytes),
       retransmission(0) {}
 
 TransmissionInfo::TransmissionInfo(const TransmissionInfo& other) = default;
 
 TransmissionInfo::~TransmissionInfo() {}
 
 }  // namespace net