[cast_channel] Implement CastSocketService::OpenSocket()

components/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 COMPONENTS_CAST_CHANNEL_CAST_SOCKET_H_
 #define COMPONENTS_CAST_CHANNEL_CAST_SOCKET_H_
 
 #include <stdint.h>
 
 #include <queue>
@@ skipping 38 matching lines @@
   VIDEO_OUT = 1 << 0,
   VIDEO_IN = 1 << 1,
   AUDIO_OUT = 1 << 2,
   AUDIO_IN = 1 << 3,
   DEV_MODE = 1 << 4
 };
 
 // Public interface of the CastSocket class.
 class CastSocket {
  public:
+  using OnOpenCallback =
+      base::Callback<void(int channel_id, ChannelError error_state)>;
+
   class Observer {
    public:
     virtual ~Observer() {}
 
     // Invoked when an error occurs on |socket|.
     virtual void OnError(const CastSocket& socket,
                          cast_channel::ChannelError error_state) = 0;
 
     // Invoked when |socket| receives a message.
     virtual void OnMessage(const CastSocket& socket,
                            const cast_channel::CastMessage& message) = 0;
   };
 
   virtual ~CastSocket() {}
 
   // 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.
   // If the CastSocket is destroyed while the connection is pending, |callback|
   // will be invoked with CHANNEL_ERROR_UNKNOWN. In this case, invoking
   // |callback| must not result in any re-entrancy behavior.
   // Ownership of |delegate| is transferred to this CastSocket.
-  virtual void Connect(base::Callback<void(ChannelError)> callback) = 0;
+  virtual void Connect(const OnOpenCallback& 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 65 matching lines @@
                  base::TimeDelta liveness_timeout,
                  base::TimeDelta ping_interval,
                  const scoped_refptr<Logger>& logger,
                  uint64_t device_capabilities,
                  const AuthContext& auth_context);
 
   // Ensures that the socket is closed.
   ~CastSocketImpl() override;
 
   // CastSocket interface.
-  void Connect(base::Callback<void(ChannelError)> callback) override;
+  void Connect(const OnOpenCallback& 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;
   ReadyState ready_state() const override;
   ChannelError error_state() const override;
   bool keep_alive() const override;
   bool audio_only() const override;
   void AddObserver(Observer* observer) override;
@@ skipping 40 matching lines @@
 
   // Replaces the internally-constructed transport object with one provided
   // by the caller (e.g. a mock).
   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);
 
+  void Connect();
+
  private:
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestConnectAuthMessageCorrupted);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest,
                            TestConnectChallengeReplyReceiveError);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest,
                            TestConnectChallengeVerificationFails);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestObservers);
   friend class AuthTransportDelegate;
   friend class CastSocketMessageDelegate;
   friend class CastSocketTest;
@@ skipping 106 matching lines @@
   // Certificate of the peer. This field may be empty if the peer
   // certificate is not yet fetched.
   scoped_refptr<net::X509Certificate> peer_cert_;
 
   // The challenge context for the current connection.
   const AuthContext auth_context_;
 
   // Reply received from the receiver to a challenge request.
   std::unique_ptr<CastMessage> challenge_reply_;
 
   // Callback invoked when the socket is connected or fails to connect.

[mark a. foltz, 2017/06/21 17:41:42]

nit: Callbacks

[zhaobin, 2017/06/21 21:58:25]

Done.

-  base::Callback<void(ChannelError)> connect_callback_;
+  std::vector<OnOpenCallback> connect_callbacks_;
 
   // 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.
   std::unique_ptr<base::Timer> connect_timeout_timer_;
 
@@ skipping 43 matching lines @@
   // Map of CastSocket::Observer keyed by observer id. For extension side
   // observers, id is extension_id; For browser side observers, id is a hard
   // coded string.
   base::ObserverList<Observer> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(CastSocketImpl);
 };
 }  // namespace cast_channel
 
 #endif  // COMPONENTS_CAST_CHANNEL_CAST_SOCKET_H_