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

net/server/http_server_unittest.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/server/http_server.h"
+
 #include <stdint.h>
 
 #include <algorithm>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log.h"
-#include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/socket/tcp_server_socket.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 118 matching lines @@
     // Return true if response has data equal to or more than content length.
     int64_t body_size = static_cast<int64_t>(response.size()) - end_of_headers;
     DCHECK_LE(0, body_size);
     scoped_refptr<HttpResponseHeaders> headers(new HttpResponseHeaders(
         HttpUtil::AssembleRawHeaders(response.data(), end_of_headers)));
     return body_size >= headers->GetContentLength();
   }
 
   scoped_refptr<IOBufferWithSize> read_buffer_;
   scoped_refptr<DrainableIOBuffer> write_buffer_;
-  scoped_ptr<TCPClientSocket> socket_;
+  std::unique_ptr<TCPClientSocket> socket_;
   int connect_result_;
 };
 
 }  // namespace
 
 class HttpServerTest : public testing::Test,
                        public HttpServer::Delegate {
  public:
   HttpServerTest() : quit_after_request_count_(0) {}
 
   void SetUp() override {
-    scoped_ptr<ServerSocket> server_socket(
+    std::unique_ptr<ServerSocket> server_socket(
         new TCPServerSocket(NULL, NetLog::Source()));
     server_socket->ListenWithAddressAndPort("127.0.0.1", 0, 1);
     server_.reset(new HttpServer(std::move(server_socket), this));
     ASSERT_EQ(OK, server_->GetLocalAddress(&server_address_));
   }
 
   void OnConnect(int connection_id) override {}
 
   void OnHttpRequest(int connection_id,
                      const HttpServerRequestInfo& info) override {
@@ skipping 26 matching lines @@
   }
 
   HttpServerRequestInfo GetRequest(size_t request_index) {
     return requests_[request_index].first;
   }
 
   int GetConnectionId(size_t request_index) {
     return requests_[request_index].second;
   }
 
-  void HandleAcceptResult(scoped_ptr<StreamSocket> socket) {
+  void HandleAcceptResult(std::unique_ptr<StreamSocket> socket) {
     server_->accepted_socket_.reset(socket.release());
     server_->HandleAcceptResult(OK);
   }
 
  protected:
-  scoped_ptr<HttpServer> server_;
+  std::unique_ptr<HttpServer> server_;
   IPEndPoint server_address_;
   base::Closure run_loop_quit_func_;
   std::vector<std::pair<HttpServerRequestInfo, int> > requests_;
 
  private:
   size_t quit_after_request_count_;
 };
 
 namespace {
 
@@ skipping 164 matching lines @@
 
    private:
     base::Closure quit_loop_func_;
   };
 
   base::RunLoop run_loop;
   TestURLFetcherDelegate delegate(run_loop.QuitClosure());
 
   scoped_refptr<URLRequestContextGetter> request_context_getter(
       new TestURLRequestContextGetter(base::ThreadTaskRunnerHandle::Get()));
-  scoped_ptr<URLFetcher> fetcher =
+  std::unique_ptr<URLFetcher> fetcher =
       URLFetcher::Create(GURL(base::StringPrintf("http://127.0.0.1:%d/test",
                                                  server_address_.port())),
                          URLFetcher::GET, &delegate);
   fetcher->SetRequestContext(request_context_getter.get());
   fetcher->AddExtraRequestHeader(
       base::StringPrintf("content-length:%d", 1 << 30));
   fetcher->Start();
 
   ASSERT_TRUE(RunLoopWithTimeout(&run_loop));
   ASSERT_EQ(0u, requests_.size());
@@ skipping 124 matching lines @@
   int read_buf_len_;
   CompletionCallback read_callback_;
   std::string pending_read_data_;
   BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(MockStreamSocket);
 };
 
 TEST_F(HttpServerTest, RequestWithBodySplitAcrossPackets) {
   MockStreamSocket* socket = new MockStreamSocket();
-  HandleAcceptResult(make_scoped_ptr<StreamSocket>(socket));
+  HandleAcceptResult(base::WrapUnique<StreamSocket>(socket));
   std::string body("body");
   std::string request_text = base::StringPrintf(
       "GET /test HTTP/1.1\r\n"
       "SomeHeader: 1\r\n"
       "Content-Length: %" PRIuS "\r\n\r\n%s",
       body.length(),
       body.c_str());
   socket->DidRead(request_text.c_str(), request_text.length() - 2);
   ASSERT_EQ(0u, requests_.size());
   socket->DidRead(request_text.c_str() + request_text.length() - 2, 2);
@@ skipping 65 matching lines @@
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   client.Send("GET / HTTP/1.1\r\n\r\n");
   ASSERT_FALSE(RunUntilRequestsReceived(1));
   ASSERT_EQ(1ul, connection_ids_.size());
   ASSERT_EQ(0ul, requests_.size());
 }
 
 }  // namespace
 
 }  // namespace net