Clean up a raft of SPDY files

net/spdy/spdy_framer_test.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 <algorithm>
 #include <iostream>
+#include <limits>
 
 #include "base/memory/scoped_ptr.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/platform_test.h"
 
+using std::string;
+using std::max;
+using std::min;
+using std::numeric_limits;
 using testing::_;
 
 namespace net {
 
 namespace test {
 
 static const size_t kMaxDecompressedSize = 1024;
 
 class MockVisitor : public SpdyFramerVisitorInterface {
  public:
   MOCK_METHOD1(OnError, void(SpdyFramer* framer));
   MOCK_METHOD1(OnControl, void(const SpdyControlFrame* frame));
   MOCK_METHOD3(OnControlFrameHeaderData, bool(SpdyStreamId stream_id,
                                               const char* header_data,
                                               size_t len));
   MOCK_METHOD2(OnCredentialFrameData, bool(const char* header_data,
                                            size_t len));
   MOCK_METHOD1(OnDataFrameHeader, void(const SpdyDataFrame* frame));
   MOCK_METHOD3(OnStreamFrameData, void(SpdyStreamId stream_id,
                                        const char* data,
                                        size_t len));
   MOCK_METHOD3(OnSetting, void(SpdySettingsIds id, uint8 flags, uint32 value));
 };
 
 class SpdyFramerTestUtil {
  public:
   // Decompress a single frame using the decompression context held by
-  // the SpdyFramer. The implemention will CHECK fail if the input is anything
-  // other than a single, well-formed compressed frame.
+  // the SpdyFramer.  The implemention is meant for use only in tests

[ramant (doing other things), 2012/04/24 20:53:37]

nit: two spaces after period. As you are cleaning up, should we consider using
all 80 characters? tx

+  // and will CHECK fail if the input is anything other than a single,
+  // well-formed compressed frame.
   //
   // Returns a new decompressed SpdyFrame.
   template<class SpdyFrameType> static SpdyFrame* DecompressFrame(
       SpdyFramer* framer, const SpdyFrameType& frame) {
     DecompressionVisitor visitor;
     framer->set_visitor(&visitor);
     size_t input_size = frame.length() + SpdyFrame::kHeaderSize;
     CHECK_EQ(input_size, framer->ProcessInput(frame.data(), input_size));
     CHECK_EQ(SpdyFramer::SPDY_RESET, framer->state());
     framer->set_visitor(NULL);
 
     char* buffer = visitor.ReleaseBuffer();
-    CHECK(buffer);
+    CHECK(buffer != NULL);
     SpdyFrame* decompressed_frame = new SpdyFrame(buffer, true);
     decompressed_frame->set_length(visitor.size() - SpdyFrame::kHeaderSize);
     return decompressed_frame;
   }
 
   class DecompressionVisitor : public SpdyFramerVisitorInterface {
    public:
     DecompressionVisitor()
         : buffer_(NULL), size_(0), finished_(false) {
     }
 
     virtual void OnControl(const SpdyControlFrame* frame) {
       CHECK(frame->has_header_block());
-      CHECK(!buffer_.get());
-      CHECK_EQ(size_, 0u);
+      CHECK(buffer_.get() == NULL);
+      CHECK_EQ(0u, size_);
       CHECK(!finished_);
 
       int32 control_frame_header_size = 0;
       switch (frame->type()) {
         case SYN_STREAM:
           control_frame_header_size = SpdySynStreamControlFrame::size();
           break;
         case SYN_REPLY:
           control_frame_header_size = SpdySynReplyControlFrame::size();
           break;
         case HEADERS:
           control_frame_header_size = SpdyHeadersControlFrame::size();
           break;
         default:
           LOG(FATAL);
-          return;
       }
 
       // Allocate space for the frame, and the copy header over.
       buffer_.reset(new char[kMaxDecompressedSize]);
       memcpy(buffer_.get(), frame->data(), control_frame_header_size);
       size_ += control_frame_header_size;
     }
 
     virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                           const char* header_data,
@@ skipping 44 matching lines @@
     scoped_array<char> buffer_;
     size_t size_;
     bool finished_;
 
     DISALLOW_COPY_AND_ASSIGN(DecompressionVisitor);
   };
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFramerTestUtil);
 };
 
-std::string HexDumpWithMarks(const unsigned char* data, int length,
+string HexDumpWithMarks(const unsigned char* data, int length,
                              const bool* marks, int mark_length) {
   static const char kHexChars[] = "0123456789abcdef";
   static const int kColumns = 4;
 
   const int kSizeLimit = 1024;
   if (length > kSizeLimit || mark_length > kSizeLimit) {
     LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
-    length = std::min(length, kSizeLimit);
-    mark_length = std::min(mark_length, kSizeLimit);
+    length = min(length, kSizeLimit);
+    mark_length = min(mark_length, kSizeLimit);
   }
 
-  std::string hex;
+  string hex;
   for (const unsigned char* row = data; length > 0;
        row += kColumns, length -= kColumns) {
     for (const unsigned char *p = row; p < row + 4; ++p) {
       if (p < row + length) {
         const bool mark =
             (marks && (p - data) < mark_length && marks[p - data]);
         hex += mark ? '*' : ' ';
         hex += kHexChars[(*p & 0xf0) >> 4];
         hex += kHexChars[*p & 0x0f];
         hex += mark ? '*' : ' ';
       } else {
         hex += "    ";
       }
     }
     hex = hex + "  ";
 
     for (const unsigned char *p = row; p < row + 4 && p < row + length; ++p)
       hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.';
 
     hex = hex + '\n';
   }
   return hex;
 }
 
 void CompareCharArraysWithHexError(
-    const std::string& description,
+    const string& description,
     const unsigned char* actual,
     const int actual_len,
     const unsigned char* expected,
     const int expected_len) {
-  const int min_len = std::min(actual_len, expected_len);
-  const int max_len = std::max(actual_len, expected_len);
+  const int min_len = min(actual_len, expected_len);
+  const int max_len = max(actual_len, expected_len);
   scoped_array<bool> marks(new bool[max_len]);
   bool identical = (actual_len == expected_len);
   for (int i = 0; i < min_len; ++i) {
     if (actual[i] != expected[i]) {
       marks[i] = true;
       identical = false;
     } else {
       marks[i] = false;
     }
   }
   for (int i = min_len; i < max_len; ++i) {
     marks[i] = true;
   }
   if (identical) return;
   ADD_FAILURE()
       << "Description:\n"
       << description
       << "\n\nExpected:\n"
       << HexDumpWithMarks(expected, expected_len, marks.get(), max_len)
       << "\nActual:\n"
       << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
 }
 
 class TestSpdyVisitor : public SpdyFramerVisitorInterface  {
  public:
-  static const size_t kDefaultHeaderBufferSize = 64 * 1024;
+  static const size_t kDefaultHeaderBufferSize = 16 * 1024;
   static const size_t kDefaultCredentialBufferSize = 16 * 1024;
 
-  TestSpdyVisitor(int version)
+  explicit TestSpdyVisitor(int version)
     : framer_(version),
       use_compression_(false),
       error_count_(0),
       syn_frame_count_(0),
       syn_reply_frame_count_(0),
       headers_frame_count_(0),
       goaway_count_(0),
       credential_count_(0),
       settings_frame_count_(0),
       setting_count_(0),
@@ skipping 132 matching lines @@
     framer_.set_visitor(this);
     size_t input_remaining = size;
     const char* input_ptr = reinterpret_cast<const char*>(input);
     while (input_remaining > 0 &&
            framer_.error_code() == SpdyFramer::SPDY_NO_ERROR) {
       // To make the tests more interesting, we feed random (amd small) chunks
       // into the framer.  This simulates getting strange-sized reads from
       // the socket.
       const size_t kMaxReadSize = 32;
       size_t bytes_read =
-          (rand() % std::min(input_remaining, kMaxReadSize)) + 1;
+          (rand() % min(input_remaining, kMaxReadSize)) + 1;
       size_t bytes_processed = framer_.ProcessInput(input_ptr, bytes_read);
       input_remaining -= bytes_processed;
       input_ptr += bytes_processed;
       if (framer_.state() == SpdyFramer::SPDY_DONE)
         framer_.Reset();
     }
   }
 
   void InitHeaderStreaming(const SpdyControlFrame* frame) {
     memset(header_buffer_.get(), 0, header_buffer_size_);
@@ skipping 48 matching lines @@
   SpdyControlType header_control_type_;
   bool header_buffer_valid_;
   SpdyHeaderBlock headers_;
 
   scoped_array<char> credential_buffer_;
   size_t credential_buffer_length_;
   size_t credential_buffer_size_;
   SpdyCredential credential_;
 };
 
-}  // namespace test
+}  // namespace net
 
 using test::CompareCharArraysWithHexError;
 using test::SpdyFramerTestUtil;
 using test::TestSpdyVisitor;
 
 TEST(SpdyFrameBuilderTest, WriteLimits) {
   SpdyFrameBuilder builder(1, DATA_FLAG_NONE, kLengthMask + 8);
   // Data frame header is 8 bytes
   EXPECT_EQ(8u, builder.length());
-  const std::string kLargeData(kLengthMask, 'A');
+  const string kLargeData(kLengthMask, 'A');
   builder.WriteUInt32(kLengthMask);
   EXPECT_EQ(12u, builder.length());
   EXPECT_TRUE(builder.WriteBytes(kLargeData.data(), kLengthMask - 4));
-  EXPECT_EQ(kLengthMask + 8, builder.length());
+  EXPECT_EQ(kLengthMask + 8u, builder.length());
 }
 
 enum SpdyFramerTestTypes {
-  SPDY2,
-  SPDY3,
+  SPDY2 = 2,
+  SPDY3 = 3,
 };
 
 class SpdyFramerTest
     : public ::testing::TestWithParam<SpdyFramerTestTypes> {
  protected:
   virtual void SetUp() {
-    spdy_version_ = (GetParam() == SPDY2) ? 2 : 3;
+    spdy_version_ = GetParam();
   }
 
-  virtual void TearDown() {}
-
-  void CompareFrame(const std::string& description,
+  void CompareFrame(const string& description,
                     const SpdyFrame& actual_frame,
                     const unsigned char* expected,
                     const int expected_len) {
     const unsigned char* actual =
         reinterpret_cast<const unsigned char*>(actual_frame.data());
     int actual_len = actual_frame.length() + SpdyFrame::kHeaderSize;
     CompareCharArraysWithHexError(
         description, actual, actual_len, expected, expected_len);
   }
 
   // Returns true if the two header blocks have equivalent content.
   bool CompareHeaderBlocks(const SpdyHeaderBlock* expected,
                            const SpdyHeaderBlock* actual) {
     if (expected->size() != actual->size()) {
       LOG(ERROR) << "Expected " << expected->size() << " headers; actually got "
-                 << actual->size() << "." << std::endl;
+                 << actual->size() << ".";
       return false;
     }
     for (SpdyHeaderBlock::const_iterator it = expected->begin();
          it != expected->end();
          ++it) {
       SpdyHeaderBlock::const_iterator it2 = actual->find(it->first);
       if (it2 == actual->end()) {
-        LOG(ERROR) << "Expected header name '" << it->first << "'."
-                   << std::endl;
+        LOG(ERROR) << "Expected header name '" << it->first << "'.";
         return false;
       }
       if (it->second.compare(it2->second) != 0) {
         LOG(ERROR) << "Expected header named '" << it->first
                    << "' to have a value of '" << it->second
                    << "'. The actual value received was '" << it2->second
-                   << "'." << std::endl;
+                   << "'.";
         return false;
       }
     }
     return true;
   }
 
   void AddSpdySettingFromWireFormat(SettingsMap* settings,
                                     uint32 key,
                                     uint32 value) {
     SettingsFlagsAndId flags_and_id =
         SettingsFlagsAndId::FromWireFormat(spdy_version_, key);
     SpdySettingsIds id = static_cast<SpdySettingsIds>(flags_and_id.id());
     SpdySettingsFlags flags =
         static_cast<SpdySettingsFlags>(flags_and_id.flags());
     settings->insert(std::make_pair(id, SettingsFlagsAndValue(flags, value)));
   }
 
-  bool IsSpdy2() { return spdy_version_ < 3; }
+  bool IsSpdy2() { return spdy_version_ == SPDY2; }
 
   // Version of SPDY protocol to be used.
-  int spdy_version_;
+  unsigned char spdy_version_;
 };
 
-
-//-----------------------------------------------------------------------------
 // All tests are run with two different SPDY versions: SPDY/2 and SPDY/3.
 INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
                         SpdyFramerTest,
                         ::testing::Values(SPDY2, SPDY3));
 
 TEST_P(SpdyFramerTest, IsCompressible) {
   SpdyFramer framer(spdy_version_);
   for (SpdyControlType type = SYN_STREAM;
        type < NUM_CONTROL_FRAME_TYPES;
        type = static_cast<SpdyControlType>(type + 1)) {
@@ skipping 16 matching lines @@
   // Encode the header block into a SynStream frame.
   scoped_ptr<SpdySynStreamControlFrame> frame(
       framer.CreateSynStream(1,  // stream id
                              0,  // associated stream id
                              1,  // priority
                              0,  // credential slot
                              CONTROL_FLAG_NONE,
                              false,  // compress
                              &headers));
   EXPECT_TRUE(frame.get() != NULL);
-  std::string serialized_headers(frame->header_block(),
-                                 frame->header_block_len());
+  string serialized_headers(frame->header_block(), frame->header_block_len());
   SpdyHeaderBlock new_headers;
   EXPECT_TRUE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
                                               serialized_headers.size(),
                                               &new_headers));
 
   EXPECT_EQ(headers.size(), new_headers.size());
   EXPECT_EQ(headers["alpha"], new_headers["alpha"]);
   EXPECT_EQ(headers["gamma"], new_headers["gamma"]);
 }
 
 // Test that if there's not a full frame, we fail to parse it.
 TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "charlie";
   SpdyFramer framer(spdy_version_);
 
   // Encode the header block into a SynStream frame.
   scoped_ptr<SpdySynStreamControlFrame> frame(
       framer.CreateSynStream(1,  // stream id
                              0,  // associated stream id
                              1,  // priority
                              0,  // credential slot
                              CONTROL_FLAG_NONE,
                              false,  // compress
                              &headers));
   EXPECT_TRUE(frame.get() != NULL);
 
-  std::string serialized_headers(frame->header_block(),
-                                 frame->header_block_len());
+  string serialized_headers(frame->header_block(), frame->header_block_len());
   SpdyHeaderBlock new_headers;
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
                                                serialized_headers.size() - 2,
                                                &new_headers));
 }
 
 TEST_P(SpdyFramerTest, OutOfOrderHeaders) {
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(SYN_STREAM, CONTROL_FLAG_NONE, 1, 1024);
 
@@ skipping 13 matching lines @@
     frame.WriteStringPiece32("gamma");
     frame.WriteStringPiece32("alpha");
     frame.WriteStringPiece32("alpha");
   }
   // write the length
   frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
 
   SpdyHeaderBlock new_headers;
   scoped_ptr<SpdyFrame> control_frame(frame.take());
   SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
-  std::string serialized_headers(syn_frame.header_block(),
-                                 syn_frame.header_block_len());
+  string serialized_headers(syn_frame.header_block(),
+                            syn_frame.header_block_len());
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   EXPECT_TRUE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
                                               serialized_headers.size(),
                                               &new_headers));
 }
 
 TEST_P(SpdyFramerTest, CreateCredential) {
   SpdyFramer framer(spdy_version_);
 
@@ skipping 85 matching lines @@
     frame.WriteStringPiece32("value1");
     frame.WriteStringPiece32("name");
     frame.WriteStringPiece32("value2");
   }
   // write the length
   frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
 
   SpdyHeaderBlock new_headers;
   scoped_ptr<SpdyFrame> control_frame(frame.take());
   SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
-  std::string serialized_headers(syn_frame.header_block(),
-                                 syn_frame.header_block_len());
+  string serialized_headers(syn_frame.header_block(),
+                            syn_frame.header_block_len());
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   // This should fail because duplicate headers are verboten by the spec.
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
                                                serialized_headers.size(),
                                                &new_headers));
 }
 
 TEST_P(SpdyFramerTest, MultiValueHeader) {
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(SYN_STREAM, CONTROL_FLAG_NONE, 1, 1024);
 
   frame.WriteUInt32(3);  // stream_id
   frame.WriteUInt32(0);  // associated stream id
   frame.WriteUInt16(0);  // Priority.
 
-  std::string value("value1\0value2");
+  string value("value1\0value2");
   if (IsSpdy2()) {
     frame.WriteUInt16(1);  // Number of headers.
     frame.WriteString("name");
     frame.WriteString(value);
   } else {
     frame.WriteUInt32(1);  // Number of headers.
     frame.WriteStringPiece32("name");
     frame.WriteStringPiece32(value);
   }
   // write the length
   frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
 
   SpdyHeaderBlock new_headers;
   scoped_ptr<SpdyFrame> control_frame(frame.take());
   SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
-  std::string serialized_headers(syn_frame.header_block(),
-                                 syn_frame.header_block_len());
+  string serialized_headers(syn_frame.header_block(),
+                            syn_frame.header_block_len());
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   EXPECT_TRUE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
                                               serialized_headers.size(),
                                               &new_headers));
   EXPECT_TRUE(new_headers.find("name") != new_headers.end());
   EXPECT_EQ(value, new_headers.find("name")->second);
 }
 
 TEST_P(SpdyFramerTest, BasicCompression) {
@@ skipping 52 matching lines @@
                              false,  // compress
                              &headers));
   EXPECT_EQ(frame3->length(), uncompressed_frame->length());
   EXPECT_EQ(0,
       memcmp(frame3->data(), uncompressed_frame->data(),
       SpdyFrame::kHeaderSize + uncompressed_frame->length()));
 }
 
 TEST_P(SpdyFramerTest, Basic) {
   const unsigned char kV2Input[] = {
-    0x80, spdy_version_, 0x00, 0x01,   // SYN Stream #1
+    0x80, spdy_version_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x14,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x02, 'h', 'h',
     0x00, 0x02, 'v', 'v',
 
-    0x80, spdy_version_, 0x00, 0x08,   // HEADERS on Stream #1
+    0x80, spdy_version_, 0x00, 0x08,  // HEADERS on Stream #1
     0x00, 0x00, 0x00, 0x18,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x02, 'h', '2',
     0x00, 0x02, 'v', '2',
     0x00, 0x02, 'h', '3',
     0x00, 0x02, 'v', '3',
 
-    0x00, 0x00, 0x00, 0x01,            // DATA on Stream #1
+    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x0c,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x80, spdy_version_, 0x00, 0x01,   // SYN Stream #3
+    0x80, spdy_version_, 0x00, 0x01,  // SYN Stream #3
     0x00, 0x00, 0x00, 0x0c,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
 
-    0x00, 0x00, 0x00, 0x03,            // DATA on Stream #3
+    0x00, 0x00, 0x00, 0x03,           // DATA on Stream #3
     0x00, 0x00, 0x00, 0x08,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x00, 0x00, 0x00, 0x01,            // DATA on Stream #1
+    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x04,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x80, spdy_version_, 0x00, 0x03,   // RST_STREAM on Stream #1
+    0x80, spdy_version_, 0x00, 0x03,  // RST_STREAM on Stream #1
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
 
-    0x00, 0x00, 0x00, 0x03,            // DATA on Stream #3
+    0x00, 0x00, 0x00, 0x03,           // DATA on Stream #3
     0x00, 0x00, 0x00, 0x00,
 
-    0x80, spdy_version_, 0x00, 0x03,   // RST_STREAM on Stream #3
+    0x80, spdy_version_, 0x00, 0x03,  // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x00,
   };
 
   const unsigned char kV3Input[] = {
-    0x80, spdy_version_, 0x00, 0x01,   // SYN Stream #1
+    0x80, spdy_version_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x1a,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x01, 0x00, 0x00,
     0x00, 0x02, 'h', 'h',
     0x00, 0x00, 0x00, 0x02,
     'v', 'v',
 
-    0x80, spdy_version_, 0x00, 0x08,   // HEADERS on Stream #1
+    0x80, spdy_version_, 0x00, 0x08,  // HEADERS on Stream #1
     0x00, 0x00, 0x00, 0x22,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x02, 0x00, 0x00,
     0x00, 0x02, 'h', '2',
     0x00, 0x00, 0x00, 0x02,
     'v', '2', 0x00, 0x00,
     0x00, 0x02, 'h', '3',
     0x00, 0x00, 0x00, 0x02,
     'v', '3',
 
-    0x00, 0x00, 0x00, 0x01,            // DATA on Stream #1
+    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x0c,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x80, spdy_version_, 0x00, 0x01,   // SYN Stream #3
+    0x80, spdy_version_, 0x00, 0x01,  // SYN Stream #3
     0x00, 0x00, 0x00, 0x0e,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00,
 
-    0x00, 0x00, 0x00, 0x03,            // DATA on Stream #3
+    0x00, 0x00, 0x00, 0x03,           // DATA on Stream #3
     0x00, 0x00, 0x00, 0x08,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x00, 0x00, 0x00, 0x01,            // DATA on Stream #1
+    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x04,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x80, spdy_version_, 0x00, 0x03,   // RST_STREAM on Stream #1
+    0x80, spdy_version_, 0x00, 0x03,  // RST_STREAM on Stream #1
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
 
-    0x00, 0x00, 0x00, 0x03,            // DATA on Stream #3
+    0x00, 0x00, 0x00, 0x03,           // DATA on Stream #3
     0x00, 0x00, 0x00, 0x00,
 
-    0x80, spdy_version_, 0x00, 0x03,   // RST_STREAM on Stream #3
+    0x80, spdy_version_, 0x00, 0x03,  // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x00,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
   } else {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(24, visitor.data_bytes_);
   EXPECT_EQ(2, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(4, visitor.data_frame_count_);
 }
 
 // Test that the FIN flag on a data frame signifies EOF.
 TEST_P(SpdyFramerTest, FinOnDataFrame) {
   const unsigned char kV2Input[] = {
-    0x80, spdy_version_, 0x00, 0x01,   // SYN Stream #1
+    0x80, spdy_version_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x14,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x02, 'h', 'h',
     0x00, 0x02, 'v', 'v',
 
-    0x80, spdy_version_, 0x00, 0x02,   // SYN REPLY Stream #1
+    0x80, spdy_version_, 0x00, 0x02,  // SYN REPLY Stream #1
     0x00, 0x00, 0x00, 0x10,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x02, 'a', 'a',
     0x00, 0x02, 'b', 'b',
 
-    0x00, 0x00, 0x00, 0x01,            // DATA on Stream #1
+    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x0c,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x00, 0x00, 0x00, 0x01,            // DATA on Stream #1, with EOF
+    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1, with EOF
     0x01, 0x00, 0x00, 0x04,
     0xde, 0xad, 0xbe, 0xef,
   };
   const unsigned char kV3Input[] = {
-    0x80, spdy_version_, 0x00, 0x01,   // SYN Stream #1
+    0x80, spdy_version_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x1a,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x01, 0x00, 0x00,
     0x00, 0x02, 'h', 'h',
     0x00, 0x00, 0x00, 0x02,
     'v', 'v',
 
-    0x80, spdy_version_, 0x00, 0x02,   // SYN REPLY Stream #1
+    0x80, spdy_version_, 0x00, 0x02,  // SYN REPLY Stream #1
     0x00, 0x00, 0x00, 0x16,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x01, 0x00, 0x00,
     0x00, 0x02, 'a', 'a',
     0x00, 0x00, 0x00, 0x02,
     'b', 'b',
 
-    0x00, 0x00, 0x00, 0x01,            // DATA on Stream #1
+    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x0c,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x00, 0x00, 0x00, 0x01,            // DATA on Stream #1, with EOF
+    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1, with EOF
     0x01, 0x00, 0x00, 0x04,
     0xde, 0xad, 0xbe, 0xef,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
   } else {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_EQ(1, visitor.syn_reply_frame_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
   EXPECT_EQ(16, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(2, visitor.data_frame_count_);
 }
 
 // Test that the FIN flag on a SYN reply frame signifies EOF.
 TEST_P(SpdyFramerTest, FinOnSynReplyFrame) {
   const unsigned char kV2Input[] = {
-    0x80, spdy_version_, 0x00, 0x01,   // SYN Stream #1
+    0x80, spdy_version_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x14,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x02, 'h', 'h',
     0x00, 0x02, 'v', 'v',
 
-    0x80, spdy_version_, 0x00, 0x02,   // SYN REPLY Stream #1
+    0x80, spdy_version_, 0x00, 0x02,  // SYN REPLY Stream #1
     0x01, 0x00, 0x00, 0x14,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x02, 'a', 'a',
     0x00, 0x02, 'b', 'b',
   };
   const unsigned char kV3Input[] = {
-    0x80, spdy_version_, 0x00, 0x01,   // SYN Stream #1
+    0x80, spdy_version_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x1a,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x01, 0x00, 0x00,
     0x00, 0x02, 'h', 'h',
     0x00, 0x00, 0x00, 0x02,
     'v', 'v',
 
-    0x80, spdy_version_, 0x00, 0x02,   // SYN REPLY Stream #1
+    0x80, spdy_version_, 0x00, 0x02,  // SYN REPLY Stream #1
     0x01, 0x00, 0x00, 0x1a,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x01, 0x00, 0x00,
     0x00, 0x02, 'a', 'a',
     0x00, 0x00, 0x00, 0x02,
     'b', 'b',
   };
 
@@ skipping 52 matching lines @@
                                   0,  // priority
                                   0,  // credential slot
                                   flags,
                                   true,  // compress
                                   &block));
   EXPECT_TRUE(syn_frame_2.get() != NULL);
 
   // Now start decompressing
   scoped_ptr<SpdyFrame> decompressed;
   scoped_ptr<SpdySynStreamControlFrame> syn_frame;
-  scoped_ptr<std::string> serialized_headers;
+  scoped_ptr<string> serialized_headers;
   SpdyHeaderBlock decompressed_headers;
 
   // Decompress SYN_STREAM #1
   decompressed.reset(SpdyFramerTestUtil::DecompressFrame(
       &recv_framer, *syn_frame_1.get()));
   EXPECT_TRUE(decompressed.get() != NULL);
   EXPECT_TRUE(decompressed->is_control_frame());
   EXPECT_EQ(SYN_STREAM,
             reinterpret_cast<SpdyControlFrame*>(decompressed.get())->type());
   syn_frame.reset(new SpdySynStreamControlFrame(decompressed->data(), false));
-  serialized_headers.reset(new std::string(syn_frame->header_block(),
-                                           syn_frame->header_block_len()));
+  serialized_headers.reset(new string(syn_frame->header_block(),
+                                      syn_frame->header_block_len()));
   EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers->c_str(),
                                                    serialized_headers->size(),
                                                    &decompressed_headers));
   EXPECT_EQ(2u, decompressed_headers.size());
   EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
   EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
 
   // Decompress SYN_STREAM #2
   decompressed.reset(SpdyFramerTestUtil::DecompressFrame(
       &recv_framer, *syn_frame_2.get()));
   EXPECT_TRUE(decompressed.get() != NULL);
   EXPECT_TRUE(decompressed->is_control_frame());
   EXPECT_EQ(SYN_STREAM,
             reinterpret_cast<SpdyControlFrame*>(decompressed.get())->type());
   syn_frame.reset(new SpdySynStreamControlFrame(decompressed->data(), false));
-  serialized_headers.reset(new std::string(syn_frame->header_block(),
-                                           syn_frame->header_block_len()));
+  serialized_headers.reset(new string(syn_frame->header_block(),
+                                      syn_frame->header_block_len()));
   decompressed_headers.clear();
   EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers->c_str(),
                                                    serialized_headers->size(),
                                                    &decompressed_headers));
   EXPECT_EQ(3u, decompressed_headers.size());
   EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
   EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
   EXPECT_EQ(kValue3, decompressed_headers[kHeader3]);
 }
 
@@ skipping 135 matching lines @@
   {
     const char kDescription[] = "'hello' data frame, no FIN";
     const unsigned char kFrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h', 'e', 'l', 'l',
       'o'
     };
     const char bytes[] = "hello";
     scoped_ptr<SpdyFrame> frame(framer.CreateDataFrame(
-        1, bytes, arraysize(bytes) - 1, DATA_FLAG_NONE));
+        1, bytes, strlen(bytes), DATA_FLAG_NONE));
     CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
   }
 
   {
     const char kDescription[] = "Data frame with negative data byte, no FIN";
     const unsigned char kFrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
       0xff
     };
@@ skipping 35 matching lines @@
       'o'
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateDataFrame(
         0x7fffffff, "hello", 5, DATA_FLAG_FIN));
     CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
   }
 
   {
     const char kDescription[] = "Large data frame";
     const int kDataSize = 4 * 1024 * 1024;  // 4 MB
-    const std::string kData(kDataSize, 'A');
+    const string kData(kDataSize, 'A');
     const unsigned char kFrameHeader[] = {
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x40, 0x00, 0x00,
     };
 
     const int kFrameSize = arraysize(kFrameHeader) + kDataSize;
     scoped_array<unsigned char> expected_frame_data(
         new unsigned char[kFrameSize]);
     memcpy(expected_frame_data.get(), kFrameHeader, arraysize(kFrameHeader));
     memset(expected_frame_data.get() + arraysize(kFrameHeader), 'A', kDataSize);
 
     scoped_ptr<SpdyFrame> frame(framer.CreateDataFrame(
         1, kData.data(), kData.size(), DATA_FLAG_FIN));
     CompareFrame(kDescription, *frame, expected_frame_data.get(), kFrameSize);
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "SYN_STREAM frame, lowest pri, slot 2, no FIN";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "bar";
 
-    const unsigned char kPri = (IsSpdy2()) ? 0xC0 : 0xE0;
-    const unsigned char kCre = (IsSpdy2()) ? 0 : 2;
+    const unsigned char kPri = IsSpdy2() ? 0xC0 : 0xE0;
+    const unsigned char kCre = IsSpdy2() ? 0 : 2;
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x20,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
       kPri, 0x00, 0x00, 0x02,
       0x00, 0x03, 'b',  'a',
       'r',  0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x03,
       'f',  'o',  'o',  0x00,
@@ skipping 80 matching lines @@
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header val, high pri, FIN, "
         "max stream ID";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "";
 
-    const unsigned char kPri = (spdy_version_ != 2) ? 0x20 : 0x40;
+    const unsigned char kPri = IsSpdy2() ? 0x40 : 0x20;
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x1D,
       0x7f, 0xff, 0xff, 0xff,
       0x7f, 0xff, 0xff, 0xff,
       kPri, 0x00, 0x00, 0x02,
       0x00, 0x03, 'b',  'a',
       'r',  0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x03,
       'f',  'o',  'o',  0x00,
@@ skipping 33 matching lines @@
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] =
         "SYN_STREAM frame, low pri, no FIN";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "bar";
 
-    const SpdyPriority priority = (spdy_version_ != 2) ? 4 : 2;
+    const SpdyPriority priority = IsSpdy2() ? 2 : 4;
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x25,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
       0x80, 0x00, 0x38, 0xea,
       0xdf, 0xa2, 0x51, 0xb2,
       0x62, 0x60, 0x62, 0x60,
       0x4e, 0x4a, 0x2c, 0x62,
       0x60, 0x4e, 0xcb, 0xcf,
@@ skipping 142 matching lines @@
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x00
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateSynReply(
         0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (IsSpdy2()) ? kV2FrameData : kV3FrameData,
-                 (IsSpdy2()) ? arraysize(kV2FrameData)
-                                     : arraysize(kV3FrameData));
+                 IsSpdy2() ? kV2FrameData : kV3FrameData,
+                 IsSpdy2() ? arraysize(kV2FrameData) : arraysize(kV3FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSynReplyCompressed) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] = "SYN_REPLY frame, no FIN";
 
@@ skipping 24 matching lines @@
       0x4a, 0x04, 0xe5, 0x0b,
       0xe6, 0xb4, 0xfc, 0x7c,
       0x24, 0x0a, 0x28, 0x08,
       0x00, 0x00, 0x00, 0xff,
       0xff
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateSynReply(
         1, CONTROL_FLAG_NONE, true, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (IsSpdy2()) ? kV2FrameData : kV3FrameData,
-                 (IsSpdy2()) ? arraysize(kV2FrameData)
-                                     : arraysize(kV3FrameData));
+                 IsSpdy2() ? kV2FrameData : kV3FrameData,
+                 IsSpdy2() ? arraysize(kV2FrameData) : arraysize(kV3FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateRstStream) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "RST_STREAM frame";
     const unsigned char kFrameData[] = {
       0x80, spdy_version_, 0x00, 0x03,
@@ skipping 62 matching lines @@
       0x80, spdy_version_, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x0c,
       0x00, 0x00, 0x00, 0x01,
       0x04, 0x03, 0x02, 0x01,
       0x0a, 0x0b, 0x0c, 0x0d,
     };
 
     scoped_ptr<SpdySettingsControlFrame> frame(framer.CreateSettings(settings));
     CompareFrame(kDescription,
                  *frame,
-                 (IsSpdy2()) ? kFrameDatav2 : kFrameDatav3,
+                 IsSpdy2() ? kFrameDatav2 : kFrameDatav3,
                  arraysize(kFrameDatav3));  // Size is unchanged among versions.
     EXPECT_EQ(SpdyFramer::kInvalidStream,
               SpdyFramer::GetControlFrameStreamId(frame.get()));
 
     // Make sure that ParseSettings also works as advertised.
     SettingsMap parsed_settings;
     EXPECT_TRUE(framer.ParseSettings(frame.get(), &parsed_settings));
     EXPECT_EQ(settings.size(), parsed_settings.size());
     EXPECT_EQ(kFlags, parsed_settings[kId].first);
     EXPECT_EQ(kValue, parsed_settings[kId].second);
@@ skipping 87 matching lines @@
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00,
     };
     scoped_ptr<SpdyGoAwayControlFrame> frame(framer.CreateGoAway(0, GOAWAY_OK));
     CompareFrame(kDescription,
                  *frame,
                  IsSpdy2() ? kV2FrameData : kV3FrameData,
-                 IsSpdy2() ? arraysize(kV2FrameData)
-                           : arraysize(kV3FrameData));
+                 IsSpdy2() ? arraysize(kV2FrameData) : arraysize(kV3FrameData));
     EXPECT_EQ(SpdyFramer::kInvalidStream,
               SpdyFramer::GetControlFrameStreamId(frame.get()));
   }
 
   {
     const char kDescription[] = "GOAWAY frame with max stream ID, status";
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x04,
       0x7f, 0xff, 0xff, 0xff,
     };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x02,
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateGoAway(0x7FFFFFFF,
                                                     GOAWAY_INTERNAL_ERROR));
     CompareFrame(kDescription,
                  *frame,
                  IsSpdy2() ? kV2FrameData : kV3FrameData,
-                 IsSpdy2() ? arraysize(kV2FrameData)
-                           : arraysize(kV3FrameData));
+                 IsSpdy2() ? arraysize(kV2FrameData) : arraysize(kV3FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateHeadersUncompressed) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
 
@@ skipping 22 matching lines @@
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x03, 'b',  'a',  'r'
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
         1, CONTROL_FLAG_NONE, false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (IsSpdy2()) ? kV2FrameData : kV3FrameData,
-                 (IsSpdy2()) ? arraysize(kV2FrameData)
-                                     : arraysize(kV3FrameData));
+                 IsSpdy2() ? kV2FrameData : kV3FrameData,
+                 IsSpdy2() ? arraysize(kV2FrameData) : arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header name, FIN, max stream ID";
 
     SpdyHeaderBlock headers;
     headers[""] = "foo";
     headers["foo"] = "bar";
 
@@ skipping 19 matching lines @@
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r'
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
         0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
     CompareFrame(kDescription,
                  *frame,
                  IsSpdy2() ? kV2FrameData : kV3FrameData,
-                 IsSpdy2() ? arraysize(kV2FrameData)
-                           : arraysize(kV3FrameData));
+                 IsSpdy2() ? arraysize(kV2FrameData) : arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "";
 
@@ skipping 19 matching lines @@
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x00
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
         0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
     CompareFrame(kDescription,
                  *frame,
                  IsSpdy2() ? kV2FrameData : kV3FrameData,
-                 IsSpdy2() ? arraysize(kV2FrameData)
-                           : arraysize(kV3FrameData));
+                 IsSpdy2() ? arraysize(kV2FrameData) : arraysize(kV3FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateHeadersCompressed) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
 
@@ skipping 25 matching lines @@
       0xe6, 0xb4, 0xfc, 0x7c,
       0x24, 0x0a, 0x28, 0x08,
       0x00, 0x00, 0x00, 0xff,
       0xff
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
         1, CONTROL_FLAG_NONE, true, &headers));
     CompareFrame(kDescription,
                  *frame,
                  IsSpdy2() ? kV2FrameData : kV3FrameData,
-                 IsSpdy2() ? arraysize(kV2FrameData)
-                           : arraysize(kV3FrameData));
+                 IsSpdy2() ? arraysize(kV2FrameData) : arraysize(kV3FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateWindowUpdate) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame";
     const unsigned char kFrameData[] = {
       0x80, spdy_version_, 0x00, 0x09,
@@ skipping 61 matching lines @@
                              1,                     // priority
                              0,                     // credential_slot
                              CONTROL_FLAG_NONE,
                              true,                  // compress
                              &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
-       control_frame->length() + SpdyControlFrame::kHeaderSize);
+      control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedSynReplyHeaderBlock) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdySynReplyControlFrame> control_frame(
       framer.CreateSynReply(1,                     // stream_id
                             CONTROL_FLAG_NONE,
                             true,                  // compress
                             &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
+      control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.syn_reply_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyHeadersControlFrame> control_frame(
       framer.CreateHeaders(1,                     // stream_id
                            CONTROL_FLAG_NONE,
                            true,                  // compress
                            &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
+      control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   // control_frame_header_data_count_ depends on the random sequence
   // produced by rand(), so adding, removing or running single tests
   // alters this value.  The best we can do is assert that it happens
   // at least twice.
   EXPECT_LE(2, visitor.control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyHeadersControlFrame> control_frame(
       framer.CreateHeaders(1,                     // stream_id
                            CONTROL_FLAG_FIN,
                            true,                  // compress
                            &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
-       control_frame->length() + SpdyControlFrame::kHeaderSize);
+      control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   // control_frame_header_data_count_ depends on the random sequence
   // produced by rand(), so adding, removing or running single tests
   // alters this value.  The best we can do is assert that it happens
   // at least twice.
   EXPECT_LE(2, visitor.control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
@@ skipping 52 matching lines @@
                              0,                     // associated_stream_id
                              1,                     // priority
                              0,                     // credential_slot
                              CONTROL_FLAG_NONE,
                              false,                 // compress
                              &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
+      control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_FALSE(visitor.header_buffer_valid_);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE,
             visitor.framer_.error_code());
   EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 // Check that the framer stops delivering header data chunks once the visitor
 // declares it doesn't want any more. This is important to guard against
@@ skipping 14 matching lines @@
                              0,                     // credential_slot
                              CONTROL_FLAG_FIN,      // half close
                              true,                  // compress
                              &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.set_header_buffer_size(kHeaderBufferSize);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
-       control_frame->length() + SpdyControlFrame::kHeaderSize);
+      control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_FALSE(visitor.header_buffer_valid_);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE,
             visitor.framer_.error_code());
 
   // The framer should have stoped delivering chunks after the visitor
   // signaled "stop" by returning false from OnControlFrameHeaderData().
   //
   // control_frame_header_data_count_ depends on the random sequence
   // produced by rand(), so adding, removing or running single tests
@@ skipping 19 matching lines @@
                              0,                     // associated_stream_id
                              1,                     // priority
                              0,                     // credential_slot
                              CONTROL_FLAG_NONE,
                              false,                 // compress
                              &headers));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
-       control_frame->length() + SpdyControlFrame::kHeaderSize);
+      control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_DECOMPRESS_FAILURE, visitor.framer_.error_code());
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameSizesAreValidated) {
   // Create a GoAway frame that has a few extra bytes at the end.
   // We create enough overhead to overflow the framer's control frame buffer.
   size_t overhead = SpdyFramer::kControlFrameBufferSize;
-
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyGoAwayControlFrame> goaway(framer.CreateGoAway(1, GOAWAY_OK));
   goaway->set_length(goaway->length() + overhead);
-  std::string pad('A', overhead);
+  string pad('A', overhead);
   TestSpdyVisitor visitor(spdy_version_);
 
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(goaway->data()),
       goaway->length() - overhead + SpdyControlFrame::kHeaderSize);
   visitor.SimulateInFramer(
       reinterpret_cast<const unsigned char*>(pad.c_str()),
       overhead);
+
   EXPECT_EQ(1, visitor.error_count_);  // This generated an error.
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code());
   EXPECT_EQ(0, visitor.goaway_count_);  // Frame not parsed.
 }
 
 TEST_P(SpdyFramerTest, ReadZeroLenSettingsFrame) {
   SpdyFramer framer(spdy_version_);
   SettingsMap settings;
   scoped_ptr<SpdyFrame> control_frame(framer.CreateSettings(settings));
   control_frame->set_length(0);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
+      control_frame->length() + SpdyControlFrame::kHeaderSize);
   // Should generate an error, since zero-len settings frames are unsupported.
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frames with invalid length.
 TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) {
   SpdyFramer framer(spdy_version_);
   SettingsMap settings;
   // Add a setting to pad the frame so that we don't get a buffer overflow when
   // calling SimulateInFramer() below.
   settings[SETTINGS_UPLOAD_BANDWIDTH] =
-      SettingsFlagsAndValue(SETTINGS_FLAG_NONE, 0x00000002);
+      SettingsFlagsAndValue(SETTINGS_FLAG_PLEASE_PERSIST, 0x00000002);
   scoped_ptr<SpdyFrame> control_frame(framer.CreateSettings(settings));
   control_frame->set_length(5);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
+      control_frame->length() + SpdyControlFrame::kHeaderSize);
   // Should generate an error, since zero-len settings frames are unsupported.
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frames larger than the frame buffer size.
 TEST_P(SpdyFramerTest, ReadLargeSettingsFrame) {
   SpdyFramer framer(spdy_version_);
   SettingsMap settings;
-  SpdySettingsFlags flags = SETTINGS_FLAG_NONE;
+  SpdySettingsFlags flags = SETTINGS_FLAG_PLEASE_PERSIST;
   settings[SETTINGS_UPLOAD_BANDWIDTH] =
       SettingsFlagsAndValue(flags, 0x00000002);
   settings[SETTINGS_DOWNLOAD_BANDWIDTH] =
       SettingsFlagsAndValue(flags, 0x00000003);
   settings[SETTINGS_ROUND_TRIP_TIME] = SettingsFlagsAndValue(flags, 0x00000004);
   scoped_ptr<SpdyFrame> control_frame(framer.CreateSettings(settings));
   EXPECT_LT(SpdyFramer::kControlFrameBufferSize,
             control_frame->length() + SpdyControlFrame::kHeaderSize);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
 
   // Read all at once.
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(settings.size(), static_cast<unsigned>(visitor.setting_count_));
   EXPECT_EQ(1, visitor.settings_frame_count_);
 
   // Read data in small chunks.
   size_t framed_data = 0;
   size_t unframed_data = control_frame->length() +
                          SpdyControlFrame::kHeaderSize;
   size_t kReadChunkSize = 5;  // Read five bytes at a time.
   while (unframed_data > 0) {
-    size_t to_read = std::min(kReadChunkSize, unframed_data);
+    size_t to_read = min(kReadChunkSize, unframed_data);
     visitor.SimulateInFramer(
         reinterpret_cast<unsigned char*>(control_frame->data() + framed_data),
         to_read);
     unframed_data -= to_read;
     framed_data += to_read;
   }
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(settings.size() * 2, static_cast<unsigned>(visitor.setting_count_));
   EXPECT_EQ(2, visitor.settings_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, ReadCredentialFrame) {
   SpdyCredential credential;
   credential.slot = 3;
   credential.proof = "proof";
   credential.certs.push_back("a cert");
   credential.certs.push_back("another cert");
   credential.certs.push_back("final cert");
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateCredentialFrame(credential));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame.get()->data()),
-      control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
+      reinterpret_cast<unsigned char*>(control_frame->data()),
+      control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.credential_count_);
   EXPECT_EQ(control_frame->length(), visitor.credential_buffer_length_);
   EXPECT_EQ(credential.slot, visitor.credential_.slot);
   EXPECT_EQ(credential.proof, visitor.credential_.proof);
   EXPECT_EQ(credential.certs.size(), visitor.credential_.certs.size());
   for (size_t i = 0; i < credential.certs.size(); i++) {
     EXPECT_EQ(credential.certs[i], visitor.credential_.certs[i]);
   }
 }
@@ skipping 58 matching lines @@
   credential.certs.push_back("a cert");
   credential.certs.push_back("another cert");
   credential.certs.push_back("final cert");
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateCredentialFrame(credential));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   unsigned char* data =
-      reinterpret_cast<unsigned char*>(control_frame.get()->data());
+      reinterpret_cast<unsigned char*>(control_frame->data());
   size_t offset = SpdyControlFrame::kHeaderSize + 4;
   data[offset] = 0xFF;  // Proof length is past the end of the frame
   visitor.SimulateInFramer(
-      data, control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
+      data, control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_P(SpdyFramerTest, ReadCredentialFrameWithCorruptCertificate) {
   SpdyCredential credential;
   credential.slot = 3;
   credential.proof = "proof";
   credential.certs.push_back("a cert");
   credential.certs.push_back("another cert");
   credential.certs.push_back("final cert");
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateCredentialFrame(credential));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   unsigned char* data =
-      reinterpret_cast<unsigned char*>(control_frame.get()->data());
+      reinterpret_cast<unsigned char*>(control_frame->data());
   size_t offset = SpdyControlFrame::kHeaderSize + credential.proof.length();
   data[offset] = 0xFF;  // Certificate length is past the end of the frame
   visitor.SimulateInFramer(
-      data, control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
+      data, control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_P(SpdyFramerTest, ReadGarbage) {
   SpdyFramer framer(spdy_version_);
   unsigned char garbage_frame[256];
   memset(garbage_frame, ~0, sizeof(garbage_frame));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(garbage_frame, sizeof(garbage_frame));
@@ skipping 155 matching lines @@
                                                    GOAWAY));
   EXPECT_EQ(SpdyHeadersControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(spdy_version_,
                                                    HEADERS));
   EXPECT_EQ(SpdyWindowUpdateControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(spdy_version_,
                                                    WINDOW_UPDATE));
   EXPECT_EQ(SpdyCredentialControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(spdy_version_,
                                                    CREDENTIAL));
-  EXPECT_EQ(static_cast<size_t>(0x7FFFFFFF),
+  EXPECT_EQ(numeric_limits<size_t>::max(),
             SpdyFramer::GetMinimumControlFrameSize(spdy_version_,
                                                    NUM_CONTROL_FRAME_TYPES));
 }
 
 TEST_P(SpdyFramerTest, CatchProbableHttpResponse) {
   {
     testing::StrictMock<test::MockVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
@@ skipping 64 matching lines @@
 
   size_t frame_size = frame->length() + SpdyFrame::kHeaderSize;
   framer.ProcessInput(frame->data(), frame_size);
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, SettingsFlagsAndId) {
   const uint32 kId = 0x020304;
   const uint32 kFlags = 0x01;
-  const uint32 kWireFormat =
-      htonl(IsSpdy2() ? 0x04030201 : 0x01020304);
+  const uint32 kWireFormat = htonl(IsSpdy2() ? 0x04030201 : 0x01020304);
 
   SettingsFlagsAndId id_and_flags =
       SettingsFlagsAndId::FromWireFormat(spdy_version_, kWireFormat);
   EXPECT_EQ(kId, id_and_flags.id());
   EXPECT_EQ(kFlags, id_and_flags.flags());
   EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat(spdy_version_));
 }
 
 }  // namespace net