Replace the existing SpdyHeaderBlock typedef with a class.

net/spdy/spdy_test_util_common.cc

 // Copyright (c) 2013 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_test_util_common.h"
 
 #include <cstddef>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 122 matching lines @@
     if (!header_len)
       continue;
     this_value = extra_headers[1 + (i * 2)];
     std::string new_value;
     if (headers->find(this_header) != headers->end()) {
       // More than one entry in the header.
       // Don't add the header again, just the append to the value,
       // separated by a NULL character.
 
       // Adjust the value.
-      new_value = (*headers)[this_header];
+      new_value = (*headers)[this_header].as_string();
       // Put in a NULL separator.
       new_value.append(1, '\0');
       // Append the new value.
       new_value += this_value;
     } else {
       // Not a duplicate, just write the value.
       new_value = this_value;
     }
     (*headers)[this_header] = new_value;
   }
@@ skipping 570 matching lines @@
     : protocol_(protocol),
       spdy_version_(NextProtoToSpdyMajorVersion(protocol)),
       default_url_(GURL(kDefaultURL)) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 }
 
 void SpdyTestUtil::AddUrlToHeaderBlock(base::StringPiece url,
                                        SpdyHeaderBlock* headers) const {
   std::string scheme, host, path;
   ParseUrl(url, &scheme, &host, &path);
+  (*headers)[GetHostKey()] = host;
   (*headers)[GetSchemeKey()] = scheme;
-  (*headers)[GetHostKey()] = host;
   (*headers)[GetPathKey()] = path;
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlock(
     base::StringPiece url) const {
   return ConstructHeaderBlock("GET", url, NULL);
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlockForProxy(
     base::StringPiece url) const {
@@ skipping 113 matching lines @@
   return ConstructSpdyControlFrame(
       headers.Pass(), compressed, stream_id,
       request_priority, type, flags, associated_stream_id);
 }
 
 std::string SpdyTestUtil::ConstructSpdyReplyString(
     const SpdyHeaderBlock& headers) const {
   std::string reply_string;
   for (SpdyHeaderBlock::const_iterator it = headers.begin();
        it != headers.end(); ++it) {
-    std::string key = it->first;
+    std::string key = it->first.as_string();
     // Remove leading colon from "special" headers (for SPDY3 and
     // above).
     if (spdy_version() >= SPDY3 && key[0] == ':')
       key = key.substr(1);
     for (const std::string& value :
          base::SplitString(it->second, base::StringPiece("\0", 1),
                            base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
       reply_string += key + ": " + value + "\n";
     }
   }
@@ skipping 77 matching lines @@
       stream_id, *block, request_priority, compressed, true);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyGet(const char* const extra_headers[],
                                           int extra_header_count,
                                           bool compressed,
                                           int stream_id,
                                           RequestPriority request_priority,
                                           bool direct) const {
   SpdyHeaderBlock block;
+  MaybeAddVersionHeader(&block);
+  block[GetMethodKey()] = "GET";
   AddUrlToHeaderBlock(default_url_.spec(), &block);
-  block[GetMethodKey()] = "GET";
-  MaybeAddVersionHeader(&block);
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
   return ConstructSpdySyn(stream_id, block, request_priority, compressed, true);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyConnect(
     const char* const extra_headers[],
     int extra_header_count,
     int stream_id,
     RequestPriority priority,
     const HostPortPair& host_port_pair) const {
   SpdyHeaderBlock block;
+  MaybeAddVersionHeader(&block);
   block[GetMethodKey()] = "CONNECT";
   if (spdy_version() < HTTP2) {
-    block[GetPathKey()] = host_port_pair.ToString();
     block[GetHostKey()] = (host_port_pair.port() == 443)
                               ? host_port_pair.host()
                               : host_port_pair.ToString();
+    block[GetPathKey()] = host_port_pair.ToString();
   } else {
     block[GetHostKey()] = host_port_pair.ToString();
   }
-
-  MaybeAddVersionHeader(&block);
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
   return ConstructSpdySyn(stream_id, block, priority, false, false);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
                                            int extra_header_count,
                                            int stream_id,
                                            int associated_stream_id,
                                            const char* url) {
   if (spdy_version() < HTTP2) {
     SpdySynStreamIR syn_stream(stream_id);
     syn_stream.set_associated_to_stream_id(associated_stream_id);
     syn_stream.SetHeader("hello", "bye");
     syn_stream.SetHeader(GetStatusKey(), "200 OK");
     syn_stream.SetHeader(GetVersionKey(), "HTTP/1.1");
     AddUrlToHeaderBlock(url, syn_stream.mutable_header_block());
     AppendToHeaderBlock(extra_headers, extra_header_count,
                         syn_stream.mutable_header_block());
     return CreateFramer(false)->SerializeFrame(syn_stream);
   } else {
     SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
     AddUrlToHeaderBlock(url, push_promise.mutable_header_block());
     scoped_ptr<SpdyFrame> push_promise_frame(
         CreateFramer(false)->SerializeFrame(push_promise));
 
     SpdyHeadersIR headers(stream_id);
+    headers.SetHeader(GetStatusKey(), "200 OK");
     headers.SetHeader("hello", "bye");
-    headers.SetHeader(GetStatusKey(), "200 OK");
     AppendToHeaderBlock(extra_headers, extra_header_count,
                         headers.mutable_header_block());
     scoped_ptr<SpdyFrame> headers_frame(
         CreateFramer(false)->SerializeFrame(headers));
 
     int joint_data_size = push_promise_frame->size() + headers_frame->size();
     scoped_ptr<char[]> data(new char[joint_data_size]);
     const SpdyFrame* frames[2] = {
         push_promise_frame.get(), headers_frame.get(),
     };
@@ skipping 122 matching lines @@
     return CreateFramer(false)->SerializeFrame(reply);
   }
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdySynReplyError(
     const char* const status,
     const char* const* const extra_headers,
     int extra_header_count,
     int stream_id) {
   SpdyHeaderBlock block;
-  block["hello"] = "bye";
   block[GetStatusKey()] = status;
   MaybeAddVersionHeader(&block);
+  block["hello"] = "bye";
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
 
   return ConstructSpdyReply(stream_id, block);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyGetSynReplyRedirect(int stream_id) {
   static const char* const kExtraHeaders[] = {
     "location", "http://www.foo.com/index.php",
   };
   return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
                                     arraysize(kExtraHeaders)/2, stream_id);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdySynReplyError(int stream_id) {
   return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyGetSynReply(
     const char* const extra_headers[],
     int extra_header_count,
     int stream_id) {
   SpdyHeaderBlock block;
-  block["hello"] = "bye";
   block[GetStatusKey()] = "200";
   MaybeAddVersionHeader(&block);
+  block["hello"] = "bye";
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
 
   return ConstructSpdyReply(stream_id, block);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyPost(const char* url,
                                            SpdyStreamId stream_id,
                                            int64 content_length,
                                            RequestPriority priority,
                                            const char* const extra_headers[],
                                            int extra_header_count) {
   scoped_ptr<SpdyHeaderBlock> block(
       ConstructPostHeaderBlock(url, content_length));
   AppendToHeaderBlock(extra_headers, extra_header_count, block.get());
   return ConstructSpdySyn(stream_id, *block, priority, false, false);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructChunkedSpdyPost(
     const char* const extra_headers[],
     int extra_header_count) {
   SpdyHeaderBlock block;
+  MaybeAddVersionHeader(&block);
   block[GetMethodKey()] = "POST";
   AddUrlToHeaderBlock(default_url_.spec(), &block);
-  MaybeAddVersionHeader(&block);
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
   return ConstructSpdySyn(1, block, LOWEST, false, false);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyPostSynReply(
     const char* const extra_headers[],
     int extra_header_count) {
   // TODO(jgraettinger): Remove this method.
   return ConstructSpdyGetSynReply(NULL, 0, 1);
 }
@@ skipping 85 matching lines @@
   return ":path";
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeaderBlock(
     base::StringPiece method,
     base::StringPiece url,
     int64* content_length) const {
   std::string scheme, host, path;
   ParseUrl(url.data(), &scheme, &host, &path);
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
-  (*headers)[GetMethodKey()] = method.as_string();
-  (*headers)[GetPathKey()] = path.c_str();
-  (*headers)[GetHostKey()] = host.c_str();
-  (*headers)[GetSchemeKey()] = scheme.c_str();
   if (include_version_header()) {
     (*headers)[GetVersionKey()] = "HTTP/1.1";
   }
+  (*headers)[GetMethodKey()] = method.as_string();
+  (*headers)[GetHostKey()] = host.c_str();
+  (*headers)[GetSchemeKey()] = scheme.c_str();
+  (*headers)[GetPathKey()] = path.c_str();
   if (content_length) {
     std::string length_str = base::Int64ToString(*content_length);
     (*headers)["content-length"] = length_str;
   }
   return headers.Pass();
 }
 
 void SpdyTestUtil::MaybeAddVersionHeader(
     SpdyFrameWithHeaderBlockIR* frame_ir) const {
   if (include_version_header()) {
     frame_ir->SetHeader(GetVersionKey(), "HTTP/1.1");
   }
 }
 
 void SpdyTestUtil::MaybeAddVersionHeader(SpdyHeaderBlock* block) const {
   if (include_version_header()) {
     (*block)[GetVersionKey()] = "HTTP/1.1";
   }
 }
 
 void SpdyTestUtil::SetPriority(RequestPriority priority,
                                SpdySynStreamIR* ir) const {
   ir->set_priority(ConvertRequestPriorityToSpdyPriority(
       priority, spdy_version()));
 }
 
 }  // namespace net