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

net/spdy/spdy_protocol.h

 // 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.
 
 // This file contains some protocol structures for use with SPDY 3 and HTTP 2
 // The SPDY 3 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3
 
 #ifndef NET_SPDY_SPDY_PROTOCOL_H_
 #define NET_SPDY_SPDY_PROTOCOL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <iosfwd>
 #include <limits>
 #include <map>
 #include <memory>
-#include <string>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/sys_byteorder.h"
 #include "net/base/net_export.h"
+#include "net/spdy/platform/api/spdy_string.h"
 #include "net/spdy/platform/api/spdy_string_piece.h"
 #include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_bitmasks.h"
 #include "net/spdy/spdy_bug_tracker.h"
 #include "net/spdy/spdy_header_block.h"
 
 namespace net {
 
 // A stream id is a 31 bit entity.
 typedef uint32_t SpdyStreamId;
@@ skipping 420 matching lines @@
 class NET_EXPORT_PRIVATE SpdyDataIR
     : public NON_EXPORTED_BASE(SpdyFrameWithFinIR) {
  public:
   // Performs a deep copy on data.
   SpdyDataIR(SpdyStreamId stream_id, SpdyStringPiece data);
 
   // Performs a deep copy on data.
   SpdyDataIR(SpdyStreamId stream_id, const char* data);
 
   // Moves data into data_store_. Makes a copy if passed a non-movable string.
-  SpdyDataIR(SpdyStreamId stream_id, std::string data);
+  SpdyDataIR(SpdyStreamId stream_id, SpdyString data);
 
   // Use in conjunction with SetDataShallow() for shallow-copy on data.
   explicit SpdyDataIR(SpdyStreamId stream_id);
 
   ~SpdyDataIR() override;
 
   const char* data() const { return data_; }
   size_t data_len() const { return data_len_; }
 
   bool padded() const { return padded_; }
 
   int padding_payload_len() const { return padding_payload_len_; }
 
   void set_padding_len(int padding_len) {
     DCHECK_GT(padding_len, 0);
     DCHECK_LE(padding_len, kPaddingSizePerFrame);
     padded_ = true;
     // The pad field takes one octet on the wire.
     padding_payload_len_ = padding_len - 1;
   }
 
   // Deep-copy of data (keep private copy).
   void SetDataDeep(SpdyStringPiece data) {
-    data_store_.reset(new std::string(data.data(), data.size()));
+    data_store_.reset(new SpdyString(data.data(), data.size()));
     data_ = data_store_->data();
     data_len_ = data.size();
   }
 
   // Shallow-copy of data (do not keep private copy).
   void SetDataShallow(SpdyStringPiece data) {
     data_store_.reset();
     data_ = data.data();
     data_len_ = data.size();
   }
 
   // Use this method if we don't have a contiguous buffer and only
   // need a length.
   void SetDataShallow(size_t len) {
     data_store_.reset();
     data_ = nullptr;
     data_len_ = len;
   }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   SpdyFrameType frame_type() const override;
 
  private:
   // Used to store data that this SpdyDataIR should own.
-  std::unique_ptr<std::string> data_store_;
+  std::unique_ptr<SpdyString> data_store_;
   const char* data_;
   size_t data_len_;
 
   bool padded_;
   // padding_payload_len_ = desired padding length - len(padding length field).
   int padding_payload_len_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyDataIR);
 };
 
@@ skipping 71 matching lines @@
   // References description, doesn't copy it, so description must outlast
   // this SpdyGoAwayIR.
   SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
                SpdyErrorCode error_code,
                const char* description);
 
   // Moves description into description_store_, so caller doesn't need to
   // keep description live after constructing this SpdyGoAwayIR.
   SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
                SpdyErrorCode error_code,
-               std::string description);
+               SpdyString description);
 
   ~SpdyGoAwayIR() override;
   SpdyStreamId last_good_stream_id() const { return last_good_stream_id_; }
   void set_last_good_stream_id(SpdyStreamId last_good_stream_id) {
     DCHECK_EQ(0u, last_good_stream_id & ~kStreamIdMask);
     last_good_stream_id_ = last_good_stream_id;
   }
   SpdyErrorCode error_code() const { return error_code_; }
   void set_error_code(SpdyErrorCode error_code) {
     // TODO(hkhalil): Check valid ranges of error_code?
     error_code_ = error_code;
   }
 
   const SpdyStringPiece& description() const { return description_; }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   SpdyFrameType frame_type() const override;
 
  private:
   SpdyStreamId last_good_stream_id_;
   SpdyErrorCode error_code_;
-  const std::string description_store_;
+  const SpdyString description_store_;
   const SpdyStringPiece description_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyGoAwayIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
  public:
   explicit SpdyHeadersIR(SpdyStreamId stream_id)
       : SpdyHeadersIR(stream_id, SpdyHeaderBlock()) {}
   SpdyHeadersIR(SpdyStreamId stream_id, SpdyHeaderBlock header_block)
@@ skipping 98 matching lines @@
  public:
   explicit SpdyContinuationIR(SpdyStreamId stream_id);
   ~SpdyContinuationIR() override;
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   SpdyFrameType frame_type() const override;
 
   bool end_headers() const { return end_headers_; }
   void set_end_headers(bool end_headers) {end_headers_ = end_headers;}
-  const std::string& encoding() const { return *encoding_; }
-  void take_encoding(std::unique_ptr<std::string> encoding) {
+  const SpdyString& encoding() const { return *encoding_; }
+  void take_encoding(std::unique_ptr<SpdyString> encoding) {
     encoding_ = std::move(encoding);
   }
 
  private:
-  std::unique_ptr<std::string> encoding_;
+  std::unique_ptr<SpdyString> encoding_;
   bool end_headers_;
   DISALLOW_COPY_AND_ASSIGN(SpdyContinuationIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameWithStreamIdIR {
  public:
   explicit SpdyAltSvcIR(SpdyStreamId stream_id);
   ~SpdyAltSvcIR() override;
 
-  std::string origin() const { return origin_; }
+  SpdyString origin() const { return origin_; }
   const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector() const {
     return altsvc_vector_;
   }
 
-  void set_origin(std::string origin) { origin_ = std::move(origin); }
+  void set_origin(SpdyString origin) { origin_ = std::move(origin); }
   void add_altsvc(const SpdyAltSvcWireFormat::AlternativeService& altsvc) {
     altsvc_vector_.push_back(altsvc);
   }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   SpdyFrameType frame_type() const override;
 
  private:
-  std::string origin_;
+  SpdyString origin_;
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector_;
   DISALLOW_COPY_AND_ASSIGN(SpdyAltSvcIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameWithStreamIdIR {
  public:
   explicit SpdyPriorityIR(SpdyStreamId stream_id)
       : SpdyFrameWithStreamIdIR(stream_id),
         parent_stream_id_(0),
         weight_(1),
@@ skipping 124 matching lines @@
   SpdyFrameVisitor() {}
   virtual ~SpdyFrameVisitor() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameVisitor);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_PROTOCOL_H_