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

net/spdy/spdy_network_transaction_unittest.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 <cmath>
 #include <memory>
-#include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/test_file_util.h"
@@ skipping 14 matching lines @@
 #include "net/http/http_transaction_test_util.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/proxy/proxy_server.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/next_proto.h"
 #include "net/spdy/buffered_spdy_framer.h"
+#include "net/spdy/platform/api/spdy_string.h"
 #include "net/spdy/platform/api/spdy_string_piece.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_test_util_common.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/test/cert_test_util.h"
@@ skipping 34 matching lines @@
 
   void SetUp() override {
     get_request_initialized_ = false;
     post_request_initialized_ = false;
     chunked_post_request_initialized_ = false;
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   struct TransactionHelperResult {
     int rv;
-    std::string status_line;
-    std::string response_data;
+    SpdyString status_line;
+    SpdyString response_data;
     HttpResponseInfo response_info;
   };
 
   // A helper class that handles all the initial npn/ssl setup.
   class NormalSpdyTransactionHelper {
    public:
     NormalSpdyTransactionHelper(
         const HttpRequestInfo& request,
         RequestPriority priority,
         const NetLogWithSource& log,
@@ skipping 292 matching lines @@
           upload_chunked_data_stream_.get();
       chunked_post_request_initialized_ = true;
     }
     return chunked_post_request_;
   }
 
   // Read the result of a particular transaction, knowing that we've got
   // multiple transactions in the read pipeline; so as we read, we may have
   // to skip over data destined for other transactions while we consume
   // the data for |trans|.
-  int ReadResult(HttpNetworkTransaction* trans,
-                 std::string* result) {
+  int ReadResult(HttpNetworkTransaction* trans, SpdyString* result) {
     const int kSize = 3000;
 
     int bytes_read = 0;
     scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(kSize));
     TestCompletionCallback callback;
     while (true) {
       int rv = trans->Read(buf.get(), kSize, callback.callback());
       if (rv == ERR_IO_PENDING) {
         rv = callback.WaitForResult();
       } else if (rv <= 0) {
@@ skipping 19 matching lines @@
             key, url,
             /* enable_ip_based_pooling = */ true, log);
     ASSERT_TRUE(spdy_session);
     EXPECT_EQ(0u, spdy_session->num_active_streams());
     EXPECT_EQ(0u, spdy_session->num_unclaimed_pushed_streams());
   }
 
   void RunServerPushTest(SequencedSocketData* data,
                          HttpResponseInfo* response,
                          HttpResponseInfo* push_response,
-                         const std::string& expected) {
+                         const SpdyString& expected) {
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        NetLogWithSource(), nullptr);
     helper.RunPreTestSetup();
     helper.AddData(data);
 
     HttpNetworkTransaction* trans = helper.trans();
 
     // Start the transaction with basic parameters.
     TestCompletionCallback callback;
     int rv = trans->Start(&CreateGetRequest(), callback.callback(),
                           NetLogWithSource());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     rv = callback.WaitForResult();
 
     // Finish async network reads/writes.
     base::RunLoop().RunUntilIdle();
 
     // Request the pushed path.
     HttpNetworkTransaction trans2(DEFAULT_PRIORITY, helper.session());
     rv = trans2.Start(&CreateGetPushRequest(), callback.callback(),
                       NetLogWithSource());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     base::RunLoop().RunUntilIdle();
 
     // The data for the pushed path may be coming in more than 1 frame. Compile
     // the results into a single string.
 
     // Read the server push body.
-    std::string result2;
+    SpdyString result2;
     ReadResult(&trans2, &result2);
     // Read the response body.
-    std::string result;
+    SpdyString result;
     ReadResult(trans, &result);
 
     // Verify that we consumed all test data.
     EXPECT_TRUE(data->AllReadDataConsumed());
     EXPECT_TRUE(data->AllWriteDataConsumed());
 
     LoadTimingInfo load_timing_info;
     EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
     EXPECT_TRUE(load_timing_info.push_start.is_null());
     EXPECT_TRUE(load_timing_info.push_end.is_null());
@@ skipping 64 matching lines @@
     request.load_flags = 0;
     int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     callback.WaitForResult();
   }
 
   ChunkedUploadDataStream* upload_chunked_data_stream() const {
     return upload_chunked_data_stream_.get();
   }
 
-  std::string GetDefaultUrlWithPath(const char* path) {
-    return std::string(kDefaultUrl) + path;
+  SpdyString GetDefaultUrlWithPath(const char* path) {
+    return SpdyString(kDefaultUrl) + path;
   }
 
   const GURL default_url_;
   const HostPortPair host_port_pair_;
   SpdyTestUtil spdy_util_;
 
  private:
   std::unique_ptr<ChunkedUploadDataStream> upload_chunked_data_stream_;
   std::unique_ptr<UploadDataStream> upload_data_stream_;
   bool get_request_initialized_;
@@ skipping 1085 matching lines @@
   ASSERT_TRUE(helper.StartDefaultTest());
 
   base::RunLoop().RunUntilIdle();
   upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, false);
   base::RunLoop().RunUntilIdle();
   upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, true);
 
   helper.FinishDefaultTest();
   helper.VerifyDataConsumed();
 
-  std::string expected_response;
+  SpdyString expected_response;
   expected_response += kUploadData;
   expected_response += kUploadData;
   expected_response += kUploadData;
 
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ(expected_response, out.response_data);
 }
 
@@ skipping 105 matching lines @@
   // Process the request headers, response headers, and response body.
   // The request body is still in flight.
   const HttpResponseInfo* response = helper.trans()->GetResponseInfo();
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
 
   // Finish sending the request body.
   upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, true);
   helper.WaitForCallbackToComplete();
   EXPECT_THAT(helper.output().rv, IsOk());
 
-  std::string response_body;
+  SpdyString response_body;
   EXPECT_THAT(ReadTransaction(helper.trans(), &response_body), IsOk());
   EXPECT_EQ(kUploadData, response_body);
 
   // Finish async network reads/writes.
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
 }
 
 // The client upon cancellation tries to send a RST_STREAM frame. The mock
 // socket causes the TCP write to return zero. This test checks that the client
@@ skipping 84 matching lines @@
   int rv =
       trans->Start(&helper.request(), callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
-  std::string response_data;
+  SpdyString response_data;
   rv = ReadTransaction(trans, &response_data);
   EXPECT_THAT(rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 
   helper.VerifyDataConsumed();
 }
 
 TEST_F(SpdyNetworkTransactionTest, ResetReplyWithTransferEncoding) {
   // Construct the request.
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
@@ skipping 313 matching lines @@
       spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
       CreateMockWrite(req, 0), CreateMockWrite(priority, 2),
   };
 
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
   SpdySerializedFrame response_body_frame(
       spdy_util_.ConstructSpdyDataFrame(1, "should not include", 18, true));
 
   SpdyHeaderBlock push_headers;
-  spdy_util_.AddUrlToHeaderBlock(std::string(kDefaultUrl) + "b.dat",
+  spdy_util_.AddUrlToHeaderBlock(SpdyString(kDefaultUrl) + "b.dat",
                                  &push_headers);
 
   SpdySerializedFrame push_init_frame(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(push_headers), 2, 1));
 
   SpdySerializedFrame push_headers_frame(
       spdy_util_.ConstructSpdyPushHeaders(2, nullptr, 0));
 
   SpdySerializedFrame push_body_frame(spdy_util_.ConstructSpdyDataFrame(
       2, "should not include either", 25, false));
@@ skipping 96 matching lines @@
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
 
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(OK, d.request_status());
-    std::string contents("hello!");
+    SpdyString contents("hello!");
     EXPECT_EQ(contents, d.data_received());
   }
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
   EXPECT_TRUE(data2.AllReadDataConsumed());
   EXPECT_TRUE(data2.AllWriteDataConsumed());
 }
 
 // Send a spdy request to www.example.org. Get a pushed stream that redirects to
 // www.foo.com.
@@ skipping 47 matching lines @@
   {
     std::unique_ptr<URLRequest> r(spdy_url_request_context.CreateRequest(
         default_url_, DEFAULT_PRIORITY, &d));
     spdy_url_request_context.socket_factory().
         AddSocketDataProvider(&data);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(0, d.received_redirect_count());
-    std::string contents("hello!");
+    SpdyString contents("hello!");
     EXPECT_EQ(contents, d.data_received());
 
     std::unique_ptr<URLRequest> r2(spdy_url_request_context.CreateRequest(
         GURL(GetDefaultUrlWithPath("/foo.dat")), DEFAULT_PRIORITY, &d2));
     spdy_url_request_context.socket_factory().
         AddSocketDataProvider(&data2);
 
     d2.set_quit_on_redirect(true);
     r2->Start();
     base::RunLoop().Run();
     EXPECT_EQ(1, d2.received_redirect_count());
 
     r2->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d2.response_started_count());
     EXPECT_FALSE(d2.received_data_before_response());
     EXPECT_EQ(OK, d2.request_status());
-    std::string contents2("hello!");
+    SpdyString contents2("hello!");
     EXPECT_EQ(contents2, d2.data_received());
   }
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
   EXPECT_TRUE(data2.AllReadDataConsumed());
   EXPECT_TRUE(data2.AllWriteDataConsumed());
 }
 
 TEST_F(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) {
   SpdySerializedFrame stream1_syn(
@@ skipping 13 matching lines @@
   SpdySerializedFrame stream2_body(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),         CreateMockRead(stream2_syn, 2),
       CreateMockRead(stream1_body, 4),          CreateMockRead(stream2_body, 5),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
-  std::string expected_push_result("pushed");
+  SpdyString expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
@@ skipping 22 matching lines @@
   MockRead reads[] = {
       CreateMockRead(stream2_syn, 1),
       CreateMockRead(stream1_reply, 3),
       CreateMockRead(stream1_body, 4, SYNCHRONOUS),
       CreateMockRead(stream2_body, 5),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
-  std::string expected_push_result("pushed");
+  SpdyString expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
@@ skipping 22 matching lines @@
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),
       CreateMockRead(stream2_syn, 2),
       CreateMockRead(stream2_body, 4),
       CreateMockRead(stream1_body, 5, SYNCHRONOUS),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
-  std::string expected_push_result("pushed");
+  SpdyString expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
@@ skipping 192 matching lines @@
       CreateMockRead(stream1_reply, 1),
       CreateMockRead(stream2_syn, 2),
       CreateMockRead(stream3_syn, 4),
       CreateMockRead(stream1_body, 6),
       CreateMockRead(stream2_body, 7),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 8),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
-  std::string expected_push_result("pushed");
+  SpdyString expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
@@ skipping 35 matching lines @@
       CreateMockRead(stream2_body1, 4),
       CreateMockRead(stream2_body2, 5),
       CreateMockRead(stream2_body3, 6),
       CreateMockRead(stream2_body4, 7),
       CreateMockRead(stream1_body, 8, SYNCHRONOUS),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 9),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
-  std::string expected_push_result("pushed my darling hello my baby");
+  SpdyString expected_push_result("pushed my darling hello my baby");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data, &response, &response2, kPushedData);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers);
   EXPECT_EQ("HTTP/1.1 200", response2.headers->GetStatusLine());
@@ skipping 278 matching lines @@
 
   HttpNetworkTransaction trans2(DEFAULT_PRIORITY, helper.session());
   TestCompletionCallback callback2;
   rv = trans2.Start(&CreateGetPushRequest(), callback2.callback(),
                     NetLogWithSource());
   rv = callback2.GetResult(rv);
   EXPECT_THAT(rv, IsOk());
   response = *trans2.GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
-  std::string result;
+  SpdyString result;
   ReadResult(&trans2, &result);
   EXPECT_EQ(kPushedData, result);
 
   data.Resume();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
@@ skipping 51 matching lines @@
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
 
     EXPECT_THAT(out.rv, IsOk());
     EXPECT_EQ("HTTP/1.1 200", out.status_line);
     EXPECT_EQ("hello!", out.response_data);
 
     scoped_refptr<HttpResponseHeaders> headers = out.response_info.headers;
     EXPECT_TRUE(headers);
     size_t iter = 0;
-    std::string name, value;
+    SpdyString name, value;
     SpdyHeaderBlock header_block;
     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
       auto value_it = header_block.find(name);
       if (value_it == header_block.end() || value_it->second.empty()) {
         header_block[name] = value;
       } else {
-        std::string joint_value = value_it->second.as_string();
+        SpdyString joint_value = value_it->second.as_string();
         joint_value.append(1, '\0');
         joint_value.append(value);
         header_block[name] = joint_value;
       }
     }
     EXPECT_EQ(test_cases[i].expected_headers, header_block);
   }
 }
 
 // Verify that various response headers parse vary fields correctly through the
@@ skipping 42 matching lines @@
     MockWrite writes[] = {
         CreateMockWrite(frame_req, 0),
     };
 
     // Construct the reply.
     SpdyHeaderBlock reply_headers;
     AppendToHeaderBlock(test_cases[i].extra_headers[1],
                         test_cases[i].num_headers[1],
                         &reply_headers);
     // Construct the expected header reply string before moving |reply_headers|.
-    std::string expected_reply =
+    SpdyString expected_reply =
         spdy_test_util.ConstructSpdyReplyString(reply_headers);
 
     SpdySerializedFrame frame_reply(
         spdy_test_util.ConstructSpdyReply(1, std::move(reply_headers)));
 
     SpdySerializedFrame body(spdy_test_util.ConstructSpdyDataFrame(1, true));
     MockRead reads[] = {
         CreateMockRead(frame_reply, 1), CreateMockRead(body, 2),
         MockRead(ASYNC, 0, 3)  // EOF
     };
@@ skipping 20 matching lines @@
     EXPECT_EQ("hello!", out.response_data) << i;
 
     // Test the response information.
     EXPECT_EQ(out.response_info.vary_data.is_valid(),
               test_cases[i].vary_matches) << i;
 
     // Check the headers.
     scoped_refptr<HttpResponseHeaders> headers = out.response_info.headers;
     ASSERT_TRUE(headers) << i;
     size_t iter = 0;
-    std::string name, value, lines;
+    SpdyString name, value, lines;
     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
       lines.append(name);
       lines.append(": ");
       lines.append(value);
       lines.append("\n");
     }
 
     EXPECT_EQ(expected_reply, lines) << i;
   }
 }
@@ skipping 236 matching lines @@
 
   // Check that we logged all the headers correctly
   pos = ExpectLogContainsSomewhere(entries, 0,
                                    NetLogEventType::HTTP2_SESSION_SEND_HEADERS,
                                    NetLogEventPhase::NONE);
 
   base::ListValue* header_list;
   ASSERT_TRUE(entries[pos].params.get());
   ASSERT_TRUE(entries[pos].params->GetList("headers", &header_list));
 
-  std::vector<std::string> expected;
-  expected.push_back(std::string(spdy_util_.GetHostKey()) +
-                     ": www.example.org");
-  expected.push_back(std::string(spdy_util_.GetPathKey()) + ": /");
-  expected.push_back(std::string(spdy_util_.GetSchemeKey()) + ": " +
+  std::vector<SpdyString> expected;
+  expected.push_back(SpdyString(spdy_util_.GetHostKey()) + ": www.example.org");
+  expected.push_back(SpdyString(spdy_util_.GetPathKey()) + ": /");
+  expected.push_back(SpdyString(spdy_util_.GetSchemeKey()) + ": " +
                      default_url_.scheme());
-  expected.push_back(std::string(spdy_util_.GetMethodKey()) + ": GET");
+  expected.push_back(SpdyString(spdy_util_.GetMethodKey()) + ": GET");
   expected.push_back("user-agent: Chrome");
   EXPECT_EQ(expected.size(), header_list->GetSize());
-  for (std::vector<std::string>::const_iterator it = expected.begin();
-       it != expected.end();
-       ++it) {
+  for (std::vector<SpdyString>::const_iterator it = expected.begin();
+       it != expected.end(); ++it) {
     base::Value header(*it);
     EXPECT_NE(header_list->end(), header_list->Find(header)) <<
         "Header not found: " << *it;
   }
 }
 
 // Since we buffer the IO from the stream to the renderer, this test verifies
 // that when we read out the maximum amount of data (e.g. we received 50 bytes
 // on the network, but issued a Read for only 5 of those bytes) that the data
 // flow still works correctly.
@@ skipping 46 matching lines @@
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
-  std::string content;
+  SpdyString content;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 3;
     scoped_refptr<IOBuffer> buf(new IOBuffer(kSmallReadSize));
     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv == ERR_IO_PENDING) {
       data.Resume();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
@@ skipping 64 matching lines @@
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
-  std::string content;
+  SpdyString content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<IOBuffer> buf(new IOBuffer(kSmallReadSize));
     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv == ERR_IO_PENDING) {
       data.Resume();
       rv = read_callback.WaitForResult();
     }
@@ skipping 65 matching lines @@
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
-  std::string content;
+  SpdyString content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<IOBuffer> buf(new IOBuffer(kSmallReadSize));
     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv > 0) {
       EXPECT_EQ(kSmallReadSize, rv);
       content.append(buf->data(), rv);
     } else if (rv < 0) {
@@ skipping 62 matching lines @@
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
-  std::string content;
+  SpdyString content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<IOBuffer> buf(new IOBuffer(kSmallReadSize));
     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv == ERR_IO_PENDING) {
       data.Resume();
       rv = read_callback.WaitForResult();
     }
@@ skipping 164 matching lines @@
   // Verify second response.
   const HttpResponseInfo* response = trans2.GetResponseInfo();
   ASSERT_TRUE(response);
   EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP2, response->connection_info);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_alpn_negotiated);
   EXPECT_EQ("127.0.0.1", response->socket_address.host());
   EXPECT_EQ(443, response->socket_address.port());
-  std::string response_data;
+  SpdyString response_data;
   rv = ReadTransaction(&trans2, &response_data);
   EXPECT_THAT(rv, IsOk());
   EXPECT_EQ("hello!", response_data);
 
   // Graceful GOAWAY was received, SpdySession should be unavailable.
   spdy_session = spdy_session_pool->FindAvailableSession(
       key, GURL(),
       /* enable_ip_based_pooling = */ true, log);
   EXPECT_FALSE(spdy_session);
 
@@ skipping 95 matching lines @@
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1_1,
             response->connection_info);
   EXPECT_TRUE(response->was_alpn_negotiated);
   EXPECT_TRUE(request.url.SchemeIs("https"));
   EXPECT_EQ("127.0.0.1", response->socket_address.host());
   EXPECT_EQ(443, response->socket_address.port());
-  std::string response_data;
+  SpdyString response_data;
   ASSERT_THAT(ReadTransaction(helper.trans(), &response_data), IsOk());
   EXPECT_EQ("hello", response_data);
 }
 
 // Retry with HTTP/1.1 to the proxy when receiving HTTP_1_1_REQUIRED from the
 // proxy.  Note that no actual protocol negotiation happens, instead this test
 // forces protocols for both sockets.
 TEST_F(SpdyNetworkTransactionTest, HTTP11RequiredProxyRetry) {
   HttpRequestInfo request;
   request.method = "GET";
@@ skipping 74 matching lines @@
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1_1,
             response->connection_info);
   EXPECT_FALSE(response->was_alpn_negotiated);
   EXPECT_TRUE(request.url.SchemeIs("https"));
   EXPECT_EQ("127.0.0.1", response->socket_address.host());
   EXPECT_EQ(70, response->socket_address.port());
-  std::string response_data;
+  SpdyString response_data;
   ASSERT_THAT(ReadTransaction(helper.trans(), &response_data), IsOk());
   EXPECT_EQ("hello", response_data);
 }
 
 // Test to make sure we can correctly connect through a proxy.
 TEST_F(SpdyNetworkTransactionTest, ProxyConnect) {
   auto session_deps = base::MakeUnique<SpdySessionDependencies>(
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      NetLogWithSource(),
@@ skipping 31 matching lines @@
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback.WaitForResult();
   EXPECT_EQ(0, rv);
 
   // Verify the response headers.
   HttpResponseInfo response = *trans->GetResponseInfo();
   ASSERT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
-  std::string response_data;
+  SpdyString response_data;
   ASSERT_THAT(ReadTransaction(trans, &response_data), IsOk());
   EXPECT_EQ("hello!", response_data);
   helper.VerifyDataConsumed();
 }
 
 // Test to make sure we can correctly connect through a proxy to
 // www.example.org, if there already exists a direct spdy connection to
 // www.example.org. See https://crbug.com/49874.
 TEST_F(SpdyNetworkTransactionTest, DirectConnectProxyReconnect) {
   // Use a proxy service which returns a proxy fallback list from DIRECT to
@@ skipping 102 matching lines @@
   int rv = trans_proxy->Start(&request_proxy, callback_proxy.callback(),
                               NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback_proxy.WaitForResult();
   EXPECT_EQ(0, rv);
 
   HttpResponseInfo response_proxy = *trans_proxy->GetResponseInfo();
   ASSERT_TRUE(response_proxy.headers);
   EXPECT_EQ("HTTP/1.1 200", response_proxy.headers->GetStatusLine());
 
-  std::string response_data;
+  SpdyString response_data;
   ASSERT_THAT(ReadTransaction(trans_proxy, &response_data), IsOk());
   EXPECT_EQ("hello!", response_data);
 
   helper_proxy.VerifyDataConsumed();
 }
 
 // When we get a TCP-level RST, we need to retry a HttpNetworkTransaction
 // on a new connection, if the connection was previously known to be good.
 // This can happen when a server reboots without saying goodbye, or when
 // we're behind a NAT that masked the RST.
@@ skipping 62 matching lines @@
         // Now schedule the ERR_CONNECTION_RESET.
         data1.Resume();
       }
       rv = callback.WaitForResult();
       EXPECT_THAT(rv, IsOk());
 
       const HttpResponseInfo* response = trans.GetResponseInfo();
       ASSERT_TRUE(response);
       EXPECT_TRUE(response->headers);
       EXPECT_TRUE(response->was_fetched_via_spdy);
-      std::string response_data;
+      SpdyString response_data;
       rv = ReadTransaction(&trans, &response_data);
       EXPECT_THAT(rv, IsOk());
       EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
       EXPECT_EQ("hello!", response_data);
       base::RunLoop().RunUntilIdle();
     }
 
     helper.VerifyDataConsumed();
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 120 matching lines @@
       CreateMockRead(stream1_reply, 1),
       CreateMockRead(stream2_syn, 2),
       CreateMockRead(stream2_headers, 4),
       CreateMockRead(stream1_body, 5, SYNCHRONOUS),
       CreateMockRead(stream2_body, 6),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 7),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
-  std::string expected_push_result("pushed");
+  SpdyString expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
@@ skipping 31 matching lines @@
       2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),   CreateMockRead(stream2_syn, 2),
       CreateMockRead(stream1_body, 4),    MockRead(ASYNC, ERR_IO_PENDING, 5),
       CreateMockRead(stream2_headers, 6), CreateMockRead(stream2_body, 7),
       MockRead(ASYNC, ERR_IO_PENDING, 8), MockRead(ASYNC, 0, 9),  // EOF
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
-  std::string expected_push_result("pushed");
+  SpdyString expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      NetLogWithSource(), nullptr);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction.
@@ skipping 11 matching lines @@
   // headers are not yet complete.
   HttpNetworkTransaction trans2(DEFAULT_PRIORITY, helper.session());
   rv = trans2.Start(&CreateGetPushRequest(), callback.callback(),
                     NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   data.Resume();
   data.RunUntilPaused();
   base::RunLoop().RunUntilIdle();
 
   // Read the server push body.
-  std::string result2;
+  SpdyString result2;
   ReadResult(&trans2, &result2);
   // Read the response body.
-  std::string result;
+  SpdyString result;
   ReadResult(trans, &result);
 
   // Verify that the received push data is same as the expected push data.
   EXPECT_EQ(result2.compare(expected_push_result), 0)
       << "Received data: "
       << result2
       << "||||| Expected data: "
       << expected_push_result;
 
   // Verify the response headers.
@@ skipping 167 matching lines @@
     TestCompletionCallback callback;
 
     int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     rv = callback.WaitForResult();
 
     // Finish async network reads/writes.
     base::RunLoop().RunUntilIdle();
 
     // Read the response body.
-    std::string result;
+    SpdyString result;
     ReadResult(trans, &result);
 
     // Verify that we consumed all test data.
     EXPECT_TRUE(data.AllReadDataConsumed());
     EXPECT_TRUE(data.AllWriteDataConsumed());
 
     // Verify the response headers.
     // Copy the response info, because trans goes away.
     response = *trans->GetResponseInfo();
 
@@ skipping 76 matching lines @@
   rv = callback1.GetResult(rv);
   EXPECT_THAT(rv, IsOk());
 
   EXPECT_TRUE(spdy_session->unclaimed_pushed_streams_.empty());
   EXPECT_EQ(0u, spdy_session->unclaimed_pushed_streams_.size());
 
   HttpResponseInfo response = *trans0->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
-  std::string result0;
+  SpdyString result0;
   ReadResult(trans0, &result0);
   EXPECT_EQ("hello!", result0);
 
   HttpResponseInfo push_response = *trans1.GetResponseInfo();
   EXPECT_TRUE(push_response.headers);
   EXPECT_EQ("HTTP/1.1 200", push_response.headers->GetStatusLine());
 
-  std::string result1;
+  SpdyString result1;
   ReadResult(&trans1, &result1);
   EXPECT_EQ(kPushedData, result1);
 
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
   VerifyStreamsClosed(helper);
 }
 
 // Verify that push works cross origin, even if there is already a connection
 // open to origin of pushed resource.
@@ skipping 135 matching lines @@
   EXPECT_TRUE(spdy_session0->unclaimed_pushed_streams_.empty());
   EXPECT_EQ(0u, spdy_session0->unclaimed_pushed_streams_.size());
 
   EXPECT_TRUE(spdy_session1->unclaimed_pushed_streams_.empty());
   EXPECT_EQ(0u, spdy_session1->unclaimed_pushed_streams_.size());
 
   HttpResponseInfo response0 = *trans0->GetResponseInfo();
   EXPECT_TRUE(response0.headers);
   EXPECT_EQ("HTTP/1.1 200", response0.headers->GetStatusLine());
 
-  std::string result0;
+  SpdyString result0;
   ReadResult(trans0, &result0);
   EXPECT_EQ(kData0, result0);
 
   HttpResponseInfo response1 = *trans1.GetResponseInfo();
   EXPECT_TRUE(response1.headers);
   EXPECT_EQ("HTTP/1.1 200", response1.headers->GetStatusLine());
 
-  std::string result1;
+  SpdyString result1;
   ReadResult(&trans1, &result1);
   EXPECT_EQ(kData1, result1);
 
   HttpResponseInfo push_response = *trans2.GetResponseInfo();
   EXPECT_TRUE(push_response.headers);
   EXPECT_EQ("HTTP/1.1 200", push_response.headers->GetStatusLine());
 
-  std::string result2;
+  SpdyString result2;
   ReadResult(&trans2, &result2);
   EXPECT_EQ(kPushedData, result2);
 
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
   VerifyStreamsClosed(helper);
 }
 
 TEST_F(SpdyNetworkTransactionTest, ServerPushInvalidCrossOrigin) {
   // "spdy_pooling.pem" is valid for www.example.org,
@@ skipping 204 matching lines @@
 // write, leading to a complete write of request body; after that we send
 // a reply with a body, to cause a graceful shutdown.
 
 // TODO(agayev): develop a socket data provider where both, reads and
 // writes are ordered so that writing tests like these are easy and rewrite
 // all these tests using it.  Right now we are working around the
 // limitations as described above and it's not deterministic, tests may
 // fail under specific circumstances.
 TEST_F(SpdyNetworkTransactionTest, WindowUpdateReceived) {
   static int kFrameCount = 2;
-  std::unique_ptr<std::string> content(
-      new std::string(kMaxSpdyFrameChunkSize, 'a'));
+  std::unique_ptr<SpdyString> content(
+      new SpdyString(kMaxSpdyFrameChunkSize, 'a'));
   SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, nullptr,
       0));
   SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(
       1, content->c_str(), content->size(), false));
   SpdySerializedFrame body_end(spdy_util_.ConstructSpdyDataFrame(
       1, content->c_str(), content->size(), true));
 
   MockWrite writes[] = {
       CreateMockWrite(req, 0), CreateMockWrite(body, 1),
@@ skipping 122 matching lines @@
                              kHttp2ConnectionHeaderPrefixSize, 0));
   writes.push_back(CreateMockWrite(initial_settings_frame, writes.size()));
   writes.push_back(CreateMockWrite(initial_window_update, writes.size()));
   writes.push_back(CreateMockWrite(req, writes.size()));
 
   std::vector<MockRead> reads;
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
   reads.push_back(CreateMockRead(resp, writes.size() + reads.size()));
 
   std::vector<SpdySerializedFrame> body_frames;
-  const std::string body_data(kChunkSize, 'x');
+  const SpdyString body_data(kChunkSize, 'x');
   for (size_t remaining = kTargetSize; remaining != 0;) {
     size_t frame_size = std::min(remaining, body_data.size());
     body_frames.push_back(spdy_util_.ConstructSpdyDataFrame(1, body_data.data(),
                                                             frame_size, false));
     reads.push_back(
         CreateMockRead(body_frames.back(), writes.size() + reads.size()));
     remaining -= frame_size;
   }
   // Yield.
   reads.push_back(
@@ skipping 62 matching lines @@
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
 }
 
 // Test that WINDOW_UPDATE frame causing overflow is handled correctly.
 TEST_F(SpdyNetworkTransactionTest, WindowUpdateOverflow) {
   // Number of full frames we hope to write (but will not, used to
   // set content-length header correctly)
   static int kFrameCount = 3;
 
-  std::unique_ptr<std::string> content(
-      new std::string(kMaxSpdyFrameChunkSize, 'a'));
+  std::unique_ptr<SpdyString> content(
+      new SpdyString(kMaxSpdyFrameChunkSize, 'a'));
   SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, nullptr,
       0));
   SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(
       1, content->c_str(), content->size(), false));
   SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, ERROR_CODE_FLOW_CONTROL_ERROR));
 
   // We're not going to write a data frame with FIN, we'll receive a bad
   // WINDOW_UPDATE while sending a request and will send a RST_STREAM frame.
@@ skipping 63 matching lines @@
   // |initial_window_size|.
   size_t num_upload_buffers =
       ceil(static_cast<double>(initial_window_size) / kBufferSize);
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
 
   // Construct content for a data frame of maximum size.
-  std::string content(kMaxSpdyFrameChunkSize, 'a');
+  SpdyString content(kMaxSpdyFrameChunkSize, 'a');
 
   SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1,
       /*content_length=*/kBufferSize * num_upload_buffers + kUploadDataSize,
       LOWEST, nullptr, 0));
 
   // Full frames.
   SpdySerializedFrame body1(spdy_util_.ConstructSpdyDataFrame(
       1, content.c_str(), content.size(), false));
 
   // Last frame in each upload data buffer.
   SpdySerializedFrame body2(spdy_util_.ConstructSpdyDataFrame(
       1, content.c_str(), kBufferSize % kMaxSpdyFrameChunkSize, false));
 
   // The very last frame before the stalled frames.
   SpdySerializedFrame body3(spdy_util_.ConstructSpdyDataFrame(
       1, content.c_str(),
       initial_window_size % kBufferSize % kMaxSpdyFrameChunkSize, false));
 
   // Data frames to be sent once WINDOW_UPDATE frame is received.
 
   // If kBufferSize * num_upload_buffers > initial_window_size,
   // we need one additional frame to send the rest of 'a'.
-  std::string last_body(kBufferSize * num_upload_buffers - initial_window_size,
-                        'a');
+  SpdyString last_body(kBufferSize * num_upload_buffers - initial_window_size,
+                       'a');
   SpdySerializedFrame body4(spdy_util_.ConstructSpdyDataFrame(
       1, last_body.c_str(), last_body.size(), false));
 
   // Also send a "hello!" after WINDOW_UPDATE.
   SpdySerializedFrame body5(spdy_util_.ConstructSpdyDataFrame(1, true));
 
   // Fill in mock writes.
   size_t i = 0;
   std::vector<MockWrite> writes;
   writes.push_back(CreateMockWrite(req, i++));
@@ skipping 36 matching lines @@
   SpdySerializedFrame reply(spdy_util_.ConstructSpdyPostReply(nullptr, 0));
   reads.push_back(CreateMockRead(reply, i++));
   reads.push_back(CreateMockRead(body2, i++));
   reads.push_back(CreateMockRead(body5, i++));
   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
 
   SequencedSocketData data(reads.data(), reads.size(), writes.data(),
                            writes.size());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-  std::string upload_data_string(kBufferSize * num_upload_buffers, 'a');
+  SpdyString upload_data_string(kBufferSize * num_upload_buffers, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size())));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = default_url_;
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
@@ skipping 47 matching lines @@
   // |initial_window_size|.
   size_t num_upload_buffers =
       ceil(static_cast<double>(initial_window_size) / kBufferSize);
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
 
   // Construct content for a data frame of maximum size.
-  std::string content(kMaxSpdyFrameChunkSize, 'a');
+  SpdyString content(kMaxSpdyFrameChunkSize, 'a');
 
   SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1,
       /*content_length=*/kBufferSize * num_upload_buffers + kUploadDataSize,
       LOWEST, nullptr, 0));
 
   // Full frames.
   SpdySerializedFrame body1(spdy_util_.ConstructSpdyDataFrame(
       1, content.c_str(), content.size(), false));
 
   // Last frame in each upload data buffer.
   SpdySerializedFrame body2(spdy_util_.ConstructSpdyDataFrame(
       1, content.c_str(), kBufferSize % kMaxSpdyFrameChunkSize, false));
 
   // The very last frame before the stalled frames.
   SpdySerializedFrame body3(spdy_util_.ConstructSpdyDataFrame(
       1, content.c_str(),
       initial_window_size % kBufferSize % kMaxSpdyFrameChunkSize, false));
 
   // Data frames to be sent once WINDOW_UPDATE frame is received.
 
   // If kBufferSize * num_upload_buffers > initial_window_size,
   // we need one additional frame to send the rest of 'a'.
-  std::string last_body(kBufferSize * num_upload_buffers - initial_window_size,
-                        'a');
+  SpdyString last_body(kBufferSize * num_upload_buffers - initial_window_size,
+                       'a');
   SpdySerializedFrame body4(spdy_util_.ConstructSpdyDataFrame(
       1, last_body.c_str(), last_body.size(), false));
 
   // Also send a "hello!" after WINDOW_UPDATE.
   SpdySerializedFrame body5(spdy_util_.ConstructSpdyDataFrame(1, true));
 
   // Fill in mock writes.
   size_t i = 0;
   std::vector<MockWrite> writes;
   writes.push_back(CreateMockWrite(req, i++));
@@ skipping 45 matching lines @@
   reads.push_back(CreateMockRead(body2, i++));
   reads.push_back(CreateMockRead(body5, i++));
   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
 
   // Force all writes to happen before any read, last write will not
   // actually queue a frame, due to window size being 0.
   SequencedSocketData data(reads.data(), reads.size(), writes.data(),
                            writes.size());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-  std::string upload_data_string(kBufferSize * num_upload_buffers, 'a');
+  SpdyString upload_data_string(kBufferSize * num_upload_buffers, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size())));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = default_url_;
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
@@ skipping 50 matching lines @@
   // |initial_window_size|.
   size_t num_upload_buffers =
       ceil(static_cast<double>(initial_window_size) / kBufferSize);
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
 
   // Construct content for a data frame of maximum size.
-  std::string content(kMaxSpdyFrameChunkSize, 'a');
+  SpdyString content(kMaxSpdyFrameChunkSize, 'a');
 
   SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1,
       /*content_length=*/kBufferSize * num_upload_buffers + kUploadDataSize,
       LOWEST, nullptr, 0));
 
   // Full frames.
   SpdySerializedFrame body1(spdy_util_.ConstructSpdyDataFrame(
       1, content.c_str(), content.size(), false));
 
   // Last frame in each upload data buffer.
   SpdySerializedFrame body2(spdy_util_.ConstructSpdyDataFrame(
       1, content.c_str(), kBufferSize % kMaxSpdyFrameChunkSize, false));
 
   // The very last frame before the stalled frames.
   SpdySerializedFrame body3(spdy_util_.ConstructSpdyDataFrame(
       1, content.c_str(),
       initial_window_size % kBufferSize % kMaxSpdyFrameChunkSize, false));
 
   // Data frames to be sent once WINDOW_UPDATE frame is received.
 
   // If kBufferSize * num_upload_buffers > initial_window_size,
   // we need one additional frame to send the rest of 'a'.
-  std::string last_body(kBufferSize * num_upload_buffers - initial_window_size,
-                        'a');
+  SpdyString last_body(kBufferSize * num_upload_buffers - initial_window_size,
+                       'a');
   SpdySerializedFrame body4(spdy_util_.ConstructSpdyDataFrame(
       1, last_body.c_str(), last_body.size(), false));
 
   // Also send a "hello!" after WINDOW_UPDATE.
   SpdySerializedFrame body5(spdy_util_.ConstructSpdyDataFrame(1, true));
 
   // Fill in mock writes.
   size_t i = 0;
   std::vector<MockWrite> writes;
   writes.push_back(CreateMockWrite(req, i++));
@@ skipping 47 matching lines @@
   reads.push_back(CreateMockRead(body2, i++));
   reads.push_back(CreateMockRead(body5, i++));
   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
 
   // Force all writes to happen before any read, last write will not
   // actually queue a frame, due to window size being 0.
   SequencedSocketData data(reads.data(), reads.size(), writes.data(),
                            writes.size());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-  std::string upload_data_string(kBufferSize * num_upload_buffers, 'a');
+  SpdyString upload_data_string(kBufferSize * num_upload_buffers, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size())));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = default_url_;
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
@@ skipping 87 matching lines @@
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      NetLogWithSource(), nullptr);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
 // Regression test for https://crbug.com/493348: request header exceeds 16 kB
 // and thus sent in multiple frames when using HTTP/2.
 TEST_F(SpdyNetworkTransactionTest, LargeRequest) {
-  const std::string kKey("foo");
-  const std::string kValue(1 << 15, 'z');
+  const SpdyString kKey("foo");
+  const SpdyString kValue(1 << 15, 'z');
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = default_url_;
   request.extra_headers.SetHeader(kKey, kValue);
 
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   headers[kKey] = kValue;
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyHeaders(1, std::move(headers), LOWEST, true));
@@ skipping 23 matching lines @@
 TEST_F(SpdyNetworkTransactionTest, LargeResponseHeader) {
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyHeaders(1, std::move(headers), LOWEST, true));
   MockWrite writes[] = {
       CreateMockWrite(req, 0),
   };
 
   // HPACK decoder implementation limits string literal length to 16 kB.
   const char* response_headers[2];
-  const std::string kKey(16 * 1024, 'a');
+  const SpdyString kKey(16 * 1024, 'a');
   response_headers[0] = kKey.data();
-  const std::string kValue(16 * 1024, 'b');
+  const SpdyString kValue(16 * 1024, 'b');
   response_headers[1] = kValue.data();
 
   SpdySerializedFrame resp(
       spdy_util_.ConstructSpdyGetReply(response_headers, 1, 1));
   SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(resp, 1), CreateMockRead(body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
@@ skipping 239 matching lines @@
 TEST_F(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net