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

net/spdy/spdy_proxy_client_socket_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 "net/spdy/spdy_proxy_client_socket.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 104 matching lines @@
                                      "/");
   }
 
   void ResumeAndRun() {
     // Run until the pause, if the provider isn't paused yet.
     data_->RunUntilPaused();
     data_->Resume();
     base::RunLoop().RunUntilIdle();
   }
 
-  void CloseSpdySession(Error error, const std::string& description) {
+  void CloseSpdySession(Error error, const SpdyString& description) {
     spdy_session_->CloseSessionOnError(error, description);
   }
 
   SpdyTestUtil spdy_util_;
   std::unique_ptr<SpdyProxyClientSocket> sock_;
   TestCompletionCallback read_callback_;
   TestCompletionCallback write_callback_;
   std::unique_ptr<SequencedSocketData> data_;
   BoundTestNetLog net_log_;
 
  private:
   std::unique_ptr<HttpNetworkSession> session_;
   scoped_refptr<IOBuffer> read_buf_;
   SpdySessionDependencies session_deps_;
   MockConnect connect_data_;
   base::WeakPtr<SpdySession> spdy_session_;
-  std::string user_agent_;
+  SpdyString user_agent_;
   GURL url_;
   HostPortPair proxy_host_port_;
   HostPortPair endpoint_host_port_pair_;
   ProxyServer proxy_;
   SpdySessionKey endpoint_spdy_session_key_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketTest);
 };
 
 SpdyProxyClientSocketTest::SpdyProxyClientSocketTest()
@@ skipping 82 matching lines @@
 void SpdyProxyClientSocketTest::AssertConnectionEstablished() {
   const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_EQ(200, response->headers->response_code());
 }
 
 void SpdyProxyClientSocketTest::AssertSyncReadEquals(const char* data,
                                                      int len) {
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
   ASSERT_EQ(len, sock_->Read(buf.get(), len, CompletionCallback()));
-  ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
+  ASSERT_EQ(SpdyString(data, len), SpdyString(buf->data(), len));
   ASSERT_TRUE(sock_->IsConnected());
 }
 
 void SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data,
                                                       int len) {
   // Issue the read, which will be completed asynchronously
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Read(buf.get(), len, read_callback_.callback()));
   EXPECT_TRUE(sock_->IsConnected());
 
   ResumeAndRun();
 
   EXPECT_EQ(len, read_callback_.WaitForResult());
   EXPECT_TRUE(sock_->IsConnected());
-  ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
+  ASSERT_EQ(SpdyString(data, len), SpdyString(buf->data(), len));
 }
 
 void SpdyProxyClientSocketTest::AssertReadStarts(const char* data, int len) {
   // Issue the read, which will be completed asynchronously.
   read_buf_ = new IOBuffer(len);
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Read(read_buf_.get(), len, read_callback_.callback()));
   EXPECT_TRUE(sock_->IsConnected());
 }
 
 void SpdyProxyClientSocketTest::AssertReadReturns(const char* data, int len) {
   EXPECT_TRUE(sock_->IsConnected());
 
   // Now the read will return
   EXPECT_EQ(len, read_callback_.WaitForResult());
-  ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
+  ASSERT_EQ(SpdyString(data, len), SpdyString(read_buf_->data(), len));
 }
 
 void SpdyProxyClientSocketTest::AssertAsyncWriteSucceeds(const char* data,
                                                               int len) {
   AssertWriteReturns(data, len, ERR_IO_PENDING);
   AssertWriteLength(len);
 }
 
 void SpdyProxyClientSocketTest::AssertWriteReturns(const char* data,
                                                    int len,
@@ skipping 159 matching lines @@
   AssertConnectFails(ERR_HTTPS_PROXY_TUNNEL_RESPONSE);
 
   const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   const HttpResponseHeaders* headers = response->headers.get();
   ASSERT_EQ(302, headers->response_code());
   ASSERT_FALSE(headers->HasHeader("set-cookie"));
   ASSERT_TRUE(headers->HasHeaderValue("content-length", "0"));
 
-  std::string location;
+  SpdyString location;
   ASSERT_TRUE(headers->IsRedirect(&location));
   ASSERT_EQ(location, kRedirectUrl);
 
   // Let the RST_STREAM write while |rst| is in-scope.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(SpdyProxyClientSocketTest, ConnectFails) {
   SpdySerializedFrame conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
@@ skipping 93 matching lines @@
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   AssertAsyncWriteSucceeds(kMsg1, kLen1);
   AssertAsyncWriteSucceeds(kMsg2, kLen2);
 }
 
 TEST_F(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) {
-  std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
+  SpdyString chunk_data(kMaxSpdyFrameChunkSize, 'x');
   SpdySerializedFrame conn(ConstructConnectRequestFrame());
   SpdySerializedFrame chunk(
       ConstructBodyFrame(chunk_data.data(), chunk_data.length()));
   MockWrite writes[] = {CreateMockWrite(conn, 0, SYNCHRONOUS),
                         CreateMockWrite(chunk, 3, SYNCHRONOUS),
                         CreateMockWrite(chunk, 4, SYNCHRONOUS),
                         CreateMockWrite(chunk, 5, SYNCHRONOUS)};
 
   SpdySerializedFrame resp(ConstructConnectReplyFrame());
   MockRead reads[] = {
       CreateMockRead(resp, 1, ASYNC), MockRead(SYNCHRONOUS, ERR_IO_PENDING, 2),
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
-  std::string big_data(kMaxSpdyFrameChunkSize * 3, 'x');
+  SpdyString big_data(kMaxSpdyFrameChunkSize * 3, 'x');
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(big_data.data(),
                                                    big_data.length()));
 
   EXPECT_EQ(ERR_IO_PENDING,
             sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
   EXPECT_EQ(buf->size(), write_callback_.WaitForResult());
 }
 
 // ----------- Read
 
@@ skipping 189 matching lines @@
 
   // SpdySession consumes the next read and sends it to sock_ to be buffered.
   ResumeAndRun();
   // The payload from the single large data frame will be read across
   // two different reads.
   AssertSyncReadEquals(kMsg33, kLen33);
 
   // Now attempt to do a read of more data than remains buffered
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen33));
   ASSERT_EQ(kLen3, sock_->Read(buf.get(), kLen33, read_callback_.callback()));
-  ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3));
+  ASSERT_EQ(SpdyString(kMsg3, kLen3), SpdyString(buf->data(), kLen3));
   ASSERT_TRUE(sock_->IsConnected());
 }
 
 TEST_F(SpdyProxyClientSocketTest, ReadAuthResponseBody) {
   SpdySerializedFrame conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
       CreateMockWrite(conn, 0, SYNCHRONOUS),
   };
 
   SpdySerializedFrame resp(ConstructConnectAuthReplyFrame());
@@ skipping 208 matching lines @@
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   ResumeAndRun();
 
   ASSERT_FALSE(sock_->IsConnected());
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1));
   ASSERT_EQ(kLen1, sock_->Read(buf.get(), kLen1, CompletionCallback()));
-  ASSERT_EQ(std::string(kMsg1, kLen1), std::string(buf->data(), kLen1));
+  ASSERT_EQ(SpdyString(kMsg1, kLen1), SpdyString(buf->data(), kLen1));
 
   ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
   ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
   sock_->Disconnect();
   ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
             sock_->Read(NULL, 1, CompletionCallback()));
 }
 
 // Calling Write() on a closed socket is an error
 TEST_F(SpdyProxyClientSocketTest, WriteOnClosedStream) {
@@ skipping 68 matching lines @@
   AssertConnectSucceeds();
 
   EXPECT_TRUE(sock_->IsConnected());
 
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_IO_PENDING,
             sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
   // Make sure the write actually starts.
   base::RunLoop().RunUntilIdle();
 
-  CloseSpdySession(ERR_ABORTED, std::string());
+  CloseSpdySession(ERR_ABORTED, SpdyString());
 
   EXPECT_THAT(write_callback_.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
 }
 
 // If the socket is Disconnected with a pending Write(), the callback
 // should not be called.
 TEST_F(SpdyProxyClientSocketTest, DisconnectWithWritePending) {
   SpdySerializedFrame conn(ConstructConnectRequestFrame());
   SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, ERROR_CODE_CANCEL));
@@ skipping 227 matching lines @@
 
   EXPECT_FALSE(sock_.get());
   EXPECT_TRUE(read_callback.have_result());
   EXPECT_FALSE(write_callback_.have_result());
 
   // Let the RST_STREAM write while |rst| is in-scope.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace net