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

net/spdy/spdy_framer.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 <string.h>
 
 #include <algorithm>
 #include <cctype>
 #include <ios>
 #include <iterator>
 #include <list>
 #include <memory>
 #include <new>
-#include <string>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/hpack/hpack_decoder.h"
 #include "net/spdy/hpack/hpack_decoder3.h"
 #include "net/spdy/http2_frame_decoder_adapter.h"
 #include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
 #include "net/spdy/platform/api/spdy_string_utils.h"
 #include "net/spdy/spdy_bitmasks.h"
 #include "net/spdy/spdy_bug_tracker.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_framer_decoder_adapter.h"
 
-using std::string;
 using std::vector;
 
 namespace net {
 
 namespace {
 
 // Pack parent stream ID and exclusive flag into the format used by HTTP/2
 // headers and priority frames.
 uint32_t PackStreamDependencyValues(bool exclusive,
                                     SpdyStreamId parent_stream_id) {
@@ skipping 1581 matching lines @@
       return false;
     }
     const char* begin = temp.data();
     const char* end = begin;
     std::advance(end, temp.size());
     if (std::any_of(begin, end, isupper)) {
       DVLOG(1) << "Malformed header: Header name " << temp
                << " contains upper-case characters.";
       return false;
     }
-    std::string name(temp);
+    SpdyString name(temp);
 
     // Read header value.
     if (!reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header value (" << index + 1 << " of "
                << num_headers << ").";
       return false;
     }
-    std::string value(temp);
+    SpdyString value(temp);
 
     // Ensure no duplicates.
     if (block->find(name) != block->end()) {
       DVLOG(1) << "Duplicate header '" << name << "' (" << index + 1 << " of "
                << num_headers << ").";
       return false;
     }
 
     // Store header.
     (*block)[name] = value;
@@ skipping 25 matching lines @@
 SpdySerializedFrame SpdyFramer::SpdyHeaderFrameIterator::NextFrame() {
   if (!has_next_frame_) {
     SPDY_BUG << "SpdyFramer::SpdyHeaderFrameIterator::NextFrame called without "
              << "a next frame.";
     return SpdySerializedFrame();
   }
 
   size_t size_without_block =
       is_first_frame_ ? framer_->GetHeaderFrameSizeSansBlock(*headers_ir_)
                       : framer_->GetContinuationMinimumSize();
-  auto encoding = base::MakeUnique<string>();
+  auto encoding = base::MakeUnique<SpdyString>();
   encoder_->Next(kMaxControlFrameSize - size_without_block, encoding.get());
   has_next_frame_ = encoder_->HasNext();
 
   if (framer_->debug_visitor_ != nullptr) {
     debug_total_size_ += size_without_block;
     debug_total_size_ += encoding->size();
     if (!has_next_frame_) {
       // TODO(birenroy) are these (here and below) still necessary?
       // HTTP2 uses HPACK for header compression. However, continue to
       // use GetSerializedLength() for an apples-to-apples comparision of
@@ skipping 43 matching lines @@
   SerializeDataBuilderHelper(data_ir, &flags, &num_padding_fields,
                              &size_with_padding);
 
   SpdyFrameBuilder builder(size_with_padding);
   builder.BeginNewFrame(*this, SpdyFrameType::DATA, flags, data_ir.stream_id());
   if (data_ir.padded()) {
     builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
   }
   builder.WriteBytes(data_ir.data(), data_ir.data_len());
   if (data_ir.padding_payload_len() > 0) {
-    string padding(data_ir.padding_payload_len(), 0);
+    SpdyString padding(data_ir.padding_payload_len(), 0);
     builder.WriteBytes(padding.data(), padding.length());
   }
   DCHECK_EQ(size_with_padding, builder.length());
   return builder.take();
 }
 
 void SpdyFramer::SerializeDataFrameHeaderWithPaddingLengthFieldBuilderHelper(
     const SpdyDataIR& data_ir,
     uint8_t* flags,
     size_t* frame_size,
@@ skipping 127 matching lines @@
                        goaway.description().size());
   }
 
   DCHECK_EQ(expected_length, builder.length());
   return builder.take();
 }
 
 void SpdyFramer::SerializeHeadersBuilderHelper(const SpdyHeadersIR& headers,
                                                uint8_t* flags,
                                                size_t* size,
-                                               string* hpack_encoding,
+                                               SpdyString* hpack_encoding,
                                                int* weight,
                                                size_t* length_field) {
   if (headers.fin()) {
     *flags = *flags | CONTROL_FLAG_FIN;
   }
   // This will get overwritten if we overflow into a CONTINUATION frame.
   *flags = *flags | HEADERS_FLAG_END_HEADERS;
   if (headers.has_priority()) {
     *flags = *flags | HEADERS_FLAG_PRIORITY;
   }
@@ skipping 35 matching lines @@
   // necessary.
   *length_field =
       std::min(*length_field, kMaxControlFrameSize - GetFrameHeaderSize());
 }
 
 SpdySerializedFrame SpdyFramer::SerializeHeaders(const SpdyHeadersIR& headers) {
   uint8_t flags = 0;
   // The size of this frame, including padding (if there is any) and
   // variable-length header block.
   size_t size = 0;
-  string hpack_encoding;
+  SpdyString hpack_encoding;
   int weight = 0;
   size_t length_field = 0;
   SerializeHeadersBuilderHelper(headers, &flags, &size, &hpack_encoding,
                                 &weight, &length_field);
 
   SpdyFrameBuilder builder(size);
 
   if (!skip_rewritelength_) {
     builder.BeginNewFrame(*this, SpdyFrameType::HEADERS, flags,
                           headers.stream_id());
@@ skipping 36 matching lines @@
   builder.BeginNewFrame(*this, SpdyFrameType::WINDOW_UPDATE, kNoFlags,
                         window_update.stream_id());
   builder.WriteUInt32(window_update.delta());
   DCHECK_EQ(GetWindowUpdateSize(), builder.length());
   return builder.take();
 }
 
 void SpdyFramer::SerializePushPromiseBuilderHelper(
     const SpdyPushPromiseIR& push_promise,
     uint8_t* flags,
-    string* hpack_encoding,
+    SpdyString* hpack_encoding,
     size_t* size) {
   *flags = 0;
   // This will get overwritten if we overflow into a CONTINUATION frame.
   *flags = *flags | PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   // The size of this frame, including variable-length name-value block.
   *size = GetPushPromiseMinimumSize();
 
   if (push_promise.padded()) {
     *flags = *flags | PUSH_PROMISE_FLAG_PADDED;
     *size = *size + kPadLengthFieldSize;
     *size = *size + push_promise.padding_payload_len();
   }
 
   GetHpackEncoder()->EncodeHeaderSet(push_promise.header_block(),
                                      hpack_encoding);
   *size = *size + hpack_encoding->size();
   if (*size > kMaxControlFrameSize) {
     *size = *size + GetNumberRequiredContinuationFrames(*size) *
                         GetContinuationMinimumSize();
     *flags = *flags & ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   }
 }
 
 SpdySerializedFrame SpdyFramer::SerializePushPromise(
     const SpdyPushPromiseIR& push_promise) {
   uint8_t flags = 0;
   size_t size = 0;
-  string hpack_encoding;
+  SpdyString hpack_encoding;
   SerializePushPromiseBuilderHelper(push_promise, &flags, &hpack_encoding,
                                     &size);
 
   SpdyFrameBuilder builder(size);
   if (!skip_rewritelength_) {
     builder.BeginNewFrame(*this, SpdyFrameType::PUSH_PROMISE, flags,
                           push_promise.stream_id());
   } else {
     size_t length = std::min(size, kMaxControlFrameSize) - GetFrameHeaderSize();
     builder.BeginNewFrame(*this, SpdyFrameType::PUSH_PROMISE, flags,
@@ skipping 25 matching lines @@
     debug_visitor_->OnSendCompressedFrame(push_promise.stream_id(),
                                           SpdyFrameType::PUSH_PROMISE,
                                           payload_len, builder.length());
   }
 
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeHeadersGivenEncoding(
     const SpdyHeadersIR& headers,
-    const string& encoding) const {
+    const SpdyString& encoding) const {
   size_t frame_size = GetHeaderFrameSizeSansBlock(headers) + encoding.size();
   SpdyFrameBuilder builder(frame_size);
   builder.BeginNewFrame(*this, SpdyFrameType::HEADERS,
                         SerializeHeaderFrameFlags(headers),
                         headers.stream_id());
   DCHECK_EQ(GetFrameHeaderSize(), builder.length());
 
   if (headers.padded()) {
     builder.WriteUInt8(headers.padding_payload_len());
   }
 
   if (headers.has_priority()) {
     int weight = ClampHttp2Weight(headers.weight());
     builder.WriteUInt32(PackStreamDependencyValues(headers.exclusive(),
                                                    headers.parent_stream_id()));
     // Per RFC 7540 section 6.3, serialized weight value is actual value - 1.
     builder.WriteUInt8(weight - 1);
   }
 
   builder.WriteBytes(&encoding[0], encoding.size());
 
   if (headers.padding_payload_len() > 0) {
-    string padding(headers.padding_payload_len(), 0);
+    SpdyString padding(headers.padding_payload_len(), 0);
     builder.WriteBytes(padding.data(), padding.length());
   }
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeContinuation(
     const SpdyContinuationIR& continuation) const {
-  const string& encoding = continuation.encoding();
+  const SpdyString& encoding = continuation.encoding();
   size_t frame_size = GetContinuationMinimumSize() + encoding.size();
   SpdyFrameBuilder builder(frame_size);
   uint8_t flags = continuation.end_headers() ? HEADERS_FLAG_END_HEADERS : 0;
   builder.BeginNewFrame(*this, SpdyFrameType::CONTINUATION, flags,
                         continuation.stream_id());
   DCHECK_EQ(GetFrameHeaderSize(), builder.length());
 
   builder.WriteBytes(encoding.data(), encoding.size());
   return builder.take();
 }
 
 void SpdyFramer::SerializeAltSvcBuilderHelper(const SpdyAltSvcIR& altsvc_ir,
-                                              string* value,
+                                              SpdyString* value,
                                               size_t* size) const {
   *size = GetAltSvcMinimumSize();
   *size = *size + altsvc_ir.origin().length();
   *value = SpdyAltSvcWireFormat::SerializeHeaderFieldValue(
       altsvc_ir.altsvc_vector());
   *size = *size + value->length();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeAltSvc(const SpdyAltSvcIR& altsvc_ir) {
-  string value;
+  SpdyString value;
   size_t size = 0;
   SerializeAltSvcBuilderHelper(altsvc_ir, &value, &size);
   SpdyFrameBuilder builder(size);
   builder.BeginNewFrame(*this, SpdyFrameType::ALTSVC, kNoFlags,
                         altsvc_ir.stream_id());
 
   builder.WriteUInt16(altsvc_ir.origin().length());
   builder.WriteBytes(altsvc_ir.origin().data(), altsvc_ir.origin().length());
   builder.WriteBytes(value.data(), value.length());
   DCHECK_LT(GetAltSvcMinimumSize(), builder.length());
@@ skipping 169 matching lines @@
 
   bool ok = builder.BeginNewFrame(*this, SpdyFrameType::DATA, flags,
                                   data_ir.stream_id());
 
   if (data_ir.padded()) {
     ok = ok && builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
   }
 
   ok = ok && builder.WriteBytes(data_ir.data(), data_ir.data_len());
   if (data_ir.padding_payload_len() > 0) {
-    string padding;
-    padding = string(data_ir.padding_payload_len(), 0);
+    SpdyString padding;
+    padding = SpdyString(data_ir.padding_payload_len(), 0);
     ok = ok && builder.WriteBytes(padding.data(), padding.length());
   }
   DCHECK_EQ(size_with_padding, builder.length());
   return ok;
 }
 
 bool SpdyFramer::SerializeDataFrameHeaderWithPaddingLengthField(
     const SpdyDataIR& data_ir,
     ZeroCopyOutputBuffer* output) const {
   uint8_t flags = DATA_FLAG_NONE;
@@ skipping 102 matching lines @@
   DCHECK_EQ(expected_length, builder.length());
   return ok;
 }
 
 bool SpdyFramer::SerializeHeaders(const SpdyHeadersIR& headers,
                                   ZeroCopyOutputBuffer* output) {
   uint8_t flags = 0;
   // The size of this frame, including padding (if there is any) and
   // variable-length header block.
   size_t size = 0;
-  string hpack_encoding;
+  SpdyString hpack_encoding;
   int weight = 0;
   size_t length_field = 0;
   SerializeHeadersBuilderHelper(headers, &flags, &size, &hpack_encoding,
                                 &weight, &length_field);
 
   bool ok = true;
   SpdyFrameBuilder builder(size, output);
   if (!skip_rewritelength_) {
     ok = builder.BeginNewFrame(*this, SpdyFrameType::HEADERS, flags,
                                headers.stream_id());
@@ skipping 39 matching lines @@
                                   window_update.stream_id());
   ok = ok && builder.WriteUInt32(window_update.delta());
   DCHECK_EQ(GetWindowUpdateSize(), builder.length());
   return ok;
 }
 
 bool SpdyFramer::SerializePushPromise(const SpdyPushPromiseIR& push_promise,
                                       ZeroCopyOutputBuffer* output) {
   uint8_t flags = 0;
   size_t size = 0;
-  string hpack_encoding;
+  SpdyString hpack_encoding;
   SerializePushPromiseBuilderHelper(push_promise, &flags, &hpack_encoding,
                                     &size);
 
   bool ok = true;
   SpdyFrameBuilder builder(size, output);
   if (!skip_rewritelength_) {
     ok = builder.BeginNewFrame(*this, SpdyFrameType::PUSH_PROMISE, flags,
                                push_promise.stream_id());
   } else {
     size_t length = std::min(size, kMaxControlFrameSize) - GetFrameHeaderSize();
@@ skipping 27 matching lines @@
     debug_visitor_->OnSendCompressedFrame(push_promise.stream_id(),
                                           SpdyFrameType::PUSH_PROMISE,
                                           payload_len, builder.length());
   }
 
   return ok;
 }
 
 bool SpdyFramer::SerializeContinuation(const SpdyContinuationIR& continuation,
                                        ZeroCopyOutputBuffer* output) const {
-  const string& encoding = continuation.encoding();
+  const SpdyString& encoding = continuation.encoding();
   size_t frame_size = GetContinuationMinimumSize() + encoding.size();
   SpdyFrameBuilder builder(frame_size, output);
   uint8_t flags = continuation.end_headers() ? HEADERS_FLAG_END_HEADERS : 0;
   bool ok = builder.BeginNewFrame(*this, SpdyFrameType::CONTINUATION, flags,
                                   continuation.stream_id());
   DCHECK_EQ(GetFrameHeaderSize(), builder.length());
 
   ok = ok && builder.WriteBytes(encoding.data(), encoding.size());
   return ok;
 }
 
 bool SpdyFramer::SerializeAltSvc(const SpdyAltSvcIR& altsvc_ir,
                                  ZeroCopyOutputBuffer* output) {
-  string value;
+  SpdyString value;
   size_t size = 0;
   SerializeAltSvcBuilderHelper(altsvc_ir, &value, &size);
   SpdyFrameBuilder builder(size, output);
   bool ok = builder.BeginNewFrame(*this, SpdyFrameType::ALTSVC, kNoFlags,
                                   altsvc_ir.stream_id()) &&
             builder.WriteUInt16(altsvc_ir.origin().length()) &&
             builder.WriteBytes(altsvc_ir.origin().data(),
                                altsvc_ir.origin().length()) &&
             builder.WriteBytes(value.data(), value.length());
   DCHECK_LT(GetAltSvcMinimumSize(), builder.length());
@@ skipping 113 matching lines @@
   if (header_ir.padded()) {
     flags |= HEADERS_FLAG_PADDED;
   }
   if (header_ir.has_priority()) {
     flags |= HEADERS_FLAG_PRIORITY;
   }
   return flags;
 }
 
 bool SpdyFramer::WritePayloadWithContinuation(SpdyFrameBuilder* builder,
-                                              const string& hpack_encoding,
+                                              const SpdyString& hpack_encoding,
                                               SpdyStreamId stream_id,
                                               SpdyFrameType type,
                                               int padding_payload_len) {
   uint8_t end_flag = 0;
   uint8_t flags = 0;
   if (type == SpdyFrameType::HEADERS) {
     end_flag = HEADERS_FLAG_END_HEADERS;
   } else if (type == SpdyFrameType::PUSH_PROMISE) {
     end_flag = PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   } else {
     DLOG(FATAL) << "CONTINUATION frames cannot be used with frame type "
                 << FrameTypeToString(type);
   }
 
   // Write all the padding payload and as much of the data payload as
   // possible into the initial frame.
   size_t bytes_remaining = 0;
   bytes_remaining =
       hpack_encoding.size() -
       std::min(hpack_encoding.size(),
                kMaxControlFrameSize - builder->length() - padding_payload_len);
   bool ret = builder->WriteBytes(&hpack_encoding[0],
                                  hpack_encoding.size() - bytes_remaining);
   if (padding_payload_len > 0) {
-    string padding = string(padding_payload_len, 0);
+    SpdyString padding = SpdyString(padding_payload_len, 0);
     ret &= builder->WriteBytes(padding.data(), padding.length());
   }
   if (bytes_remaining > 0 && !skip_rewritelength_) {
     ret &= builder->OverwriteLength(
         *this, kMaxControlFrameSize - GetFrameHeaderSize());
   }
 
   // Tack on CONTINUATION frames for the overflow.
   while (bytes_remaining > 0 && ret) {
     size_t bytes_to_write = std::min(
@@ skipping 85 matching lines @@
   builder->WriteUInt32(header_block.size());
 
   // Serialize each header.
   for (const auto& header : header_block) {
     builder->WriteStringPiece32(base::ToLowerASCII(header.first));
     builder->WriteStringPiece32(header.second);
   }
 }
 
 }  // namespace net