Convert //components/[a-e]* from scoped_ptr to std::unique_ptr

components/devtools_http_handler/devtools_http_handler.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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <utility>
 
@@ skipping 65 matching lines @@
 // added back pressure on the TraceComplete message protocol - crbug.com/456845.
 const int32_t kSendBufferSizeForDevTools = 256 * 1024 * 1024;  // 256Mb
 
 }  // namespace
 
 // ServerWrapper -------------------------------------------------------------
 // All methods in this class are only called on handler thread.
 class ServerWrapper : net::HttpServer::Delegate {
  public:
   ServerWrapper(base::WeakPtr<DevToolsHttpHandler> handler,
-                scoped_ptr<net::ServerSocket> socket,
+                std::unique_ptr<net::ServerSocket> socket,
                 const base::FilePath& frontend_dir,
                 bool bundles_resources);
 
   int GetLocalAddress(net::IPEndPoint* address);
 
   void AcceptWebSocket(int connection_id,
                        const net::HttpServerRequestInfo& request);
   void SendOverWebSocket(int connection_id, const std::string& message);
   void SendResponse(int connection_id,
                     const net::HttpServerResponseInfo& response);
@@ skipping 13 matching lines @@
   void OnConnect(int connection_id) override {}
   void OnHttpRequest(int connection_id,
                      const net::HttpServerRequestInfo& info) override;
   void OnWebSocketRequest(int connection_id,
                           const net::HttpServerRequestInfo& info) override;
   void OnWebSocketMessage(int connection_id,
                           const std::string& data) override;
   void OnClose(int connection_id) override;
 
   base::WeakPtr<DevToolsHttpHandler> handler_;
-  scoped_ptr<net::HttpServer> server_;
+  std::unique_ptr<net::HttpServer> server_;
   base::FilePath frontend_dir_;
   bool bundles_resources_;
 };
 
 ServerWrapper::ServerWrapper(base::WeakPtr<DevToolsHttpHandler> handler,
-                             scoped_ptr<net::ServerSocket> socket,
+                             std::unique_ptr<net::ServerSocket> socket,
                              const base::FilePath& frontend_dir,
                              bool bundles_resources)
     : handler_(handler),
       server_(new net::HttpServer(std::move(socket), this)),
       frontend_dir_(frontend_dir),
       bundles_resources_(bundles_resources) {}
 
 int ServerWrapper::GetLocalAddress(net::IPEndPoint* address) {
   return server_->GetLocalAddress(address);
 }
@@ skipping 45 matching lines @@
   }
   if (socket_factory) {
     DCHECK(thread);
     thread->message_loop()->DeleteSoon(FROM_HERE, socket_factory);
   }
   if (thread) {
     BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE, thread);
   }
 }
 
-void ServerStartedOnUI(
-    base::WeakPtr<DevToolsHttpHandler> handler,
-    base::Thread* thread,
-    ServerWrapper* server_wrapper,
-    DevToolsHttpHandler::ServerSocketFactory* socket_factory,
-    scoped_ptr<net::IPEndPoint> ip_address) {
+void ServerStartedOnUI(base::WeakPtr<DevToolsHttpHandler> handler,
+                       base::Thread* thread,
+                       ServerWrapper* server_wrapper,
+                       DevToolsHttpHandler::ServerSocketFactory* socket_factory,
+                       std::unique_ptr<net::IPEndPoint> ip_address) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (handler && thread && server_wrapper) {
     handler->ServerStarted(thread, server_wrapper, socket_factory,
                            std::move(ip_address));
   } else {
     TerminateOnUI(thread, server_wrapper, socket_factory);
   }
 }
 
 void StartServerOnHandlerThread(
     base::WeakPtr<DevToolsHttpHandler> handler,
     base::Thread* thread,
     DevToolsHttpHandler::ServerSocketFactory* server_socket_factory,
     const base::FilePath& output_directory,
     const base::FilePath& frontend_dir,
     bool bundles_resources) {
   DCHECK_EQ(thread->message_loop(), base::MessageLoop::current());
   ServerWrapper* server_wrapper = nullptr;
-  scoped_ptr<net::ServerSocket> server_socket =
+  std::unique_ptr<net::ServerSocket> server_socket =
       server_socket_factory->CreateForHttpServer();
-  scoped_ptr<net::IPEndPoint> ip_address(new net::IPEndPoint);
+  std::unique_ptr<net::IPEndPoint> ip_address(new net::IPEndPoint);
   if (server_socket) {
     server_wrapper = new ServerWrapper(handler, std::move(server_socket),
                                        frontend_dir, bundles_resources);
     if (!output_directory.empty())
       server_wrapper->WriteActivePortToUserProfile(output_directory);
 
     if (server_wrapper->GetLocalAddress(ip_address.get()) != net::OK)
       ip_address.reset();
   } else {
     ip_address.reset();
     LOG(ERROR) << "Cannot start http server for devtools. Stop devtools.";
   }
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&ServerStartedOnUI,
                  handler,
                  thread,
                  server_wrapper,
                  server_socket_factory,
                  base::Passed(&ip_address)));
 }
 
 void StartServerOnFile(
     base::WeakPtr<DevToolsHttpHandler> handler,
     DevToolsHttpHandler::ServerSocketFactory* server_socket_factory,
     const base::FilePath& output_directory,
     const base::FilePath& frontend_dir,
     bool bundles_resources) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-  scoped_ptr<base::Thread> thread(new base::Thread(kDevToolsHandlerThreadName));
+  std::unique_ptr<base::Thread> thread(
+      new base::Thread(kDevToolsHandlerThreadName));
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   if (thread->StartWithOptions(options)) {
     base::MessageLoop* message_loop = thread->message_loop();
     message_loop->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&StartServerOnHandlerThread, handler,
                    base::Unretained(thread.release()), server_socket_factory,
                    output_directory, frontend_dir, bundles_resources));
   }
@@ skipping 64 matching lines @@
   scoped_refptr<DevToolsAgentHost> agent_host_;
 };
 
 static bool TimeComparator(const DevToolsTargetDescriptor* desc1,
                            const DevToolsTargetDescriptor* desc2) {
   return desc1->GetLastActivityTime() > desc2->GetLastActivityTime();
 }
 
 // DevToolsHttpHandler::ServerSocketFactory ----------------------------------
 
-scoped_ptr<net::ServerSocket>
+std::unique_ptr<net::ServerSocket>
 DevToolsHttpHandler::ServerSocketFactory::CreateForHttpServer() {
-  return scoped_ptr<net::ServerSocket>();
+  return std::unique_ptr<net::ServerSocket>();

[danakj, 2016/04/26 01:27:53]

nullptr

[dcheng, 2016/04/26 01:35:02]

Done.

 }
 
-scoped_ptr<net::ServerSocket>
+std::unique_ptr<net::ServerSocket>
 DevToolsHttpHandler::ServerSocketFactory::CreateForTethering(
     std::string* name) {
-  return scoped_ptr<net::ServerSocket>();
+  return nullptr;
 }
 
 // DevToolsHttpHandler -------------------------------------------------------
 
 DevToolsHttpHandler::~DevToolsHttpHandler() {
   TerminateOnUI(thread_, server_wrapper_, socket_factory_);
   STLDeleteValues(&descriptor_map_);
   STLDeleteValues(&connection_to_client_);
 }
 
@@ skipping 238 matching lines @@
     SendJson(connection_id, net::HTTP_OK, &list_value, std::string());
     return;
   }
 
   if (command == "new") {
     GURL url(net::UnescapeURLComponent(
         query, net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS |
                    net::UnescapeRule::PATH_SEPARATORS));
     if (!url.is_valid())
       url = GURL(url::kAboutBlankURL);
-    scoped_ptr<DevToolsTargetDescriptor> descriptor =
-        devtools_discovery::DevToolsDiscoveryManager::GetInstance()->
-            CreateNew(url);
+    std::unique_ptr<DevToolsTargetDescriptor> descriptor =
+        devtools_discovery::DevToolsDiscoveryManager::GetInstance()->CreateNew(
+            url);
     if (!descriptor) {
       SendJson(connection_id,
                net::HTTP_INTERNAL_SERVER_ERROR,
                NULL,
                "Could not create new page");
       return;
     }
     std::string host = info.headers["host"];
-    scoped_ptr<base::DictionaryValue> dictionary(
+    std::unique_ptr<base::DictionaryValue> dictionary(
         SerializeDescriptor(*descriptor.get(), host));
     SendJson(connection_id, net::HTTP_OK, dictionary.get(), std::string());
     const std::string target_id = descriptor->GetId();
     descriptor_map_[target_id] = descriptor.release();
     return;
   }
 
   if (command == "activate" || command == "close") {
     DevToolsTargetDescriptor* descriptor = GetDescriptor(target_id);
     if (!descriptor) {
@@ skipping 140 matching lines @@
 void DevToolsHttpHandler::OnClose(int connection_id) {
   ConnectionToClientMap::iterator it =
       connection_to_client_.find(connection_id);
   if (it != connection_to_client_.end()) {
     delete it->second;
     connection_to_client_.erase(connection_id);
   }
 }
 
 DevToolsHttpHandler::DevToolsHttpHandler(
-    scoped_ptr<ServerSocketFactory> server_socket_factory,
+    std::unique_ptr<ServerSocketFactory> server_socket_factory,
     const std::string& frontend_url,
     DevToolsHttpHandlerDelegate* delegate,
     const base::FilePath& output_directory,
     const base::FilePath& debug_frontend_dir,
     const std::string& product_name,
     const std::string& user_agent)
     : thread_(nullptr),
       frontend_url_(frontend_url),
       product_name_(product_name),
       user_agent_(user_agent),
@@ skipping 12 matching lines @@
                  server_socket_factory.release(),
                  output_directory,
                  debug_frontend_dir,
                  bundles_resources));
 }
 
 void DevToolsHttpHandler::ServerStarted(
     base::Thread* thread,
     ServerWrapper* server_wrapper,
     ServerSocketFactory* socket_factory,
-    scoped_ptr<net::IPEndPoint> ip_address) {
+    std::unique_ptr<net::IPEndPoint> ip_address) {
   thread_ = thread;
   server_wrapper_ = server_wrapper;
   socket_factory_ = socket_factory;
   server_ip_address_.swap(ip_address);
 }
 
 void ServerWrapper::WriteActivePortToUserProfile(
     const base::FilePath& output_directory) {
   DCHECK(!output_directory.empty());
   net::IPEndPoint endpoint;
@@ skipping 115 matching lines @@
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace devtools_http_handler