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

net/socket/client_socket_pool_base.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.
 //
 // A ClientSocketPoolBase is used to restrict the number of sockets open at
 // a time.  It also maintains a list of idle persistent sockets for reuse.
 // Subclasses of ClientSocketPool should compose ClientSocketPoolBase to handle
 // the core logic of (1) restricting the number of active (connected or
 // connecting) sockets per "group" (generally speaking, the hostname), (2)
 // maintaining a per-group list of idle, persistent sockets for reuse, and (3)
 // limiting the total number of active sockets in the system.
 //
 // ClientSocketPoolBase abstracts socket connection details behind ConnectJob,
 // ConnectJobFactory, and SocketParams.  When a socket "slot" becomes available,
 // the ClientSocketPoolBase will ask the ConnectJobFactory to create a
 // ConnectJob with a SocketParams.  Subclasses of ClientSocketPool should
 // implement their socket specific connection by subclassing ConnectJob and
 // implementing ConnectJob::ConnectInternal().  They can control the parameters
 // passed to each new ConnectJob instance via their ConnectJobFactory subclass
 // and templated SocketParams parameter.
 //
 #ifndef NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_
 #define NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <cstddef>
 #include <deque>
 #include <list>
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_export.h"
 #include "net/base/network_change_notifier.h"
@@ skipping 12 matching lines @@
 // The connection may involve host resolution, tcp connection, ssl connection,
 // etc.
 class NET_EXPORT_PRIVATE ConnectJob {
  public:
   class NET_EXPORT_PRIVATE Delegate {
    public:
     Delegate() {}
     virtual ~Delegate() {}
 
     // Alerts the delegate that the connection completed. |job| must
-    // be destroyed by the delegate. A scoped_ptr<> isn't used because
+    // be destroyed by the delegate. A std::unique_ptr<> isn't used because
     // the caller of this function doesn't own |job|.
     virtual void OnConnectJobComplete(int result,
                                       ConnectJob* job) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // A |timeout_duration| of 0 corresponds to no timeout.
   ConnectJob(const std::string& group_name,
              base::TimeDelta timeout_duration,
              RequestPriority priority,
              ClientSocketPool::RespectLimits respect_limits,
              Delegate* delegate,
              const BoundNetLog& net_log);
   virtual ~ConnectJob();
 
   // Accessors
   const std::string& group_name() const { return group_name_; }
   const BoundNetLog& net_log() { return net_log_; }
 
   // Releases ownership of the underlying socket to the caller.
   // Returns the released socket, or NULL if there was a connection
   // error.
-  scoped_ptr<StreamSocket> PassSocket();
+  std::unique_ptr<StreamSocket> PassSocket();
 
   // Begins connecting the socket.  Returns OK on success, ERR_IO_PENDING if it
   // cannot complete synchronously without blocking, or another net error code
   // on error.  In asynchronous completion, the ConnectJob will notify
   // |delegate_| via OnConnectJobComplete.  In both asynchronous and synchronous
   // completion, ReleaseSocket() can be called to acquire the connected socket
   // if it succeeded.
   int Connect();
 
   virtual LoadState GetLoadState() const = 0;
 
   // If Connect returns an error (or OnConnectJobComplete reports an error
   // result) this method will be called, allowing the pool to add
   // additional error state to the ClientSocketHandle (post late-binding).
   virtual void GetAdditionalErrorState(ClientSocketHandle* handle) {}
 
   const LoadTimingInfo::ConnectTiming& connect_timing() const {
     return connect_timing_;
   }
 
   const BoundNetLog& net_log() const { return net_log_; }
 
  protected:
   RequestPriority priority() const { return priority_; }
   ClientSocketPool::RespectLimits respect_limits() const {
     return respect_limits_;
   }
-  void SetSocket(scoped_ptr<StreamSocket> socket);
+  void SetSocket(std::unique_ptr<StreamSocket> socket);
   StreamSocket* socket() { return socket_.get(); }
   void NotifyDelegateOfCompletion(int rv);
   void ResetTimer(base::TimeDelta remainingTime);
 
   // Connection establishment timing information.
   LoadTimingInfo::ConnectTiming connect_timing_;
 
  private:
   virtual int ConnectInternal() = 0;
 
   void LogConnectStart();
   void LogConnectCompletion(int net_error);
 
   // Alerts the delegate that the ConnectJob has timed out.
   void OnTimeout();
 
   const std::string group_name_;
   const base::TimeDelta timeout_duration_;
   // TODO(akalin): Support reprioritization.
   const RequestPriority priority_;
   const ClientSocketPool::RespectLimits respect_limits_;
   // Timer to abort jobs that take too long.
   base::OneShotTimer timer_;
   Delegate* delegate_;
-  scoped_ptr<StreamSocket> socket_;
+  std::unique_ptr<StreamSocket> socket_;
   BoundNetLog net_log_;
   // A ConnectJob is idle until Connect() has been called.
   bool idle_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectJob);
 };
 
 namespace internal {
 
 // ClientSocketPoolBaseHelper is an internal class that implements almost all
@@ skipping 55 matching lines @@
     Liveness liveness_ = ALIVE;
 
     DISALLOW_COPY_AND_ASSIGN(Request);
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
     virtual ~ConnectJobFactory() {}
 
-    virtual scoped_ptr<ConnectJob> NewConnectJob(
+    virtual std::unique_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const Request& request,
         ConnectJob::Delegate* delegate) const = 0;
 
     virtual base::TimeDelta ConnectionTimeout() const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
@@ skipping 14 matching lines @@
   // See LowerLayeredPool::IsStalled for documentation on this function.
   bool IsStalled() const;
 
   // See LowerLayeredPool for documentation on these functions. It is expected
   // in the destructor that no higher layer pools remain.
   void AddHigherLayeredPool(HigherLayeredPool* higher_pool);
   void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool);
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
   int RequestSocket(const std::string& group_name,
-                    scoped_ptr<const Request> request);
+                    std::unique_ptr<const Request> request);
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
   void RequestSockets(const std::string& group_name,
                       const Request& request,
                       int num_sockets);
 
   // See ClientSocketPool::CancelRequest for documentation on this function.
   void CancelRequest(const std::string& group_name,
                      ClientSocketHandle* handle);
 
   // See ClientSocketPool::ReleaseSocket for documentation on this function.
   void ReleaseSocket(const std::string& group_name,
-                     scoped_ptr<StreamSocket> socket,
+                     std::unique_ptr<StreamSocket> socket,
                      int id);
 
   // See ClientSocketPool::FlushWithError for documentation on this function.
   void FlushWithError(int error);
 
   // See ClientSocketPool::CloseIdleSockets for documentation on this function.
   void CloseIdleSockets();
 
   // See ClientSocketPool::IdleSocketCount() for documentation on this function.
   int idle_socket_count() const {
@@ skipping 45 matching lines @@
   // TODO(willchan): Consider a better algorithm for doing this.  Perhaps we
   // should keep an ordered list of idle sockets, and close them in order.
   // Requires maintaining more state.  It's not clear if it's worth it since
   // I'm not sure if we hit this situation often.
   bool CloseOneIdleSocket();
 
   // Checks higher layered pools to see if they can close an idle connection.
   bool CloseOneIdleConnectionInHigherLayeredPool();
 
   // See ClientSocketPool::GetInfoAsValue for documentation on this function.
-  scoped_ptr<base::DictionaryValue> GetInfoAsValue(
+  std::unique_ptr<base::DictionaryValue> GetInfoAsValue(
       const std::string& name,
       const std::string& type) const;
 
   base::TimeDelta ConnectionTimeout() const {
     return connect_job_factory_->ConnectionTimeout();
   }
 
   static bool connect_backup_jobs_enabled();
   static bool set_connect_backup_jobs_enabled(bool enabled);
 
@@ skipping 76 matching lines @@
     void StartBackupJobTimer(const std::string& group_name,
                              ClientSocketPoolBaseHelper* pool);
 
     bool BackupJobTimerIsRunning() const;
 
     // If there's a ConnectJob that's never been assigned to Request,
     // decrements |unassigned_job_count_| and returns true.
     // Otherwise, returns false.
     bool TryToUseUnassignedConnectJob();
 
-    void AddJob(scoped_ptr<ConnectJob> job, bool is_preconnect);
+    void AddJob(std::unique_ptr<ConnectJob> job, bool is_preconnect);
     // Remove |job| from this group, which must already own |job|.
     void RemoveJob(ConnectJob* job);
     void RemoveAllJobs();
 
     bool has_pending_requests() const {
       return !pending_requests_.empty();
     }
 
     size_t pending_request_count() const {
       return pending_requests_.size();
     }
 
     // Gets (but does not remove) the next pending request. Returns
     // NULL if there are no pending requests.
     const Request* GetNextPendingRequest() const;
 
     // Returns true if there is a connect job for |handle|.
     bool HasConnectJobForHandle(const ClientSocketHandle* handle) const;
 
     // Inserts the request into the queue based on priority
     // order. Older requests are prioritized over requests of equal
     // priority.
-    void InsertPendingRequest(scoped_ptr<const Request> request);
+    void InsertPendingRequest(std::unique_ptr<const Request> request);
 
     // Gets and removes the next pending request. Returns NULL if
     // there are no pending requests.
-    scoped_ptr<const Request> PopNextPendingRequest();
+    std::unique_ptr<const Request> PopNextPendingRequest();
 
     // Finds the pending request for |handle| and removes it. Returns
     // the removed pending request, or NULL if there was none.
-    scoped_ptr<const Request> FindAndRemovePendingRequest(
+    std::unique_ptr<const Request> FindAndRemovePendingRequest(
         ClientSocketHandle* handle);
 
     void IncrementActiveSocketCount() { active_socket_count_++; }
     void DecrementActiveSocketCount() { active_socket_count_--; }
 
     int unassigned_job_count() const { return unassigned_job_count_; }
     const std::list<ConnectJob*>& jobs() const { return jobs_; }
     const std::list<IdleSocket>& idle_sockets() const { return idle_sockets_; }
     int active_socket_count() const { return active_socket_count_; }
     std::list<IdleSocket>* mutable_idle_sockets() { return &idle_sockets_; }
 
    private:
     // Returns the iterator's pending request after removing it from
     // the queue.
-    scoped_ptr<const Request> RemovePendingRequest(
+    std::unique_ptr<const Request> RemovePendingRequest(
         const RequestQueue::Pointer& pointer);
 
     // Called when the backup socket timer fires.
     void OnBackupJobTimerFired(
         std::string group_name,
         ClientSocketPoolBaseHelper* pool);
 
     // Checks that |unassigned_job_count_| does not execeed the number of
     // ConnectJobs.
     void SanityCheck();
@@ skipping 57 matching lines @@
   // Removes |job| from |group|, which must already own |job|.
   void RemoveConnectJob(ConnectJob* job, Group* group);
 
   // Tries to see if we can handle any more requests for |group|.
   void OnAvailableSocketSlot(const std::string& group_name, Group* group);
 
   // Process a pending socket request for a group.
   void ProcessPendingRequest(const std::string& group_name, Group* group);
 
   // Assigns |socket| to |handle| and updates |group|'s counters appropriately.
-  void HandOutSocket(scoped_ptr<StreamSocket> socket,
+  void HandOutSocket(std::unique_ptr<StreamSocket> socket,
                      ClientSocketHandle::SocketReuseType reuse_type,
                      const LoadTimingInfo::ConnectTiming& connect_timing,
                      ClientSocketHandle* handle,
                      base::TimeDelta time_idle,
                      Group* group,
                      const BoundNetLog& net_log);
 
   // Adds |socket| to the list of idle sockets for |group|.
-  void AddIdleSocket(scoped_ptr<StreamSocket> socket, Group* group);
+  void AddIdleSocket(std::unique_ptr<StreamSocket> socket, Group* group);
 
   // Iterates through |group_map_|, canceling all ConnectJobs and deleting
   // groups if they are no longer needed.
   void CancelAllConnectJobs();
 
   // Iterates through |group_map_|, posting |error| callbacks for all
   // requests, and then deleting groups if they are no longer needed.
   void CancelAllRequestsWithError(int error);
 
   // Returns true if we can't create any more sockets due to the total limit.
@@ skipping 63 matching lines @@
   // The maximum number of sockets kept per group.
   const int max_sockets_per_group_;
 
   // Whether to use timer to cleanup idle sockets.
   bool use_cleanup_timer_;
 
   // The time to wait until closing idle sockets.
   const base::TimeDelta unused_idle_socket_timeout_;
   const base::TimeDelta used_idle_socket_timeout_;
 
-  const scoped_ptr<ConnectJobFactory> connect_job_factory_;
+  const std::unique_ptr<ConnectJobFactory> connect_job_factory_;
 
   // TODO(vandebo) Remove when backup jobs move to TransportClientSocketPool
   bool connect_backup_jobs_enabled_;
 
   // A unique id for the pool.  It gets incremented every time we
   // FlushWithError() the pool.  This is so that when sockets get released back
   // to the pool, we can make sure that they are discarded rather than reused.
   int pool_generation_number_;
 
   // Used to add |this| as a higher layer pool on top of lower layer pools.  May
@@ skipping 40 matching lines @@
 
    private:
     const scoped_refptr<SocketParams> params_;
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
     virtual ~ConnectJobFactory() {}
 
-    virtual scoped_ptr<ConnectJob> NewConnectJob(
+    virtual std::unique_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const Request& request,
         ConnectJob::Delegate* delegate) const = 0;
 
     virtual base::TimeDelta ConnectionTimeout() const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
@@ skipping 33 matching lines @@
 
   // RequestSocket bundles up the parameters into a Request and then forwards to
   // ClientSocketPoolBaseHelper::RequestSocket().
   int RequestSocket(const std::string& group_name,
                     const scoped_refptr<SocketParams>& params,
                     RequestPriority priority,
                     ClientSocketPool::RespectLimits respect_limits,
                     ClientSocketHandle* handle,
                     const CompletionCallback& callback,
                     const BoundNetLog& net_log) {
-    scoped_ptr<const Request> request(new Request(
+    std::unique_ptr<const Request> request(new Request(
         handle, callback, priority, respect_limits,
         internal::ClientSocketPoolBaseHelper::NORMAL, params, net_log));
     return helper_.RequestSocket(group_name, std::move(request));
   }
 
   // RequestSockets bundles up the parameters into a Request and then forwards
   // to ClientSocketPoolBaseHelper::RequestSockets().  Note that it assigns the
   // priority to IDLE and specifies the NO_IDLE_SOCKETS flag.
   void RequestSockets(const std::string& group_name,
                       const scoped_refptr<SocketParams>& params,
                       int num_sockets,
                       const BoundNetLog& net_log) {
     const Request request(nullptr /* no handle */, CompletionCallback(), IDLE,
                           ClientSocketPool::RespectLimits::ENABLED,
                           internal::ClientSocketPoolBaseHelper::NO_IDLE_SOCKETS,
                           params, net_log);
     helper_.RequestSockets(group_name, request, num_sockets);
   }
 
   void CancelRequest(const std::string& group_name,
                      ClientSocketHandle* handle) {
     return helper_.CancelRequest(group_name, handle);
   }
 
   void ReleaseSocket(const std::string& group_name,
-                     scoped_ptr<StreamSocket> socket,
+                     std::unique_ptr<StreamSocket> socket,
                      int id) {
     return helper_.ReleaseSocket(group_name, std::move(socket), id);
   }
 
   void FlushWithError(int error) { helper_.FlushWithError(error); }
 
   bool IsStalled() const { return helper_.IsStalled(); }
 
   void CloseIdleSockets() { return helper_.CloseIdleSockets(); }
 
@@ skipping 25 matching lines @@
   }
 
   bool HasGroup(const std::string& group_name) const {
     return helper_.HasGroup(group_name);
   }
 
   void CleanupIdleSockets(bool force) {
     return helper_.CleanupIdleSockets(force);
   }
 
-  scoped_ptr<base::DictionaryValue> GetInfoAsValue(const std::string& name,
-                                        const std::string& type) const {
+  std::unique_ptr<base::DictionaryValue> GetInfoAsValue(
+      const std::string& name,
+      const std::string& type) const {
     return helper_.GetInfoAsValue(name, type);
   }
 
   base::TimeDelta ConnectionTimeout() const {
     return helper_.ConnectionTimeout();
   }
 
   void EnableConnectBackupJobs() { helper_.EnableConnectBackupJobs(); }
 
   bool CloseOneIdleSocket() { return helper_.CloseOneIdleSocket(); }
@@ skipping 11 matching lines @@
   class ConnectJobFactoryAdaptor
       : public internal::ClientSocketPoolBaseHelper::ConnectJobFactory {
    public:
     typedef typename ClientSocketPoolBase<SocketParams>::ConnectJobFactory
         ConnectJobFactory;
 
     explicit ConnectJobFactoryAdaptor(ConnectJobFactory* connect_job_factory)
         : connect_job_factory_(connect_job_factory) {}
     ~ConnectJobFactoryAdaptor() override {}
 
-    scoped_ptr<ConnectJob> NewConnectJob(
+    std::unique_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const internal::ClientSocketPoolBaseHelper::Request& request,
         ConnectJob::Delegate* delegate) const override {
       const Request& casted_request = static_cast<const Request&>(request);
       return connect_job_factory_->NewConnectJob(
           group_name, casted_request, delegate);
     }
 
     base::TimeDelta ConnectionTimeout() const override {
       return connect_job_factory_->ConnectionTimeout();
     }
 
-    const scoped_ptr<ConnectJobFactory> connect_job_factory_;
+    const std::unique_ptr<ConnectJobFactory> connect_job_factory_;
   };
 
   internal::ClientSocketPoolBaseHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_