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

net/test/embedded_test_server/embedded_test_server.h

 // 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.
 
 #ifndef NET_TEST_EMBEDDED_TEST_SERVER_EMBEDDED_TEST_SERVER_H_
 #define NET_TEST_EMBEDDED_TEST_SERVER_EMBEDDED_TEST_SERVER_H_
 
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "crypto/rsa_private_key.h"
 #include "net/base/address_list.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/ip_endpoint.h"
 #include "net/cert/x509_certificate.h"
 #include "net/socket/ssl_server_socket.h"
 #include "net/socket/stream_socket.h"
@@ skipping 20 matching lines @@
 //
 // The common use case for unit tests is below:
 //
 // void SetUp() {
 //   test_server_.reset(new EmbeddedTestServer());
 //   ASSERT_TRUE(test_server_.Start());
 //   test_server_->RegisterRequestHandler(
 //       base::Bind(&FooTest::HandleRequest, base::Unretained(this)));
 // }
 //
-// scoped_ptr<HttpResponse> HandleRequest(const HttpRequest& request) {
+// std::unique_ptr<HttpResponse> HandleRequest(const HttpRequest& request) {
 //   GURL absolute_url = test_server_->GetURL(request.relative_url);
 //   if (absolute_url.path() != "/test")
-//     return scoped_ptr<HttpResponse>();
+//     return std::unique_ptr<HttpResponse>();
 //
-//   scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
+//   std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
 //   http_response->set_code(test_server::SUCCESS);
 //   http_response->set_content("hello");
 //   http_response->set_content_type("text/plain");
 //   return http_response;
 // }
 //
 // For a test that spawns another process such as browser_tests, it is
 // suggested to call Start in SetUpOnMainThread after the process is spawned.
 //  If you have to do it before the process spawns, you need to first setup the
 // listen socket so that there is no no other threads running while spawning
@@ skipping 31 matching lines @@
     // intermediate cross-signed by an unknown root, while the client (via
     // TestRootStore) is expected to have a self-signed version of the
     // intermediate.
     CERT_CHAIN_WRONG_ROOT,
 
     // Causes the testserver to use a hostname that is a domain
     // instead of an IP.
     CERT_COMMON_NAME_IS_DOMAIN,
   };
 
-  typedef base::Callback<scoped_ptr<HttpResponse>(
-      const HttpRequest& request)> HandleRequestCallback;
+  typedef base::Callback<std::unique_ptr<HttpResponse>(
+      const HttpRequest& request)>
+      HandleRequestCallback;
 
   // Creates a http test server. Start() must be called to start the server.
   // |type| indicates the protocol type of the server (HTTP/HTTPS).
   EmbeddedTestServer();
   explicit EmbeddedTestServer(Type type);
   ~EmbeddedTestServer();
 
   // Sets a connection listener, that would be notified when various connection
   // events happen. May only be called before the server is started. Caller
   // maintains ownership of the listener.
@@ skipping 79 matching lines @@
 
   // Adds default handlers, including those added by AddDefaultHandlers, to be
   // tried after all other user-specified handlers have been tried.
   void RegisterDefaultHandler(const HandleRequestCallback& callback);
 
  private:
   // Shuts down the server.
   void ShutdownOnIOThread();
 
   // Upgrade the TCP connection to one over SSL.
-  scoped_ptr<StreamSocket> DoSSLUpgrade(scoped_ptr<StreamSocket> connection);
+  std::unique_ptr<StreamSocket> DoSSLUpgrade(
+      std::unique_ptr<StreamSocket> connection);
   // Handles async callback when the SSL handshake has been completed.
   void OnHandshakeDone(HttpConnection* connection, int rv);
 
   // Begins accepting new client connections.
   void DoAcceptLoop();
   // Handles async callback when there is a new client socket. |rv| is the
   // return value of the socket Accept.
   void OnAcceptCompleted(int rv);
   // Adds the new |socket| to the list of clients and begins the reading
   // data.
-  void HandleAcceptResult(scoped_ptr<StreamSocket> socket);
+  void HandleAcceptResult(std::unique_ptr<StreamSocket> socket);
 
   // Attempts to read data from the |connection|'s socket.
   void ReadData(HttpConnection* connection);
   // Handles async callback when new data has been read from the |connection|.
   void OnReadCompleted(HttpConnection* connection, int rv);
   // Parses the data read from the |connection| and returns true if the entire
   // request has been received.
   bool HandleReadResult(HttpConnection* connection, int rv);
 
   // Closes and removes the connection upon error or completion.
   void DidClose(HttpConnection* connection);
 
   // Handles a request when it is parsed. It passes the request to registered
   // request handlers and sends a http response.
   void HandleRequest(HttpConnection* connection,
-                     scoped_ptr<HttpRequest> request);
+                     std::unique_ptr<HttpRequest> request);
 
   // Initializes the SSLServerContext so that SSLServerSocket connections may
   // share the same cache
   void InitializeSSLServerContext();
 
   HttpConnection* FindConnection(StreamSocket* socket);
 
   // Posts a task to the |io_thread_| and waits for a reply.
   bool PostTaskToIOThreadAndWait(
       const base::Closure& closure) WARN_UNUSED_RESULT;
 
   const bool is_using_ssl_;
 
-  scoped_ptr<base::Thread> io_thread_;
+  std::unique_ptr<base::Thread> io_thread_;
 
-  scoped_ptr<TCPServerSocket> listen_socket_;
-  scoped_ptr<StreamSocket> accepted_socket_;
+  std::unique_ptr<TCPServerSocket> listen_socket_;
+  std::unique_ptr<StreamSocket> accepted_socket_;
 
   EmbeddedTestServerConnectionListener* connection_listener_;
   uint16_t port_;
   GURL base_url_;
   IPEndPoint local_endpoint_;
 
   // Owns the HttpConnection objects.
   std::map<StreamSocket*, HttpConnection*> connections_;
 
   // Vector of registered and default request handlers.
   std::vector<HandleRequestCallback> request_handlers_;
   std::vector<HandleRequestCallback> default_request_handlers_;
 
   base::ThreadChecker thread_checker_;
 
   net::SSLServerConfig ssl_config_;
   ServerCertificate cert_;
-  scoped_ptr<SSLServerContext> context_;
+  std::unique_ptr<SSLServerContext> context_;
 
   base::WeakPtrFactory<EmbeddedTestServer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbeddedTestServer);
 };
 
 }  // namespace test_server
 
 // TODO(svaldez): Refactor EmbeddedTestServer to be in the net namespace.
 using test_server::EmbeddedTestServer;
 
 }  // namespace net
 
 #endif  // NET_TEST_EMBEDDED_TEST_SERVER_EMBEDDED_TEST_SERVER_H_