Change scoped_ptr to std::unique_ptr in //net.

net/tools/flip_server/spdy_interface_test.cc

 // Copyright 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/tools/flip_server/spdy_interface.h"
 
 #include <list>
+#include <memory>
 
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "net/spdy/buffered_spdy_framer.h"
 #include "net/tools/balsa/balsa_enums.h"
 #include "net/tools/balsa/balsa_headers.h"
 #include "net/tools/flip_server/flip_config.h"
 #include "net/tools/flip_server/flip_test_utils.h"
 #include "net/tools/flip_server/mem_cache.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 167 matching lines @@
       delete *i;
     }
     output_list.clear();
   }
 
   bool HasStream(uint32_t stream_id) {
     return interface_->output_ordering().ExistsInPriorityMaps(stream_id);
   }
 
  protected:
-  scoped_ptr<MockSMInterface> mock_another_interface_;
-  scoped_ptr<MemoryCache> memory_cache_;
-  scoped_ptr<FlipAcceptor> acceptor_;
-  scoped_ptr<EpollServer> epoll_server_;
-  scoped_ptr<FakeSMConnection> connection_;
-  scoped_ptr<TestSpdySM> interface_;
-  scoped_ptr<BufferedSpdyFramer> spdy_framer_;
-  scoped_ptr<SpdyFramerVisitor> spdy_framer_visitor_;
+  std::unique_ptr<MockSMInterface> mock_another_interface_;
+  std::unique_ptr<MemoryCache> memory_cache_;
+  std::unique_ptr<FlipAcceptor> acceptor_;
+  std::unique_ptr<EpollServer> epoll_server_;
+  std::unique_ptr<FakeSMConnection> connection_;
+  std::unique_ptr<TestSpdySM> interface_;
+  std::unique_ptr<BufferedSpdyFramer> spdy_framer_;
+  std::unique_ptr<SpdyFramerVisitor> spdy_framer_visitor_;
 };
 
 class SpdySMProxyTest : public SpdySMTestBase {
  public:
   SpdySMProxyTest() : SpdySMTestBase(FLIP_HANDLER_PROXY) {}
   virtual ~SpdySMProxyTest() {}
 };
 
 class SpdySMServerTest : public SpdySMTestBase {
  public:
   SpdySMServerTest() : SpdySMTestBase(FLIP_HANDLER_SPDY_SERVER) {}
   virtual ~SpdySMServerTest() {}
 };
 
 INSTANTIATE_TEST_CASE_P(SpdySMProxyTest, SpdySMProxyTest, Values(SPDY3, HTTP2));
 INSTANTIATE_TEST_CASE_P(SpdySMServerTest, SpdySMServerTest, Values(HTTP2));
 
 TEST_P(SpdySMProxyTest, InitSMConnection) {
   {
     InSequence s;
     EXPECT_CALL(*connection_, InitSMConnection(_, _, _, _, _, _, _, _));
   }
   interface_->InitSMConnection(
       NULL, NULL, epoll_server_.get(), -1, "", "", "", false);
 }
 
 TEST_P(SpdySMProxyTest, OnStreamFrameData) {
   BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
-  scoped_ptr<MockSMInterface> mock_interface(new MockSMInterface);
+  std::unique_ptr<MockSMInterface> mock_interface(new MockSMInterface);
   uint32_t stream_id = 92;
   uint32_t associated_id = 43;
   SpdyHeaderBlock block;
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
-  scoped_ptr<SpdySerializedFrame> frame(
+  std::unique_ptr<SpdySerializedFrame> frame(
       spdy_framer_->CreatePingFrame(12, false));
   block[":method"] = "GET";
   block[":host"] = "www.example.com";
   block[":path"] = "/path";
   block[":scheme"] = "http";
   block["foo"] = "bar";
   {
     InSequence s;
     EXPECT_CALL(*interface_,
                 FindOrMakeNewSMConnectionInterface(_, _))
@@ skipping 363 matching lines @@
   ASSERT_EQ(2, spdy_framer_->frames_received());
   ASSERT_EQ(2u, actual_header_block.size());
   ASSERT_EQ("404 Not Found", actual_header_block["status"]);
   ASSERT_EQ("HTTP/1.1", actual_header_block["version"]);
   ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size));
 }
 
 }  // namespace
 
 }  // namespace net