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

extensions/browser/api/cast_channel/cast_socket.h

 // Copyright 2014 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 EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_
 #define EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_
 
 #include <stdint.h>
 
 #include <queue>
@@ skipping 54 matching lines @@
   // Used by BrowserContextKeyedAPIFactory.
   static const char* service_name() { return "CastSocketImplManager"; }
 
   // Connects the channel to the peer. If successful, the channel will be in
   // READY_STATE_OPEN.  DO NOT delete the CastSocket object in |callback|.
   // Instead use Close().
   // |callback| will be invoked with any ChannelError that occurred, or
   // CHANNEL_ERROR_NONE if successful.
   // |delegate| receives message receipt and error events.
   // Ownership of |delegate| is transferred to this CastSocket.
-  virtual void Connect(scoped_ptr<CastTransport::Delegate> delegate,
+  virtual void Connect(std::unique_ptr<CastTransport::Delegate> delegate,
                        base::Callback<void(ChannelError)> callback) = 0;
 
   // Closes the channel if not already closed. On completion, the channel will
   // be in READY_STATE_CLOSED.
   //
   // It is fine to delete this object in |callback|.
   virtual void Close(const net::CompletionCallback& callback) = 0;
 
   // The IP endpoint for the destination of the channel.
   virtual const net::IPEndPoint& ip_endpoint() const = 0;
@@ skipping 64 matching lines @@
                  net::NetLog* net_log,
                  const base::TimeDelta& connect_timeout,
                  bool keep_alive,
                  const scoped_refptr<Logger>& logger,
                  uint64_t device_capabilities);
 
   // Ensures that the socket is closed.
   ~CastSocketImpl() override;
 
   // CastSocket interface.
-  void Connect(scoped_ptr<CastTransport::Delegate> delegate,
+  void Connect(std::unique_ptr<CastTransport::Delegate> delegate,
                base::Callback<void(ChannelError)> callback) override;
   CastTransport* transport() const override;
   void Close(const net::CompletionCallback& callback) override;
   const net::IPEndPoint& ip_endpoint() const override;
   int id() const override;
   void set_id(int channel_id) override;
   ChannelAuthType channel_auth() const override;
   ReadyState ready_state() const override;
   ChannelError error_state() const override;
   bool keep_alive() const override;
@@ skipping 21 matching lines @@
     void Start() override;
 
    private:
     CastSocketImpl* socket_;
     ChannelError error_state_;
     LastErrors last_errors_;
   };
 
   // Replaces the internally-constructed transport object with one provided
   // by the caller (e.g. a mock).
-  void SetTransportForTesting(scoped_ptr<CastTransport> transport);
+  void SetTransportForTesting(std::unique_ptr<CastTransport> transport);
 
   // Verifies whether the socket complies with cast channel policy.
   // Audio only channel policy mandates that a device declaring a video out
   // capability must not have a certificate with audio only policy.
   bool VerifyChannelPolicy(const AuthResult& result);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestConnectAuthMessageCorrupted);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest,
                            TestConnectChallengeReplyReceiveError);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest,
                            TestConnectChallengeVerificationFails);
   friend class AuthTransportDelegate;
   friend class ApiResourceManager<CastSocketImpl>;
   friend class CastSocketTest;
   friend class TestCastSocket;
 
   void SetErrorState(ChannelError error_state) override;
 
   // Frees resources and cancels pending callbacks.  |ready_state_| will be set
   // READY_STATE_CLOSED on completion.  A no-op if |ready_state_| is already
   // READY_STATE_CLOSED.
   void CloseInternal();
 
   // Creates an instance of TCPClientSocket.
-  virtual scoped_ptr<net::TCPClientSocket> CreateTcpSocket();
+  virtual std::unique_ptr<net::TCPClientSocket> CreateTcpSocket();
   // Creates an instance of SSLClientSocket with the given underlying |socket|.
-  virtual scoped_ptr<net::SSLClientSocket> CreateSslSocket(
-      scoped_ptr<net::StreamSocket> socket);
+  virtual std::unique_ptr<net::SSLClientSocket> CreateSslSocket(
+      std::unique_ptr<net::StreamSocket> socket);
   // Extracts peer certificate from SSLClientSocket instance when the socket
   // is in cert error state.
   // Returns null if the certificate could not be extracted.
   // TODO(kmarshall): Use MockSSLClientSocket for tests instead of overriding
   // this function.
   virtual scoped_refptr<net::X509Certificate> ExtractPeerCert();
   // Verifies whether the challenge reply received from the peer is valid:
   // 1. Signature in the reply is valid.
   // 2. Certificate is rooted to a trusted CA.
   virtual bool VerifyChallengeReply();
@@ skipping 55 matching lines @@
   net::NetLog::Source net_log_source_;
   // True when keep-alive signaling should be handled for this socket.
   bool keep_alive_;
 
   // Shared logging object, used to log CastSocket events for diagnostics.
   scoped_refptr<Logger> logger_;
 
   // CertVerifier is owned by us but should be deleted AFTER SSLClientSocket
   // since in some cases the destructor of SSLClientSocket may call a method
   // to cancel a cert verification request.
-  scoped_ptr<net::CertVerifier> cert_verifier_;
-  scoped_ptr<net::TransportSecurityState> transport_security_state_;
+  std::unique_ptr<net::CertVerifier> cert_verifier_;
+  std::unique_ptr<net::TransportSecurityState> transport_security_state_;
 
   // Owned ptr to the underlying TCP socket.
-  scoped_ptr<net::TCPClientSocket> tcp_socket_;
+  std::unique_ptr<net::TCPClientSocket> tcp_socket_;
 
   // Owned ptr to the underlying SSL socket.
-  scoped_ptr<net::SSLClientSocket> socket_;
+  std::unique_ptr<net::SSLClientSocket> socket_;
 
   // Certificate of the peer. This field may be empty if the peer
   // certificate is not yet fetched.
   scoped_refptr<net::X509Certificate> peer_cert_;
 
   // Reply received from the receiver to a challenge request.
-  scoped_ptr<CastMessage> challenge_reply_;
+  std::unique_ptr<CastMessage> challenge_reply_;
 
   // Callback invoked when the socket is connected or fails to connect.
   base::Callback<void(ChannelError)> connect_callback_;
 
   // Callback invoked by |connect_timeout_timer_| to cancel the connection.
   base::CancelableClosure connect_timeout_callback_;
 
   // Duration to wait before timing out.
   base::TimeDelta connect_timeout_;
 
   // Timer invoked when the connection has timed out.
-  scoped_ptr<base::Timer> connect_timeout_timer_;
+  std::unique_ptr<base::Timer> connect_timeout_timer_;
 
   // Set when a timeout is triggered and the connection process has
   // canceled.
   bool is_canceled_;
 
   // Capabilities declared by the cast device.
   uint64_t device_capabilities_;
 
   // Whether the channel is audio only as identified by the device
   // certificate during channel authentication.
@@ skipping 16 matching lines @@
 
   // Task invoked to (re)start the connect loop.  Canceled on entry to the
   // connect loop.
   base::CancelableClosure connect_loop_callback_;
 
   // Task invoked to send the auth challenge.  Canceled when the auth challenge
   // has been sent.
   base::CancelableClosure send_auth_challenge_callback_;
 
   // Cast message formatting and parsing layer.
-  scoped_ptr<CastTransport> transport_;
+  std::unique_ptr<CastTransport> transport_;
 
   // Caller's message read and error handling delegate.
-  scoped_ptr<CastTransport::Delegate> delegate_;
+  std::unique_ptr<CastTransport::Delegate> delegate_;
 
   // Raw pointer to the auth handshake delegate. Used to get detailed error
   // information.
   AuthTransportDelegate* auth_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(CastSocketImpl);
 };
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_