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

net/test/embedded_test_server/embedded_test_server.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/bind.h"
 #include "base/files/file_path.h"
@@ skipping 113 matching lines @@
   base::FilePath key_path = certs_dir.AppendASCII(cert_name);
   std::string key_string;
   CHECK(base::ReadFileToString(key_path, &key_string));
   std::vector<std::string> headers;
   headers.push_back("PRIVATE KEY");
   PEMTokenizer pem_tokenizer(key_string, headers);
   pem_tokenizer.GetNext();
   std::vector<uint8_t> key_vector;
   key_vector.assign(pem_tokenizer.data().begin(), pem_tokenizer.data().end());
 
-  scoped_ptr<crypto::RSAPrivateKey> server_key(
+  std::unique_ptr<crypto::RSAPrivateKey> server_key(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
   context_ =
       CreateSSLServerContext(GetCertificate().get(), *server_key, ssl_config_);
 }
 
 void EmbeddedTestServer::StartAcceptingConnections() {
   DCHECK(!io_thread_.get());
   base::Thread::Options thread_options;
   thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.reset(new base::Thread("EmbeddedTestServer IO Thread"));
@@ skipping 15 matching lines @@
 void EmbeddedTestServer::ShutdownOnIOThread() {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
   weak_factory_.InvalidateWeakPtrs();
   listen_socket_.reset();
   STLDeleteContainerPairSecondPointers(connections_.begin(),
                                        connections_.end());
   connections_.clear();
 }
 
 void EmbeddedTestServer::HandleRequest(HttpConnection* connection,
-                                       scoped_ptr<HttpRequest> request) {
+                                       std::unique_ptr<HttpRequest> request) {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
-  scoped_ptr<HttpResponse> response;
+  std::unique_ptr<HttpResponse> response;
 
   for (const auto& handler : request_handlers_) {
     response = handler.Run(*request);
     if (response)
       break;
   }
 
   if (!response) {
     for (const auto& handler : default_request_handlers_) {
       response = handler.Run(*request);
       if (response)
         break;
     }
   }
 
   if (!response) {
     LOG(WARNING) << "Request not handled. Returning 404: "
                  << request->relative_url;
-    scoped_ptr<BasicHttpResponse> not_found_response(new BasicHttpResponse);
+    std::unique_ptr<BasicHttpResponse> not_found_response(
+        new BasicHttpResponse);
     not_found_response->set_code(HTTP_NOT_FOUND);
     response = std::move(not_found_response);
   }
 
   response->SendResponse(
       base::Bind(&HttpConnection::SendResponseBytes, connection->GetWeakPtr()),
       base::Bind(&EmbeddedTestServer::DidClose, weak_factory_.GetWeakPtr(),
                  connection));
 }
 
@@ skipping 85 matching lines @@
   request_handlers_.push_back(callback);
 }
 
 void EmbeddedTestServer::RegisterDefaultHandler(
     const HandleRequestCallback& callback) {
   // TODO(svaldez): Add check to prevent RegisterHandler from being called
   // after the server has started. https://crbug.com/546060
   default_request_handlers_.push_back(callback);
 }
 
-scoped_ptr<StreamSocket> EmbeddedTestServer::DoSSLUpgrade(
-    scoped_ptr<StreamSocket> connection) {
+std::unique_ptr<StreamSocket> EmbeddedTestServer::DoSSLUpgrade(
+    std::unique_ptr<StreamSocket> connection) {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
   return context_->CreateSSLServerSocket(std::move(connection));
 }
 
 void EmbeddedTestServer::DoAcceptLoop() {
   int rv = OK;
   while (rv == OK) {
     rv = listen_socket_->Accept(
         &accepted_socket_, base::Bind(&EmbeddedTestServer::OnAcceptCompleted,
@@ skipping 10 matching lines @@
   DoAcceptLoop();
 }
 
 void EmbeddedTestServer::OnHandshakeDone(HttpConnection* connection, int rv) {
   if (connection->socket_->IsConnected())
     ReadData(connection);
   else
     DidClose(connection);
 }
 
-void EmbeddedTestServer::HandleAcceptResult(scoped_ptr<StreamSocket> socket) {
+void EmbeddedTestServer::HandleAcceptResult(
+    std::unique_ptr<StreamSocket> socket) {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
   if (connection_listener_)
     connection_listener_->AcceptedSocket(*socket);
 
   if (is_using_ssl_)
     socket = DoSSLUpgrade(std::move(socket));
 
   HttpConnection* http_connection = new HttpConnection(
       std::move(socket),
       base::Bind(&EmbeddedTestServer::HandleRequest, base::Unretained(this)));
@@ skipping 71 matching lines @@
     const base::Closure& closure) {
   // Note that PostTaskAndReply below requires
   // base::ThreadTaskRunnerHandle::Get() to return a task runner for posting
   // the reply task. However, in order to make EmbeddedTestServer universally
   // usable, it needs to cope with the situation where it's running on a thread
   // on which a message loop is not (yet) available or as has been destroyed
   // already.
   //
   // To handle this situation, create temporary message loop to support the
   // PostTaskAndReply operation if the current thread as no message loop.
-  scoped_ptr<base::MessageLoop> temporary_loop;
+  std::unique_ptr<base::MessageLoop> temporary_loop;
   if (!base::MessageLoop::current())
     temporary_loop.reset(new base::MessageLoop());
 
   base::RunLoop run_loop;
   if (!io_thread_->task_runner()->PostTaskAndReply(FROM_HERE, closure,
                                                    run_loop.QuitClosure())) {
     return false;
   }
   run_loop.Run();
 
   return true;
 }
 
 }  // namespace test_server
 }  // namespace net