Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/api/dial/dial_service.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 CHROME_BROWSER_EXTENSIONS_API_DIAL_DIAL_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_API_DIAL_DIAL_SERVICE_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
 #include "net/base/ip_address.h"
 #include "net/log/net_log.h"
 #include "net/udp/udp_socket.h"
 
 namespace net {
 class IPEndPoint;
@@ skipping 136 matching lines @@
     void HandleResponse(int bytes_read);
 
     // Parses a response into a DialDeviceData object. If the DIAL response is
     // invalid or does not contain enough information, then the return
     // value will be false and |device| is not changed.
     static bool ParseResponse(const std::string& response,
                               const base::Time& response_time,
                               DialDeviceData* device);
 
     // The UDP socket.
-    scoped_ptr<net::UDPSocket> socket_;
+    std::unique_ptr<net::UDPSocket> socket_;
 
     // Buffer for socket reads.
     scoped_refptr<net::IOBufferWithSize> recv_buffer_;
 
     // The source of of the last socket read.
     net::IPEndPoint recv_address_;
 
     // Thread checker.
     base::ThreadChecker thread_checker_;
 
@@ skipping 30 matching lines @@
   // |SendOneRequest()|, and start the timer to finish discovery if needed.
   // The (Address family, interface index) of each address in |ip_addresses|
   // must be unique. If |ip_address| is empty, calls |FinishDiscovery()|.
   void DiscoverOnAddresses(const net::IPAddressList& ip_addresses);
 
   // Creates a DialSocket, binds it to |bind_ip_address| and if
   // successful, add the DialSocket to |dial_sockets_|.
   void BindAndAddSocket(const net::IPAddress& bind_ip_address);
 
   // Creates a DialSocket with callbacks to this object.
-  scoped_ptr<DialSocket> CreateDialSocket();
+  std::unique_ptr<DialSocket> CreateDialSocket();
 
   // Sends a single discovery request to every socket that are currently open.
   void SendOneRequest();
 
   // Notify observers that a discovery request was made.
   void NotifyOnDiscoveryRequest();
 
   // Notify observers a device has been discovered.
   void NotifyOnDeviceDiscovered(const DialDeviceData& device_data);
 
   // Notify observers that there has been an error with one of the DialSockets.
   void NotifyOnError();
 
   // Called from finish_timer_ when we are done with the current round of
   // discovery.
   void FinishDiscovery();
 
   // Returns |true| if there are open sockets.
   bool HasOpenSockets();
 
   // DialSockets for each network interface whose ip address was
   // successfully bound.
-  std::vector<scoped_ptr<DialSocket>> dial_sockets_;
+  std::vector<std::unique_ptr<DialSocket>> dial_sockets_;
 
   // The NetLog for this service.
   net::NetLog* net_log_;
 
   // The NetLog source for this service.
   net::NetLog::Source net_log_source_;
 
   // The multicast address:port for search requests.
   net::IPEndPoint send_address_;
 
@@ skipping 36 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(DialServiceTest, TestOnDeviceDiscovered);
   FRIEND_TEST_ALL_PREFIXES(DialServiceTest, TestOnDiscoveryFinished);
   FRIEND_TEST_ALL_PREFIXES(DialServiceTest, TestOnDiscoveryRequest);
   FRIEND_TEST_ALL_PREFIXES(DialServiceTest, TestResponseParsing);
   DISALLOW_COPY_AND_ASSIGN(DialServiceImpl);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DIAL_DIAL_SERVICE_H_