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

net/spdy/spdy_write_queue_unittest.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_write_queue.h"
 
 #include <cstddef>
 #include <cstring>
 #include <memory>
-#include <string>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/request_priority.h"
 #include "net/log/net_log_with_source.h"
+#include "net/spdy/platform/api/spdy_string.h"
 #include "net/spdy/spdy_buffer_producer.h"
 #include "net/spdy/spdy_stream.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
-using std::string;
-
 const char kOriginal[] = "original";
 const char kRequeued[] = "requeued";
 
 class SpdyWriteQueueTest : public ::testing::Test {};
 
 // Makes a SpdyFrameProducer producing a frame with the data in the
 // given string.
-std::unique_ptr<SpdyBufferProducer> StringToProducer(const std::string& s) {
+std::unique_ptr<SpdyBufferProducer> StringToProducer(const SpdyString& s) {
   std::unique_ptr<char[]> data(new char[s.size()]);
   std::memcpy(data.get(), s.data(), s.size());
   return std::unique_ptr<SpdyBufferProducer>(
       new SimpleBufferProducer(std::unique_ptr<SpdyBuffer>(
           new SpdyBuffer(std::unique_ptr<SpdySerializedFrame>(
               new SpdySerializedFrame(data.release(), s.size(), true))))));
 }
 
 // Makes a SpdyBufferProducer producing a frame with the data in the
 // given int (converted to a string).
@@ skipping 30 matching lines @@
     queue->Enqueue(MEDIUM, SpdyFrameType::RST_STREAM, std::move(producer),
                    base::WeakPtr<SpdyStream>());
   }
 
  private:
   std::unique_ptr<SpdyBuffer> buffer_;
 };
 
 // Produces a frame with the given producer and returns a copy of its
 // data as a string.
-std::string ProducerToString(std::unique_ptr<SpdyBufferProducer> producer) {
+SpdyString ProducerToString(std::unique_ptr<SpdyBufferProducer> producer) {
   std::unique_ptr<SpdyBuffer> buffer = producer->ProduceBuffer();
-  return std::string(buffer->GetRemainingData(), buffer->GetRemainingSize());
+  return SpdyString(buffer->GetRemainingData(), buffer->GetRemainingSize());
 }
 
 // Produces a frame with the given producer and returns a copy of its
 // data as an int (converted from a string).
 int ProducerToInt(std::unique_ptr<SpdyBufferProducer> producer) {
   int i = 0;
   EXPECT_TRUE(base::StringToInt(ProducerToString(std::move(producer)), &i));
   return i;
 }
 
@@ skipping 193 matching lines @@
       DEFAULT_PRIORITY, SpdyFrameType::HEADERS,
       std::unique_ptr<SpdyBufferProducer>(new RequeingBufferProducer(&queue)),
       base::WeakPtr<SpdyStream>());
   {
     SpdyFrameType frame_type;
     std::unique_ptr<SpdyBufferProducer> producer;
     base::WeakPtr<SpdyStream> stream;
 
     EXPECT_TRUE(queue.Dequeue(&frame_type, &producer, &stream));
     EXPECT_TRUE(queue.IsEmpty());
-    EXPECT_EQ(string(kOriginal), producer->ProduceBuffer()->GetRemainingData());
+    EXPECT_EQ(SpdyString(kOriginal),
+              producer->ProduceBuffer()->GetRemainingData());
   }
   // |producer| was destroyed, and a buffer is re-queued.
   EXPECT_FALSE(queue.IsEmpty());
 
   SpdyFrameType frame_type;
   std::unique_ptr<SpdyBufferProducer> producer;
   base::WeakPtr<SpdyStream> stream;
 
   EXPECT_TRUE(queue.Dequeue(&frame_type, &producer, &stream));
-  EXPECT_EQ(string(kRequeued), producer->ProduceBuffer()->GetRemainingData());
+  EXPECT_EQ(SpdyString(kRequeued),
+            producer->ProduceBuffer()->GetRemainingData());
 }
 
 TEST_F(SpdyWriteQueueTest, ReentranceOnClear) {
   SpdyWriteQueue queue;
   queue.Enqueue(
       DEFAULT_PRIORITY, SpdyFrameType::HEADERS,
       std::unique_ptr<SpdyBufferProducer>(new RequeingBufferProducer(&queue)),
       base::WeakPtr<SpdyStream>());
 
   queue.Clear();
   EXPECT_FALSE(queue.IsEmpty());
 
   SpdyFrameType frame_type;
   std::unique_ptr<SpdyBufferProducer> producer;
   base::WeakPtr<SpdyStream> stream;
 
   EXPECT_TRUE(queue.Dequeue(&frame_type, &producer, &stream));
-  EXPECT_EQ(string(kRequeued), producer->ProduceBuffer()->GetRemainingData());
+  EXPECT_EQ(SpdyString(kRequeued),
+            producer->ProduceBuffer()->GetRemainingData());
 }
 
 TEST_F(SpdyWriteQueueTest, ReentranceOnRemovePendingWritesAfter) {
   std::unique_ptr<SpdyStream> stream(MakeTestStream(DEFAULT_PRIORITY));
   stream->set_stream_id(2);
 
   SpdyWriteQueue queue;
   queue.Enqueue(
       DEFAULT_PRIORITY, SpdyFrameType::HEADERS,
       std::unique_ptr<SpdyBufferProducer>(new RequeingBufferProducer(&queue)),
       stream->GetWeakPtr());
 
   queue.RemovePendingWritesForStreamsAfter(1);
   EXPECT_FALSE(queue.IsEmpty());
 
   SpdyFrameType frame_type;
   std::unique_ptr<SpdyBufferProducer> producer;
   base::WeakPtr<SpdyStream> weak_stream;
 
   EXPECT_TRUE(queue.Dequeue(&frame_type, &producer, &weak_stream));
-  EXPECT_EQ(string(kRequeued), producer->ProduceBuffer()->GetRemainingData());
+  EXPECT_EQ(SpdyString(kRequeued),
+            producer->ProduceBuffer()->GetRemainingData());
 }
 
 TEST_F(SpdyWriteQueueTest, ReentranceOnRemovePendingWritesForStream) {
   std::unique_ptr<SpdyStream> stream(MakeTestStream(DEFAULT_PRIORITY));
   stream->set_stream_id(2);
 
   SpdyWriteQueue queue;
   queue.Enqueue(
       DEFAULT_PRIORITY, SpdyFrameType::HEADERS,
       std::unique_ptr<SpdyBufferProducer>(new RequeingBufferProducer(&queue)),
       stream->GetWeakPtr());
 
   queue.RemovePendingWritesForStream(stream->GetWeakPtr());
   EXPECT_FALSE(queue.IsEmpty());
 
   SpdyFrameType frame_type;
   std::unique_ptr<SpdyBufferProducer> producer;
   base::WeakPtr<SpdyStream> weak_stream;
 
   EXPECT_TRUE(queue.Dequeue(&frame_type, &producer, &weak_stream));
-  EXPECT_EQ(string(kRequeued), producer->ProduceBuffer()->GetRemainingData());
+  EXPECT_EQ(SpdyString(kRequeued),
+            producer->ProduceBuffer()->GetRemainingData());
 }
 
 }  // namespace
 
 }  // namespace net