Add SpdyString alias for std::string in net/spdy.

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 "net/spdy/spdy_framer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <cstdint>
 #include <limits>
 #include <memory>
-#include <string>
 #include <tuple>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/spdy/array_output_buffer.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/mock_spdy_framer_visitor.h"
 #include "net/spdy/spdy_flags.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_frame_reader.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
-using std::string;
 using testing::_;
 
 namespace net {
 
 namespace test {
 
 namespace {
 
 const int64_t kSize = 64 * 1024;
 char output_buffer[kSize] = "";
@@ skipping 417 matching lines @@
   }
 
   void OnAltSvc(SpdyStreamId stream_id,
                 SpdyStringPiece origin,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                     altsvc_vector) override {
     VLOG(1) << "OnAltSvc(" << stream_id << ", \"" << origin
             << "\", altsvc_vector)";
     test_altsvc_ir_.set_stream_id(stream_id);
     if (origin.length() > 0) {
-      test_altsvc_ir_.set_origin(std::string(origin));
+      test_altsvc_ir_.set_origin(SpdyString(origin));
     }
     for (const SpdyAltSvcWireFormat::AlternativeService& altsvc :
          altsvc_vector) {
       test_altsvc_ir_.add_altsvc(altsvc);
     }
     ++altsvc_count_;
   }
 
   void OnPriority(SpdyStreamId stream_id,
                   SpdyStreamId parent_stream_id,
@@ skipping 153 matching lines @@
   // OnFramePayload.
   void OnFramePayload(const char* data, size_t len) override {
     payload_.append(data, len);
   }
 
   std::vector<std::pair<uint16_t, uint32_t>> settings_received_;
   SpdyStreamId stream_id_ = 0;
   size_t length_ = 0;
   uint8_t type_ = 0;
   uint8_t flags_ = 0;
-  string payload_;
+  SpdyString payload_;
 };
 
 // Retrieves serialized headers from a HEADERS frame.
 SpdyStringPiece GetSerializedHeaders(const SpdySerializedFrame& frame,
                                      const SpdyFramer& framer) {
   SpdyFrameReader reader(frame.data(), frame.size());
   reader.Seek(3);  // Seek past the frame length.
 
   uint8_t serialized_type;
   reader.ReadUInt8(&serialized_type);
@@ skipping 46 matching lines @@
         use_output_ = true;
         break;
       case NOT_USE:
         // TODO(yasong): remove this case after
         // FLAGS_chromium_http2_flag_remove_rewritelength deprecates.
         use_output_ = false;
         break;
     }
   }
 
-  void CompareFrame(const string& description,
+  void CompareFrame(const SpdyString& description,
                     const SpdySerializedFrame& actual_frame,
                     const unsigned char* expected,
                     const int expected_len) {
     const unsigned char* actual =
         reinterpret_cast<const unsigned char*>(actual_frame.data());
     CompareCharArraysWithHexError(description, actual, actual_frame.size(),
                                   expected, expected_len);
   }
 
-  void CompareFrames(const string& description,
+  void CompareFrames(const SpdyString& description,
                      const SpdySerializedFrame& expected_frame,
                      const SpdySerializedFrame& actual_frame) {
     CompareCharArraysWithHexError(
         description,
         reinterpret_cast<const unsigned char*>(expected_frame.data()),
         expected_frame.size(),
         reinterpret_cast<const unsigned char*>(actual_frame.data()),
         actual_frame.size());
   }
 
@@ skipping 431 matching lines @@
 
 // Test that if we receive a CONTINUATION with stream ID zero, we signal an
 // SPDY_INVALID_STREAM_ID.
 TEST_P(SpdyFramerTest, ContinuationWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyContinuationIR continuation(0);
   auto some_nonsense_encoding =
-      base::MakeUnique<string>("some nonsense encoding");
+      base::MakeUnique<SpdyString>("some nonsense encoding");
   continuation.take_encoding(std::move(some_nonsense_encoding));
   continuation.set_end_headers(true);
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
   if (use_output_) {
     ASSERT_TRUE(framer.SerializeContinuation(continuation, &output_));
     frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
   }
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
@@ skipping 73 matching lines @@
 
 TEST_P(SpdyFramerTest, MultiValueHeader) {
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, SpdyFrameType::HEADERS,
                       HEADERS_FLAG_PRIORITY | HEADERS_FLAG_END_HEADERS, 3);
   frame.WriteUInt32(0);   // Priority exclusivity and dependent stream.
   frame.WriteUInt8(255);  // Priority weight.
 
-  string value("value1\0value2", 13);
+  SpdyString value("value1\0value2", 13);
   // TODO(jgraettinger): If this pattern appears again, move to test class.
   SpdyHeaderBlock header_set;
   header_set["name"] = value;
-  string buffer;
+  SpdyString buffer;
   HpackEncoder encoder(ObtainHpackHuffmanTable());
   encoder.DisableCompression();
   encoder.EncodeHeaderSet(header_set, &buffer);
   frame.WriteBytes(&buffer[0], buffer.size());
   // write the length
   frame.OverwriteLength(framer, frame.length() - framer.GetFrameHeaderSize());
 
   SpdySerializedFrame control_frame(frame.take());
 
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
@@ skipping 1184 matching lines @@
       0x03,              // Name Len: 3
       0x66, 0x6f, 0x6f,  // foo
       0x03,              // Value Len: 3
       0x62, 0x61, 0x72,  // bar
   };
   // frame-format on
 
   SpdyHeaderBlock header_block;
   header_block["bar"] = "foo";
   header_block["foo"] = "bar";
-  auto buffer = base::MakeUnique<string>();
+  auto buffer = base::MakeUnique<SpdyString>();
   HpackEncoder encoder(ObtainHpackHuffmanTable());
   encoder.DisableCompression();
   encoder.EncodeHeaderSet(header_block, buffer.get());
 
   SpdyContinuationIR continuation(42);
   continuation.take_encoding(std::move(buffer));
   continuation.set_end_headers(true);
 
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
   if (use_output_) {
@@ skipping 94 matching lines @@
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78,                    // x
     };
     // frame-format on
 
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.set_padding_len(1);
-    string big_value(TestSpdyVisitor::sent_control_frame_max_size(), 'x');
+    SpdyString big_value(TestSpdyVisitor::sent_control_frame_max_size(), 'x');
     push_promise.SetHeader("xxx", big_value);
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     if (use_output_) {
       ASSERT_TRUE(framer.SerializePushPromise(push_promise, &output_));
       frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
     }
 
     // The entire frame should look like below:
     // Name                     Length in Byte
     // ------------------------------------------- Begin of PUSH_PROMISE frame
@@ skipping 129 matching lines @@
 }
 
 TEST_P(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) {
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   SpdyHeadersIR headers(1);
   headers.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
-  string big_value(kBigValueSize, 'x');
+  SpdyString big_value(kBigValueSize, 'x');
   headers.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(SpdyFramerPeer::SerializeHeaders(
       &framer, headers, use_output_ ? &output_ : nullptr));
   EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 }
 
 TEST_P(SpdyFramerTest, MultipleContinuationFramesWithIterator) {
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   auto headers = base::MakeUnique<SpdyHeadersIR>(1);
   headers->set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
-  string big_valuex(kBigValueSize, 'x');
+  SpdyString big_valuex(kBigValueSize, 'x');
   headers->SetHeader("aa", big_valuex);
-  string big_valuez(kBigValueSize, 'z');
+  SpdyString big_valuez(kBigValueSize, 'z');
   headers->SetHeader("bb", big_valuez);
 
   SpdyFramer::SpdyHeaderFrameIterator frame_it(&framer, std::move(headers));
 
   EXPECT_TRUE(frame_it.HasNextFrame());
   SpdySerializedFrame headers_frame(frame_it.NextFrame());
   EXPECT_EQ(headers_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
@@ skipping 38 matching lines @@
 }
 
 TEST_P(SpdyFramerTest, TooLargePushPromiseFrameUsesContinuation) {
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   SpdyPushPromiseIR push_promise(1, 2);
   push_promise.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
-  string big_value(kBigValueSize, 'x');
+  SpdyString big_value(kBigValueSize, 'x');
   push_promise.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(framer.SerializePushPromise(push_promise));
   if (use_output_) {
     ASSERT_TRUE(framer.SerializePushPromise(push_promise, &output_));
     control_frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
   }
   EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.push_promise_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 }
 
 // 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
 // "zip bomb" types of attacks.
 TEST_P(SpdyFramerTest, ControlFrameMuchTooLarge) {
   const size_t kHeaderBufferChunks = 4;
   const size_t kHeaderBufferSize =
       TestSpdyVisitor::header_data_chunk_max_size() * kHeaderBufferChunks;
   const size_t kBigValueSize = kHeaderBufferSize * 2;
-  string big_value(kBigValueSize, 'x');
+  SpdyString big_value(kBigValueSize, 'x');
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdyHeadersIR headers(1);
   headers.set_fin(true);
   headers.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(SpdyFramerPeer::SerializeHeaders(
       &framer, headers, use_output_ ? &output_ : nullptr));
   TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION);
   visitor.set_header_buffer_size(kHeaderBufferSize);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
@@ skipping 20 matching lines @@
   const unsigned char kH2Len = static_cast<unsigned char>(less_than_min_length);
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, kH2Len,        // Length: min length - 1
       0x07,                      //   Type: GOAWAY
       0x00,                      //  Flags: none
       0x00, 0x00, 0x00,   0x00,  // Stream: 0
       0x00, 0x00, 0x00,   0x00,  //   Last: 0
       0x00, 0x00, 0x00,          // Truncated Status Field
   };
   const size_t pad_length = length + kFrameHeaderSize - sizeof(kH2FrameData);
-  string pad(pad_length, 'A');
+  SpdyString pad(pad_length, 'A');
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
 
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
   visitor.SimulateInFramer(reinterpret_cast<const unsigned char*>(pad.c_str()),
                            pad.length());
 
   EXPECT_EQ(1, visitor.error_count_);  // This generated an error.
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(
@@ skipping 743 matching lines @@
   };
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   TestExtension extension;
   visitor.set_extension_visitor(&extension);
   visitor.SimulateInFramer(unknown_frame, arraysize(unknown_frame));
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0x7fffffffu, extension.stream_id_);
   EXPECT_EQ(20u, extension.length_);
   EXPECT_EQ(255, extension.type_);
   EXPECT_EQ(0xff, extension.flags_);
-  EXPECT_EQ(string(20, '\xff'), extension.payload_);
+  EXPECT_EQ(SpdyString(20, '\xff'), extension.payload_);
 
   // Follow it up with a valid control frame to make sure we handle
   // subsequent frames correctly.
   SpdySettingsIR settings_ir;
   settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE, 10);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(0, visitor.error_count_);
@@ skipping 923 matching lines @@
   // change the order and type of frames).
   SpdySerializedFrame frame1 = std::move(headers_frame);
   SpdySerializedFrame frame2 = std::move(four_score_frame);
 
   const size_t frame1_size = frame1.size();
   const size_t frame2_size = frame2.size();
 
   VLOG(1) << "frame1_size = " << frame1_size;
   VLOG(1) << "frame2_size = " << frame2_size;
 
-  string input_buffer;
+  SpdyString input_buffer;
   input_buffer.append(frame1.data(), frame1_size);
   input_buffer.append(frame2.data(), frame2_size);
 
   const char* buf = input_buffer.data();
   const size_t buf_size = input_buffer.size();
 
   VLOG(1) << "buf_size = " << buf_size;
 
   size_t processed = framer.ProcessInput(buf, buf_size);
   EXPECT_EQ(buf_size, processed);
@@ skipping 28 matching lines @@
   // change the order and type of frames).
   SpdySerializedFrame frame1 = std::move(four_score_frame);
   SpdySerializedFrame frame2 = std::move(headers_frame);
 
   const size_t frame1_size = frame1.size();
   const size_t frame2_size = frame2.size();
 
   VLOG(1) << "frame1_size = " << frame1_size;
   VLOG(1) << "frame2_size = " << frame2_size;
 
-  string input_buffer;
+  SpdyString input_buffer;
   input_buffer.append(frame1.data(), frame1_size);
   input_buffer.append(frame2.data(), frame2_size);
 
   const char* buf = input_buffer.data();
   const size_t buf_size = input_buffer.size();
 
   VLOG(1) << "buf_size = " << buf_size;
 
   for (size_t first_size = 0; first_size <= buf_size; ++first_size) {
     VLOG(1) << "first_size = " << first_size;
@@ skipping 33 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net