Even more reordering the methods in headers and implementation in net/.

net/spdy/spdy_frame_builder.cc

 // Copyright (c) 2009 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 <limits>
 
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_protocol.h"
 
 namespace spdy {
@@ skipping 85 matching lines @@
   DCHECK(iter);
   DCHECK(data);
   DCHECK(length);
 
   if (!ReadUInt16(iter, length))
     return false;
 
   return ReadBytes(iter, data, *length);
 }
 
-char* SpdyFrameBuilder::BeginWrite(size_t length) {
-  size_t needed_size = length_ + length;
-  if (needed_size > capacity_ && !Resize(std::max(capacity_ * 2, needed_size)))
-    return NULL;
+bool SpdyFrameBuilder::WriteString(const std::string& value) {
+  if (value.size() > 0xffff)
+    return false;
 
-#ifdef ARCH_CPU_64_BITS
-  DCHECK_LE(length, std::numeric_limits<uint32>::max());
-#endif
+  if (!WriteUInt16(static_cast<int>(value.size())))
+    return false;
 
-  return buffer_ + length_;
-}
-
-void SpdyFrameBuilder::EndWrite(char* dest, int length) {
+  return WriteBytes(value.data(), static_cast<uint16>(value.size()));
 }
 
 bool SpdyFrameBuilder::WriteBytes(const void* data, uint16 data_len) {
   DCHECK(capacity_ != kCapacityReadOnly);
 
   char* dest = BeginWrite(data_len);
   if (!dest)
     return false;
 
   memcpy(dest, data, data_len);
 
   EndWrite(dest, data_len);
   length_ += data_len;
   return true;
 }
 
-bool SpdyFrameBuilder::WriteString(const std::string& value) {
-  if (value.size() > 0xffff)
-    return false;
-
-  if (!WriteUInt16(static_cast<int>(value.size())))
-    return false;
-
-  return WriteBytes(value.data(), static_cast<uint16>(value.size()));
-}
-
 char* SpdyFrameBuilder::BeginWriteData(uint16 length) {
   DCHECK_EQ(variable_buffer_offset_, 0U) <<
     "There can only be one variable buffer in a SpdyFrameBuilder";
 
   if (!WriteUInt16(length))
     return NULL;
 
   char *data_ptr = BeginWrite(length);
   if (!data_ptr)
     return NULL;
 
   variable_buffer_offset_ = data_ptr - buffer_ - sizeof(int);
 
   // EndWrite doesn't necessarily have to be called after the write operation,
   // so we call it here to pad out what the caller will eventually write.
   EndWrite(data_ptr, length);
   return data_ptr;
 }
 
+char* SpdyFrameBuilder::BeginWrite(size_t length) {
+  size_t needed_size = length_ + length;
+  if (needed_size > capacity_ && !Resize(std::max(capacity_ * 2, needed_size)))
+    return NULL;
+
+#ifdef ARCH_CPU_64_BITS
+  DCHECK_LE(length, std::numeric_limits<uint32>::max());
+#endif
+
+  return buffer_ + length_;
+}
+
+void SpdyFrameBuilder::EndWrite(char* dest, int length) {
+}
+
 bool SpdyFrameBuilder::Resize(size_t new_capacity) {
   if (new_capacity <= capacity_)
     return true;
 
   char* p = new char[new_capacity];
   if (!p)
     return false;
   if (buffer_) {
     memcpy(p, buffer_, capacity_);
     delete[] buffer_;
   }
   buffer_ = p;
   capacity_ = new_capacity;
   return true;
 }
 
 }  // namespace spdy