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

net/spdy/spdy_deframer_visitor.cc

 // Copyright 2016 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_deframer_visitor.h"
 
 #include <stdlib.h>
-#include <string.h>
 
 #include <algorithm>
 #include <cstdint>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/mock_spdy_framer_visitor.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"
 
 using ::base::MakeUnique;
-using ::std::string;
 using ::testing::AssertionFailure;
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
 
 namespace net {
 namespace test {
 
 // Specify whether to process headers as request or response in visitor-related
 // params.
 enum class HeaderDirection { REQUEST, RESPONSE };
@@ skipping 170 matching lines @@
 
   // Per-HPACK block state. Only valid while processing a HEADERS or
   // PUSH_PROMISE frame, and its CONTINUATION frames.
   // Did the most recent HEADERS or PUSH_PROMISE include the END_STREAM flag?
   // Note that this does not necessarily indicate that the current frame is
   // the last frame for the stream (may be followed by CONTINUATION frames,
   // may only half close).
   bool fin_ = false;
   bool got_hpack_end_ = false;
 
-  std::unique_ptr<string> data_;
+  std::unique_ptr<SpdyString> data_;
 
   // Total length of the data frame.
   size_t data_len_ = 0;
 
   // Amount of skipped padding (i.e. total length of padding, including Pad
   // Length field).
   size_t padding_len_ = 0;
 
-  std::unique_ptr<string> goaway_description_;
+  std::unique_ptr<SpdyString> goaway_description_;
   std::unique_ptr<StringPairVector> headers_;
   std::unique_ptr<SettingVector> settings_;
   std::unique_ptr<TestHeadersHandler> headers_handler_;
 
   std::unique_ptr<SpdyGoAwayIR> goaway_ir_;
   std::unique_ptr<SpdyHeadersIR> headers_ir_;
   std::unique_ptr<SpdyPushPromiseIR> push_promise_ir_;
   std::unique_ptr<SpdySettingsIR> settings_ir_;
 
  private:
@@ skipping 176 matching lines @@
 
 void SpdyTestDeframerImpl::OnAltSvc(
     SpdyStreamId stream_id,
     SpdyStringPiece origin,
     const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {
   DVLOG(1) << "OnAltSvc stream_id: " << stream_id;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_GT(stream_id, 0u);
   auto ptr = MakeUnique<SpdyAltSvcIR>(stream_id);
-  ptr->set_origin(std::string(origin));
+  ptr->set_origin(SpdyString(origin));
   for (auto& altsvc : altsvc_vector) {
     ptr->add_altsvc(altsvc);
   }
   listener_->OnAltSvc(std::move(ptr));
 }
 
 // A CONTINUATION frame contains a Header Block Fragment, and immediately
 // follows another frame that contains a Header Block Fragment (HEADERS,
 // PUSH_PROMISE or CONTINUATION). The last such frame has the END flag set.
 // SpdyFramer ensures that the behavior is correct before calling the visitor.
@@ skipping 18 matching lines @@
   DVLOG(1) << "OnDataFrameHeader stream_id: " << stream_id;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_GT(stream_id, 0u);
   CHECK_EQ(data_.get(), nullptr);
   frame_type_ = DATA;
 
   stream_id_ = stream_id;
   fin_ = fin;
   data_len_ = length;
-  data_.reset(new string());
+  data_.reset(new SpdyString());
 }
 
 // The SpdyFramer will not process any more data at this point.
 void SpdyTestDeframerImpl::OnError(SpdyFramer* framer) {
   DVLOG(1) << "SpdyFramer detected an error in the stream: "
            << SpdyFramer::SpdyFramerErrorToString(framer->spdy_framer_error())
            << "     frame_type_: " << Http2FrameTypeToString(frame_type_);
   listener_->OnError(framer, this);
 }
 
 // Received a GOAWAY frame from the peer. The last stream id it accepted from us
 // is |last_accepted_stream_id|. |status| is a protocol defined error code.
 // The frame may also contain data. After this OnGoAwayFrameData will be called
 // for any non-zero amount of data, and after that it will be called with len==0
 // to indicate the end of the GOAWAY frame.
 void SpdyTestDeframerImpl::OnGoAway(SpdyStreamId last_good_stream_id,
                                     SpdyErrorCode error_code) {
   DVLOG(1) << "OnGoAway last_good_stream_id: " << last_good_stream_id
            << "     error code: " << error_code;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   frame_type_ = GOAWAY;
   goaway_ir_ = MakeUnique<SpdyGoAwayIR>(last_good_stream_id, error_code, "");
-  goaway_description_.reset(new string());
+  goaway_description_.reset(new SpdyString());
 }
 
 // If len==0 then we've reached the end of the GOAWAY frame.
 bool SpdyTestDeframerImpl::OnGoAwayFrameData(const char* goaway_data,
                                              size_t len) {
   DVLOG(1) << "OnGoAwayFrameData";
   CHECK_EQ(frame_type_, GOAWAY) << "   frame_type_="
                                 << Http2FrameTypeToString(frame_type_);
   CHECK(goaway_description_);
   goaway_description_->append(goaway_data, len);
@@ skipping 242 matching lines @@
   got_hpack_end_ = false;
 }
 
 void SpdyTestDeframerImpl::OnHeader(SpdyStringPiece key,
                                     SpdyStringPiece value) {
   CHECK(frame_type_ == HEADERS || frame_type_ == CONTINUATION ||
         frame_type_ == PUSH_PROMISE)
       << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
   CHECK(!got_hpack_end_);
   CHECK(headers_);
-  headers_->emplace_back(std::string(key), std::string(value));
+  headers_->emplace_back(SpdyString(key), SpdyString(value));
   CHECK(headers_handler_);
   headers_handler_->OnHeader(key, value);
 }
 
 void SpdyTestDeframerImpl::OnHeaderBlockEnd(size_t header_bytes_parsed) {
   CHECK(headers_);
   CHECK(frame_type_ == HEADERS || frame_type_ == CONTINUATION ||
         frame_type_ == PUSH_PROMISE)
       << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
   CHECK(end_);
@@ skipping 260 matching lines @@
 // The SpdyFramer will not process any more data at this point.
 void DeframerCallbackCollector::OnError(SpdyFramer* framer,
                                         SpdyTestDeframer* deframer) {
   CollectedFrame cf;
   cf.error_reported = true;
   collected_frames_->push_back(std::move(cf));
 }
 
 }  // namespace test
 }  // namespace net