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

net/test/embedded_test_server/embedded_test_server_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/test/embedded_test_server/embedded_test_server.h"
 
 #include <utility>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "crypto/nss_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
@@ skipping 140 matching lines @@
   // Waits until the specified number of responses are received.
   void WaitForResponses(int num_responses) {
     num_responses_received_ = 0;
     num_responses_expected_ = num_responses;
     // Will be terminated in OnURLFetchComplete().
     base::MessageLoop::current()->Run();
   }
 
   // Handles |request| sent to |path| and returns the response per |content|,
   // |content type|, and |code|. Saves the request URL for verification.
-  scoped_ptr<HttpResponse> HandleRequest(const std::string& path,
-                                         const std::string& content,
-                                         const std::string& content_type,
-                                         HttpStatusCode code,
-                                         const HttpRequest& request) {
+  std::unique_ptr<HttpResponse> HandleRequest(const std::string& path,
+                                              const std::string& content,
+                                              const std::string& content_type,
+                                              HttpStatusCode code,
+                                              const HttpRequest& request) {
     request_relative_url_ = request.relative_url;
 
     GURL absolute_url = server_->GetURL(request.relative_url);
     if (absolute_url.path() == path) {
-      scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+      std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
       http_response->set_code(code);
       http_response->set_content(content);
       http_response->set_content_type(content_type);
       return std::move(http_response);
     }
 
     return nullptr;
   }
 
  protected:
   int num_responses_received_;
   int num_responses_expected_;
   std::string request_relative_url_;
   base::Thread io_thread_;
   scoped_refptr<TestURLRequestContextGetter> request_context_getter_;
   TestConnectionListener connection_listener_;
-  scoped_ptr<EmbeddedTestServer> server_;
+  std::unique_ptr<EmbeddedTestServer> server_;
 };
 
 TEST_P(EmbeddedTestServerTest, GetBaseURL) {
   ASSERT_TRUE(server_->Start());
   if (GetParam() == EmbeddedTestServer::TYPE_HTTPS) {
     EXPECT_EQ(base::StringPrintf("https://127.0.0.1:%u/", server_->port()),
               server_->base_url().spec());
   } else {
     EXPECT_EQ(base::StringPrintf("http://127.0.0.1:%u/", server_->port()),
               server_->base_url().spec());
@@ skipping 29 matching lines @@
 TEST_P(EmbeddedTestServerTest, RegisterRequestHandler) {
   server_->RegisterRequestHandler(
       base::Bind(&EmbeddedTestServerTest::HandleRequest,
                  base::Unretained(this),
                  "/test",
                  "<b>Worked!</b>",
                  "text/html",
                  HTTP_OK));
   ASSERT_TRUE(server_->Start());
 
-  scoped_ptr<URLFetcher> fetcher =
+  std::unique_ptr<URLFetcher> fetcher =
       URLFetcher::Create(server_->GetURL("/test?q=foo"), URLFetcher::GET, this);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->Start();
   WaitForResponses(1);
 
   EXPECT_EQ(URLRequestStatus::SUCCESS, fetcher->GetStatus().status());
   EXPECT_EQ(HTTP_OK, fetcher->GetResponseCode());
   EXPECT_EQ("<b>Worked!</b>", GetContentFromFetcher(*fetcher));
   EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher));
 
   EXPECT_EQ("/test?q=foo", request_relative_url_);
 }
 
 TEST_P(EmbeddedTestServerTest, ServeFilesFromDirectory) {
   base::FilePath src_dir;
   ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
   server_->ServeFilesFromDirectory(
       src_dir.AppendASCII("net").AppendASCII("data"));
   ASSERT_TRUE(server_->Start());
 
-  scoped_ptr<URLFetcher> fetcher =
+  std::unique_ptr<URLFetcher> fetcher =
       URLFetcher::Create(server_->GetURL("/test.html"), URLFetcher::GET, this);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->Start();
   WaitForResponses(1);
 
   EXPECT_EQ(URLRequestStatus::SUCCESS, fetcher->GetStatus().status());
   EXPECT_EQ(HTTP_OK, fetcher->GetResponseCode());
   EXPECT_EQ("<p>Hello World!</p>", GetContentFromFetcher(*fetcher));
   EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher));
 }
 
 TEST_P(EmbeddedTestServerTest, DefaultNotFoundResponse) {
   ASSERT_TRUE(server_->Start());
 
-  scoped_ptr<URLFetcher> fetcher = URLFetcher::Create(
+  std::unique_ptr<URLFetcher> fetcher = URLFetcher::Create(
       server_->GetURL("/non-existent"), URLFetcher::GET, this);
   fetcher->SetRequestContext(request_context_getter_.get());
 
   fetcher->Start();
   WaitForResponses(1);
   EXPECT_EQ(URLRequestStatus::SUCCESS, fetcher->GetStatus().status());
   EXPECT_EQ(HTTP_NOT_FOUND, fetcher->GetResponseCode());
 }
 
 TEST_P(EmbeddedTestServerTest, ConnectionListenerAccept) {
   ASSERT_TRUE(server_->Start());
 
   TestNetLog net_log;
   net::AddressList address_list;
   EXPECT_TRUE(server_->GetAddressList(&address_list));
 
-  scoped_ptr<StreamSocket> socket =
+  std::unique_ptr<StreamSocket> socket =
       ClientSocketFactory::GetDefaultFactory()->CreateTransportClientSocket(
           address_list, NULL, &net_log, NetLog::Source());
   TestCompletionCallback callback;
   ASSERT_EQ(OK, callback.GetResult(socket->Connect(callback.callback())));
 
   connection_listener_.WaitUntilFirstConnectionAccepted();
 
   EXPECT_EQ(1u, connection_listener_.SocketAcceptedCount());
   EXPECT_FALSE(connection_listener_.DidReadFromSocket());
 }
 
 TEST_P(EmbeddedTestServerTest, ConnectionListenerRead) {
   ASSERT_TRUE(server_->Start());
 
-  scoped_ptr<URLFetcher> fetcher = URLFetcher::Create(
+  std::unique_ptr<URLFetcher> fetcher = URLFetcher::Create(
       server_->GetURL("/non-existent"), URLFetcher::GET, this);
   fetcher->SetRequestContext(request_context_getter_.get());
 
   fetcher->Start();
   WaitForResponses(1);
   EXPECT_EQ(1u, connection_listener_.SocketAcceptedCount());
   EXPECT_TRUE(connection_listener_.DidReadFromSocket());
 }
 
 TEST_P(EmbeddedTestServerTest, ConcurrentFetches) {
@@ skipping 13 matching lines @@
                  HTTP_OK));
   server_->RegisterRequestHandler(
       base::Bind(&EmbeddedTestServerTest::HandleRequest,
                  base::Unretained(this),
                  "/test3",
                  "No chocolates",
                  "text/plain",
                  HTTP_NOT_FOUND));
   ASSERT_TRUE(server_->Start());
 
-  scoped_ptr<URLFetcher> fetcher1 =
+  std::unique_ptr<URLFetcher> fetcher1 =
       URLFetcher::Create(server_->GetURL("/test1"), URLFetcher::GET, this);
   fetcher1->SetRequestContext(request_context_getter_.get());
-  scoped_ptr<URLFetcher> fetcher2 =
+  std::unique_ptr<URLFetcher> fetcher2 =
       URLFetcher::Create(server_->GetURL("/test2"), URLFetcher::GET, this);
   fetcher2->SetRequestContext(request_context_getter_.get());
-  scoped_ptr<URLFetcher> fetcher3 =
+  std::unique_ptr<URLFetcher> fetcher3 =
       URLFetcher::Create(server_->GetURL("/test3"), URLFetcher::GET, this);
   fetcher3->SetRequestContext(request_context_getter_.get());
 
   // Fetch the three URLs concurrently.
   fetcher1->Start();
   fetcher2->Start();
   fetcher3->Start();
   WaitForResponses(3);
 
   EXPECT_EQ(URLRequestStatus::SUCCESS, fetcher1->GetStatus().status());
@@ skipping 51 matching lines @@
         base::Bind(send, "echo",
                    base::Bind(&InfiniteResponse::SendInfinite,
                               weak_ptr_factory_.GetWeakPtr(), send)));
   }
 
   base::WeakPtrFactory<InfiniteResponse> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InfiniteResponse);
 };
 
-scoped_ptr<HttpResponse> HandleInfiniteRequest(const HttpRequest& request) {
-  return make_scoped_ptr(new InfiniteResponse);
+std::unique_ptr<HttpResponse> HandleInfiniteRequest(
+    const HttpRequest& request) {
+  return base::WrapUnique(new InfiniteResponse);
 }
 }
 
 // Tests the case the connection is closed while the server is sending a
 // response.  May non-deterministically end up at one of three paths
 // (Discover the close event synchronously, asynchronously, or server
 // shutting down before it is discovered).
 TEST_P(EmbeddedTestServerTest, CloseDuringWrite) {
   CancelRequestDelegate cancel_delegate;
   TestURLRequestContext context;
   cancel_delegate.set_cancel_in_response_started(true);
   server_->RegisterRequestHandler(base::Bind(
       &HandlePrefixedRequest, "/infinite", base::Bind(&HandleInfiniteRequest)));
   ASSERT_TRUE(server_->Start());
 
-  scoped_ptr<URLRequest> request = context.CreateRequest(
+  std::unique_ptr<URLRequest> request = context.CreateRequest(
       server_->GetURL("/infinite"), DEFAULT_PRIORITY, &cancel_delegate);
   request->Start();
   cancel_delegate.WaitUntilDone();
 }
 
 struct CertificateValuesEntry {
   const EmbeddedTestServer::ServerCertificate server_cert;
   const bool is_expired;
   const char* common_name;
   const char* root;
@@ skipping 73 matching lines @@
 
   // base::PlatformThread::Delegate:
   void ThreadMain() override {
     scoped_refptr<base::SingleThreadTaskRunner> io_thread_runner;
     base::Thread io_thread("io_thread");
     base::Thread::Options thread_options;
     thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
     ASSERT_TRUE(io_thread.StartWithOptions(thread_options));
     io_thread_runner = io_thread.task_runner();
 
-    scoped_ptr<base::MessageLoop> loop;
+    std::unique_ptr<base::MessageLoop> loop;
     if (message_loop_present_on_initialize_)
       loop.reset(new base::MessageLoopForIO);
 
     // Create the test server instance.
     EmbeddedTestServer server(type_);
     base::FilePath src_dir;
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
     ASSERT_TRUE(server.Start());
 
     // Make a request and wait for the reply.
     if (!loop)
       loop.reset(new base::MessageLoopForIO);
 
-    scoped_ptr<URLFetcher> fetcher =
+    std::unique_ptr<URLFetcher> fetcher =
         URLFetcher::Create(server.GetURL("/test?q=foo"), URLFetcher::GET, this);
     fetcher->SetRequestContext(
         new TestURLRequestContextGetter(loop->task_runner()));
     fetcher->Start();
     loop->Run();
     fetcher.reset();
 
     // Shut down.
     if (message_loop_present_on_shutdown_)
       loop.reset();
@@ skipping 29 matching lines @@
 INSTANTIATE_TEST_CASE_P(
     EmbeddedTestServerThreadingTestInstantiation,
     EmbeddedTestServerThreadingTest,
     testing::Combine(testing::Bool(),
                      testing::Bool(),
                      testing::Values(EmbeddedTestServer::TYPE_HTTP,
                                      EmbeddedTestServer::TYPE_HTTPS)));
 
 }  // namespace test_server
 }  // namespace net