Clean up a raft of SPDY files

net/spdy/spdy_framer.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.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 46 matching lines @@
 }  // namespace
 
 const int SpdyFramer::kMinSpdyVersion = 2;
 const int SpdyFramer::kMaxSpdyVersion = 3;
 const SpdyStreamId SpdyFramer::kInvalidStream = -1;
 const size_t SpdyFramer::kHeaderDataChunkMaxSize = 1024;
 const size_t SpdyFramer::kControlFrameBufferSize =
     sizeof(SpdySynStreamControlFrameBlock);
 const size_t SpdyFramer::kMaxControlFrameSize = 16 * 1024;
 
-
 #ifdef DEBUG_SPDY_STATE_CHANGES
 #define CHANGE_STATE(newstate)                                  \
   do {                                                          \
     LOG(INFO) << "Changing state from: "                        \
               << StateToString(state_)                          \
               << " to " << StateToString(newstate) << "\n";     \
     DCHECK(state_ != SPDY_ERROR);                               \
     DCHECK_EQ(previous_state_, state_);                         \
     previous_state_ = state_;                                   \
     state_ = newstate;                                          \
@@ skipping 11 matching lines @@
 SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(int version,
                                                       uint32 wire) {
   if (version < 3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return SettingsFlagsAndId(ntohl(wire) >> 24, ntohl(wire) & 0x00ffffff);
 }
 
 SettingsFlagsAndId::SettingsFlagsAndId(uint8 flags, uint32 id)
     : flags_(flags), id_(id & 0x00ffffff) {
-  DCHECK_GT(static_cast<uint32>(1 << 24), id);
+  DCHECK_GT(1u << 24, id) << "SPDY setting ID too large.";
 }
 
 uint32 SettingsFlagsAndId::GetWireFormat(int version) const {
   uint32 wire = htonl(id_ & 0x00ffffff) | htonl(flags_ << 24);
   if (version < 3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return wire;
 }
 
@@ skipping 243 matching lines @@
       case SPDY_IGNORE_REMAINING_PAYLOAD:
         // control frame has too-large payload
         // intentional fallthrough
       case SPDY_FORWARD_STREAM_FRAME: {
         size_t bytes_read = ProcessDataFramePayload(data, len);
         len -= bytes_read;
         data += bytes_read;
         break;
       }
       default:
-        LOG(ERROR) << "Invalid value for " << display_protocol_
-                   << " framer state: " << state_;
+        LOG(DFATAL) << "Invalid value for " << display_protocol_
+                    << " framer state: " << state_;
         // This ensures that we don't infinite-loop if state_ gets an
         // invalid value somehow, such as due to a SpdyFramer getting deleted
         // from a callback it calls.
         goto bottom;
     }
   } while (state_ != previous_state_);
  bottom:
   DCHECK(len == 0 || state_ == SPDY_ERROR);
   if (current_frame_len_ == 0 &&
       remaining_data_ == 0 &&
@@ skipping 147 matching lines @@
       break;
     case CREDENTIAL:
       if (current_control_frame.length() <
           SpdyCredentialControlFrame::size() - SpdyControlFrame::kHeaderSize)
         set_error(SPDY_INVALID_CONTROL_FRAME);
       break;
     default:
       LOG(WARNING) << "Valid " << display_protocol_
                    << " control frame with unhandled type: "
                    << current_control_frame.type();
-      DCHECK(false);
+      DLOG(FATAL);
       set_error(SPDY_INVALID_CONTROL_FRAME);
       break;
   }
 
   if (state_ == SPDY_ERROR) {
     return;
   }
 
   remaining_control_payload_ = current_control_frame.length();
   const size_t total_frame_size =
@@ skipping 36 matching lines @@
     case SETTINGS:
       frame_size_without_variable_data = SpdySettingsControlFrame::size();
       break;
     default:
       frame_size_without_variable_data = -1;
       break;
   }
 
   if ((frame_size_without_variable_data == -1) &&
       (total_frame_size > kControlFrameBufferSize)) {
+    // We should already be in an error state. Double-check.
     DCHECK_EQ(SPDY_ERROR, state_);
     if (state_ != SPDY_ERROR) {
       LOG(DFATAL) << display_protocol_
                   << " control frame buffer too small for fixed-length frame.";
       set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
     }
     return;
   }
   if (frame_size_without_variable_data > 0) {
     // We have a control frame with a header block. We need to parse the
@@ skipping 68 matching lines @@
 size_t SpdyFramer::ProcessControlFrameBeforeHeaderBlock(const char* data,
                                                         size_t len) {
   DCHECK_EQ(SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK, state_);
   size_t original_len = len;
 
   if (remaining_control_header_ > 0) {
     size_t bytes_read = UpdateCurrentFrameBuffer(&data, &len,
                                                  remaining_control_header_);
     remaining_control_header_ -= bytes_read;
   }
+
   if (remaining_control_header_ == 0) {
     SpdyControlFrame control_frame(current_frame_buffer_.get(), false);
     DCHECK(control_frame.type() == SYN_STREAM ||
            control_frame.type() == SYN_REPLY ||
            control_frame.type() == HEADERS ||
            control_frame.type() == SETTINGS);
     visitor_->OnControl(&control_frame);
 
     if (control_frame.type() == SETTINGS) {
       CHANGE_STATE(SPDY_SETTINGS_FRAME_PAYLOAD);
@@ skipping 11 matching lines @@
 size_t SpdyFramer::ProcessControlFrameHeaderBlock(const char* data,
                                                   size_t data_len) {
   DCHECK_EQ(SPDY_CONTROL_FRAME_HEADER_BLOCK, state_);
   SpdyControlFrame control_frame(current_frame_buffer_.get(), false);
 
   bool processed_successfully = true;
   DCHECK(control_frame.type() == SYN_STREAM ||
          control_frame.type() == SYN_REPLY ||
          control_frame.type() == HEADERS);
   size_t process_bytes = std::min(data_len, remaining_control_payload_);
-
   if (process_bytes > 0) {
     if (enable_compression_) {
       processed_successfully = IncrementallyDecompressControlFrameHeaderData(
           &control_frame, data, process_bytes);
     } else {
       processed_successfully = IncrementallyDeliverControlFrameHeaderData(
           &control_frame, data, process_bytes);
     }
+
     remaining_control_payload_ -= process_bytes;
     remaining_data_ -= process_bytes;
   }
 
   // Handle the case that there is no futher data in this frame.
   if (remaining_control_payload_ == 0 && processed_successfully) {
     // The complete header block has been delivered. We send a zero-length
     // OnControlFrameHeaderData() to indicate this.
     visitor_->OnControlFrameHeaderData(
         GetControlFrameStreamId(&control_frame), NULL, 0);
@@ skipping 13 matching lines @@
   }
 
   // Return amount processed.
   return process_bytes;
 }
 
 size_t SpdyFramer::ProcessSettingsFramePayload(const char* data,
                                                size_t data_len) {
   DCHECK_EQ(SPDY_SETTINGS_FRAME_PAYLOAD, state_);
   SpdyControlFrame control_frame(current_frame_buffer_.get(), false);
-  DCHECK_EQ(control_frame.type(), SETTINGS);
+  DCHECK_EQ(SETTINGS, control_frame.type());
   size_t unprocessed_bytes = std::min(data_len, remaining_control_payload_);
   size_t processed_bytes = 0;
 
   // Loop over our incoming data.
   while (unprocessed_bytes > 0) {
     // Process up to one setting at a time.
     size_t processing = std::min(
         unprocessed_bytes,
         static_cast<size_t>(8 - settings_scratch_.setting_buf_len));
 
@@ skipping 120 matching lines @@
   return len;
 }
 
 size_t SpdyFramer::ProcessDataFramePayload(const char* data, size_t len) {
   size_t original_len = len;
 
   SpdyDataFrame current_data_frame(current_frame_buffer_.get(), false);
   if (remaining_data_ > 0) {
     size_t amount_to_forward = std::min(remaining_data_, len);
     if (amount_to_forward && state_ != SPDY_IGNORE_REMAINING_PAYLOAD) {
-        // Only inform the visitor if there is data.
+      // Only inform the visitor if there is data.
       if (amount_to_forward) {
         visitor_->OnStreamFrameData(current_data_frame.stream_id(),
                                     data, amount_to_forward);
       }
     }
     data += amount_to_forward;
     len -= amount_to_forward;
     remaining_data_ -= amount_to_forward;
 
     // If the FIN flag is set, and there is no more data in this data
@@ skipping 35 matching lines @@
   for (uint32 index = 0; index < num_headers; ++index) {
     base::StringPiece temp;
 
     // Read header name.
     if ((spdy_version_ < 3) ? !reader.ReadStringPiece16(&temp)
                             : !reader.ReadStringPiece32(&temp)) {
       DLOG(INFO) << "Unable to read header name (" << index + 1 << " of "
                  << num_headers << ").";
       return false;
     }
-    std::string name;
-    temp.CopyToString(&name);
+    std::string name = temp.as_string();
 
     // Read header value.
     if ((spdy_version_ < 3) ? !reader.ReadStringPiece16(&temp)
                             : !reader.ReadStringPiece32(&temp)) {
       DLOG(INFO) << "Unable to read header value (" << index + 1 << " of "
                  << num_headers << ").";
       return false;
     }
-    std::string value;
-    temp.CopyToString(&value);
+    std::string value = temp.as_string();
 
     // Ensure no duplicates.
     if (block->find(name) != block->end()) {
       DLOG(INFO) << "Duplicate header '" << name << "' (" << index + 1 << " of "
                  << num_headers << ").";
       return false;
     }
 
     // Store header.
     (*block)[name] = value;
   }
   return true;
 }
 
+// TODO(hkhalil): Remove, or move to test utils kit.
 /* static */
 bool SpdyFramer::ParseSettings(const SpdySettingsControlFrame* frame,
                                SettingsMap* settings) {
   DCHECK_EQ(frame->type(), SETTINGS);
   DCHECK(settings);
 
   SpdyFrameReader parser(frame->header_block(), frame->header_block_len());
   for (size_t index = 0; index < frame->num_entries(); ++index) {
     uint32 id_and_flags_wire;
     uint32 value;
@@ skipping 21 matching lines @@
 
   SpdyFrameReader parser(data, len);
   base::StringPiece temp;
   if (!parser.ReadUInt16(&credential->slot)) {
     return false;
   }
 
   if (!parser.ReadStringPiece32(&temp)) {
     return false;
   }
-  temp.CopyToString(&credential->proof);
+  credential->proof = temp.as_string();
 
   while (!parser.IsDoneReading()) {
     if (!parser.ReadStringPiece32(&temp)) {
       return false;
     }
-    std::string cert;
-    temp.CopyToString(&cert);
-    credential->certs.push_back(cert);
+    credential->certs.push_back(temp.as_string());
   }
   return true;
 }
 
 SpdySynStreamControlFrame* SpdyFramer::CreateSynStream(
     SpdyStreamId stream_id,
     SpdyStreamId associated_stream_id,
     SpdyPriority priority,
     uint8 credential_slot,
     SpdyControlFlags flags,
     bool compressed,
     const SpdyHeaderBlock* headers) {
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
   DCHECK_EQ(0u, associated_stream_id & ~kStreamIdMask);
 
   // Find our length.
   size_t frame_size = SpdySynStreamControlFrame::size() +
                       GetSerializedLength(headers);
 
   SpdyFrameBuilder frame(SYN_STREAM, flags, spdy_version_, frame_size);
   frame.WriteUInt32(stream_id);
   frame.WriteUInt32(associated_stream_id);
   // Cap as appropriate.
   if (priority > GetLowestPriority()) {
-    DLOG(ERROR) << "Priority out-of-bounds.";
+    DLOG(DFATAL) << "Priority out-of-bounds.";
     priority = GetLowestPriority();
   }
   // Priority is 2 bits for <spdy3, 3 bits otherwise.
   frame.WriteUInt8(priority << ((spdy_version_ < 3) ? 6 : 5));
   frame.WriteUInt8((spdy_version_ < 3) ? 0 : credential_slot);
   WriteHeaderBlock(&frame, headers);
   DCHECK_EQ(frame.length(), frame_size);
 
   scoped_ptr<SpdySynStreamControlFrame> syn_frame(
       reinterpret_cast<SpdySynStreamControlFrame*>(frame.take()));
@@ skipping 103 matching lines @@
     SpdyStreamId stream_id,
     SpdyControlFlags flags,
     bool compressed,
     const SpdyHeaderBlock* headers) {
   // Basically the same as CreateSynReply().
   DCHECK_GT(stream_id, 0u);
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
 
   // Find our length.
   size_t frame_size = SpdyHeadersControlFrame::size() +
-                       GetSerializedLength(headers);
+                      GetSerializedLength(headers);
   // In SPDY 2, there were 2 unused bytes before payload.
   if (spdy_version_ < 3) {
     frame_size += 2;
   }
 
   SpdyFrameBuilder frame(HEADERS, flags, spdy_version_, frame_size);
   frame.WriteUInt32(stream_id);
   if (spdy_version_ < 3) {
     frame.WriteUInt16(0);  // Unused
   }
@@ skipping 53 matching lines @@
     frame.WriteBytes(cert->c_str(), cert->length());
   }
   DCHECK_EQ(frame.length(), frame_size);
   return reinterpret_cast<SpdyCredentialControlFrame*>(frame.take());
 }
 
 SpdyDataFrame* SpdyFramer::CreateDataFrame(SpdyStreamId stream_id,
                                            const char* data,
                                            uint32 len, SpdyDataFlags flags) {
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
-
   size_t frame_size = SpdyDataFrame::size() + len;
   SpdyFrameBuilder frame(stream_id, flags, frame_size);
   frame.WriteBytes(data, len);
   DCHECK_EQ(frame.length(), frame_size);
   return reinterpret_cast<SpdyDataFrame*>(frame.take());
 }
 
 // The following compression setting are based on Brian Olson's analysis. See
 // https://groups.google.com/group/spdy-dev/browse_thread/thread/dfaf498542fac792
 // for more details.
@@ skipping 124 matching lines @@
   base::StatsCounter post_compress_bytes("spdy.PostCompressSize");
 
   if (!enable_compression_)
     return reinterpret_cast<SpdyControlFrame*>(DuplicateFrame(frame));
 
   if (!GetFrameBoundaries(frame, &payload_length, &header_length, &payload))
     return NULL;
 
   // Create an output frame.
   int compressed_max_size = deflateBound(compressor, payload_length);
-  int new_frame_size = header_length + compressed_max_size;
+  size_t new_frame_size = header_length + compressed_max_size;
   if ((frame.type() == SYN_REPLY || frame.type() == HEADERS) &&
       spdy_version_ < 3) {
     new_frame_size += 2;
   }
-  DCHECK_GE(new_frame_size,
-            static_cast<int>(frame.length() + SpdyFrame::kHeaderSize));
+  DCHECK_GE(new_frame_size, frame.length() + SpdyFrame::kHeaderSize);
   scoped_ptr<SpdyControlFrame> new_frame(new SpdyControlFrame(new_frame_size));
   memcpy(new_frame->data(), frame.data(),
          frame.length() + SpdyFrame::kHeaderSize);
 
   compressor->next_in = reinterpret_cast<Bytef*>(const_cast<char*>(payload));
   compressor->avail_in = payload_length;
   compressor->next_out = reinterpret_cast<Bytef*>(new_frame->data()) +
                           header_length;
   compressor->avail_out = compressed_max_size;
 
@@ skipping 170 matching lines @@
     case HEADERS:
       return SpdyHeadersControlFrame::size();
     case WINDOW_UPDATE:
       return SpdyWindowUpdateControlFrame::size();
     case CREDENTIAL:
       return SpdyCredentialControlFrame::size();
     case NUM_CONTROL_FRAME_TYPES:
       break;
   }
   LOG(ERROR) << "Unknown control frame type " << type;
-  return 0x7FFFFFFF;  // Max signed 32bit int
+  return std::numeric_limits<size_t>::max();
 }
 
 /* static */
 SpdyStreamId SpdyFramer::GetControlFrameStreamId(
     const SpdyControlFrame* control_frame) {
   SpdyStreamId stream_id = kInvalidStream;
   if (control_frame != NULL) {
     switch (control_frame->type()) {
       case SYN_STREAM:
         stream_id = reinterpret_cast<const SpdySynStreamControlFrame*>(
@@ skipping 33 matching lines @@
 
 void SpdyFramer::set_enable_compression(bool value) {
   enable_compression_ = value;
 }
 
 void SpdyFramer::set_enable_compression_default(bool value) {
   g_enable_compression_default = value;
 }
 
 }  // namespace net