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

net/spdy/spdy_framer.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.
 
 #ifndef NET_SPDY_SPDY_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstdint>
 #include <map>
 #include <memory>
-#include <string>
 #include <utility>
 
 #include "base/sys_byteorder.h"
 #include "net/base/net_export.h"
 #include "net/spdy/hpack/hpack_decoder_interface.h"
 #include "net/spdy/hpack/hpack_encoder.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_flags.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_headers_handler_interface.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/zero_copy_output_buffer.h"
 
 namespace net {
 
@@ skipping 665 matching lines @@
   // Always passed exactly 1 setting's worth of data.
   bool ProcessSetting(const char* data);
 
   // Get (and lazily initialize) the HPACK state.
   HpackEncoder* GetHpackEncoder();
   HpackDecoderInterface* GetHpackDecoder();
 
   size_t GetNumberRequiredContinuationFrames(size_t size);
 
   bool WritePayloadWithContinuation(SpdyFrameBuilder* builder,
-                                    const std::string& hpack_encoding,
+                                    const SpdyString& hpack_encoding,
                                     SpdyStreamId stream_id,
                                     SpdyFrameType type,
                                     int padding_payload_len);
 
   // Utility to copy the given data block to the current frame buffer, up
   // to the given maximum number of bytes, and update the buffer
   // data (pointer and length). Returns the number of bytes
   // read, and:
   //   *data is advanced the number of bytes read.
   //   *len is reduced by the number of bytes read.
   size_t UpdateCurrentFrameBuffer(const char** data, size_t* len,
                                   size_t max_bytes);
 
   // Serializes a HEADERS frame from the given SpdyHeadersIR and encoded header
   // block. Does not need or use the SpdyHeaderBlock inside SpdyHeadersIR.
   SpdySerializedFrame SerializeHeadersGivenEncoding(
       const SpdyHeadersIR& headers,
-      const std::string& encoding) const;
+      const SpdyString& encoding) const;
 
   // Calculates the number of bytes required to serialize a SpdyHeadersIR, not
   // including the bytes to be used for the encoded header set.
   size_t GetHeaderFrameSizeSansBlock(const SpdyHeadersIR& header_ir) const;
 
   // Serializes the flags octet for a given SpdyHeadersIR.
   uint8_t SerializeHeaderFrameFlags(const SpdyHeadersIR& header_ir) const;
 
   // Set the error code and moves the framer into the error state.
   void set_error(SpdyFramerError error);
 
   // Helper functions to prepare the input for SpdyFrameBuilder.
   void SerializeDataBuilderHelper(const SpdyDataIR& data_ir,
                                   uint8_t* flags,
                                   int* num_padding_fields,
                                   size_t* size_with_padding) const;
   void SerializeDataFrameHeaderWithPaddingLengthFieldBuilderHelper(
       const SpdyDataIR& data_ir,
       uint8_t* flags,
       size_t* frame_size,
       size_t* num_padding_fields) const;
   void SerializeSettingsBuilderHelper(const SpdySettingsIR& settings,
                                       uint8_t* flags,
                                       const SettingsMap* values,
                                       size_t* size) const;
   void SerializeAltSvcBuilderHelper(const SpdyAltSvcIR& altsvc_ir,
-                                    std::string* value,
+                                    SpdyString* value,
                                     size_t* size) const;
   void SerializeHeadersBuilderHelper(const SpdyHeadersIR& headers,
                                      uint8_t* flags,
                                      size_t* size,
-                                     std::string* hpack_encoding,
+                                     SpdyString* hpack_encoding,
                                      int* weight,
                                      size_t* length_field);
   void SerializePushPromiseBuilderHelper(const SpdyPushPromiseIR& push_promise,
                                          uint8_t* flags,
-                                         std::string* hpack_encoding,
+                                         SpdyString* hpack_encoding,
                                          size_t* size);
 
   // The size of the control frame buffer.
   // Since this is only used for control frame headers, the maximum control
   // frame header size is sufficient; all remaining control
   // frame data is streamed to the visitor.
   static const size_t kControlFrameBufferSize;
 
   // The maximum size of the control frames that we send, including the size of
   // the header. This limit is arbitrary. We can enforce it here or at the
@@ skipping 89 matching lines @@
   // rather than reading all available input.
   bool process_single_input_frame_ = false;
 
   // Latched value of FLAGS_chromium_http2_flag_remove_rewritelength.
   bool skip_rewritelength_ = false;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_