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

net/spdy/bidirectional_stream_spdy_impl_unittest.cc

 // Copyright 2016 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/bidirectional_stream_spdy_impl.h"
 
 #include <memory>
-#include <string>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/timer/mock_timer.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/log/test_net_log.h"
 #include "net/socket/socket_test_util.h"
+#include "net/spdy/platform/api/spdy_string.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_test_util_common.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::test::IsError;
 using net::test::IsOk;
@@ skipping 155 matching lines @@
 
   int64_t GetTotalSentBytes() const {
       return stream_->GetTotalSentBytes();
   }
 
   bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
     return stream_->GetLoadTimingInfo(load_timing_info);
   }
 
   // Const getters for internal states.
-  const std::string& data_received() const { return data_received_; }
+  const SpdyString& data_received() const { return data_received_; }
   int bytes_read() const { return bytes_read_; }
   int error() const { return error_; }
   const SpdyHeaderBlock& response_headers() const { return response_headers_; }
   const SpdyHeaderBlock& trailers() const { return trailers_; }
   int on_data_read_count() const { return on_data_read_count_; }
   int on_data_sent_count() const { return on_data_sent_count_; }
   bool on_failed_called() const { return on_failed_called_; }
 
   // Sets whether the delegate should automatically start reading.
   void set_do_not_start_read(bool do_not_start_read) {
     do_not_start_read_ = do_not_start_read;
   }
 
  private:
   std::unique_ptr<BidirectionalStreamSpdyImpl> stream_;
   scoped_refptr<IOBuffer> read_buf_;
   int read_buf_len_;
-  std::string data_received_;
+  SpdyString data_received_;
   std::unique_ptr<base::RunLoop> loop_;
   SpdyHeaderBlock response_headers_;
   SpdyHeaderBlock trailers_;
   int error_;
   int bytes_read_;
   int on_data_read_count_;
   int on_data_sent_count_;
   bool do_not_start_read_;
   bool run_until_completion_;
   bool not_expect_callback_;
@@ skipping 78 matching lines @@
                                        base::SizeTToString(kBodyDataSize));
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(session_, read_buffer.get(), kReadBufferSize));
   delegate->SetRunUntilCompletion(true);
   delegate->Start(&request_info, net_log_.bound());
   sequenced_data_->RunUntilPaused();
 
   scoped_refptr<StringIOBuffer> write_buffer(
-      new StringIOBuffer(std::string(kBodyData, kBodyDataSize)));
+      new StringIOBuffer(SpdyString(kBodyData, kBodyDataSize)));
   delegate->SendData(write_buffer.get(), write_buffer->size(), true);
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
   delegate->WaitUntilCompletion();
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(delegate->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReused(load_timing_info);
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(1, delegate->on_data_sent_count());
@@ skipping 131 matching lines @@
                                        base::SizeTToString(kBodyDataSize * 3));
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(session_, read_buffer.get(), kReadBufferSize));
   delegate->SetRunUntilCompletion(true);
   delegate->Start(&request_info, net_log_.bound());
   sequenced_data_->RunUntilPaused();
   // Make a write pending before receiving RST_STREAM.
   scoped_refptr<StringIOBuffer> write_buffer(
-      new StringIOBuffer(std::string(kBodyData, kBodyDataSize)));
+      new StringIOBuffer(SpdyString(kBodyData, kBodyDataSize)));
   delegate->SendData(write_buffer.get(), write_buffer->size(), false);
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
 
   // Make sure OnClose() without an error completes any pending write().
   EXPECT_EQ(1, delegate->on_data_sent_count());
   EXPECT_FALSE(delegate->on_failed_called());
 
   if (is_test_sendv) {
     std::vector<scoped_refptr<IOBuffer>> three_buffers = {
@@ skipping 32 matching lines @@
   } else {
     delegate->SendData(write_buffer.get(), write_buffer->size(), true);
   }
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(delegate->error(), IsError(ERR_UNEXPECTED));
   EXPECT_TRUE(delegate->on_failed_called());
   EXPECT_EQ(is_test_sendv ? 2 : 4, delegate->on_data_sent_count());
 }
 
 }  // namespace net