[cast_channel] Make CastMessageHandler a CastSocket::Observer instead of CastTransport::Delegate

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>
 #include <string>
 
 #include "base/cancelable_callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
 #include "components/cast_channel/cast_auth_util.h"
 #include "components/cast_channel/cast_channel_enum.h"
 #include "components/cast_channel/cast_socket.h"
 #include "components/cast_channel/cast_transport.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/log/net_log_source.h"
@@ skipping 21 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:
+  class Observer {
+   public:
+    virtual ~Observer() {}
+
+    // Invoked when an error occurs on |socket|.
+    virtual void OnError(const CastSocket& socket,
+                         ChannelError error_state) = 0;
+
+    // Invoked when |socket| receives a message.
+    virtual void OnMessage(const CastSocket& socket,
+                           const 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.
-  // |delegate| receives message receipt and error events.
-  // Ownership of |delegate| is transferred to this CastSocket.
-  virtual void Connect(std::unique_ptr<CastTransport::Delegate> delegate,
-                       base::Callback<void(ChannelError)> callback) = 0;
+  virtual void Connect(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 20 matching lines @@
   // Marks a socket as invalid due to an error, and sends an OnError
   // event to |delegate_|.
   // The OnError event receipient is responsible for closing the socket in the
   // event of an error.
   // Setting the error state does not close the socket if it is open.
   virtual void SetErrorState(ChannelError error_state) = 0;
 
   // Returns a pointer to the socket's message transport layer. Can be used to
   // send and receive CastMessages over the socket.
   virtual CastTransport* transport() const = 0;
+
+  // Registers |observer| with the socket to receive messages and error events.
+  virtual void AddObserver(Observer* observer) = 0;
 };
 
 // This class implements a channel between Chrome and a Cast device using a TCP
 // socket with SSL.  The channel may authenticate that the receiver is a genuine
 // Cast device.  All CastSocketImpl objects must be used only on the IO thread.
 //
 // NOTE: Not called "CastChannel" to reduce confusion with the generated API
 // code.
 class CastSocketImpl : public CastSocket {
  public:
@@ skipping 21 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(std::unique_ptr<CastTransport::Delegate> delegate,
-               base::Callback<void(ChannelError)> callback) override;
+  void Connect(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;
   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;
 
  protected:
   // CastTransport::Delegate methods for receiving handshake messages.
   class AuthTransportDelegate : public CastTransport::Delegate {
    public:
     explicit AuthTransportDelegate(CastSocketImpl* socket);
 
     // Gets the error state of the channel.
     // Returns CHANNEL_ERROR_NONE if no errors are present.
     ChannelError error_state() const;
 
     // Gets recorded error details.
     LastError last_error() const;
 
     // CastTransport::Delegate interface.
     void OnError(ChannelError error_state) override;
     void OnMessage(const CastMessage& message) override;
     void Start() override;
 
    private:
     CastSocketImpl* socket_;
     ChannelError error_state_;
     LastError last_error_;
   };
 
+  // CastTransport::Delegate methods to receive normal messages and errors.
+  class CastSocketMessageDelegate : public CastTransport::Delegate {
+   public:
+    CastSocketMessageDelegate(CastSocketImpl* socket);
+    ~CastSocketMessageDelegate() override;
+
+    // CastTransport::Delegate implementation.
+    void OnError(ChannelError error_state) override;
+    void OnMessage(const CastMessage& message) override;
+    void Start() override;
+
+   private:
+    CastSocketImpl* const socket_;
+    DISALLOW_COPY_AND_ASSIGN(CastSocketMessageDelegate);
+  };
+
   // 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);
 
  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;
   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();
 
@@ skipping 152 matching lines @@
   // Cast message formatting and parsing layer.
   std::unique_ptr<CastTransport> transport_;
 
   // Caller's message read and error handling delegate.
   std::unique_ptr<CastTransport::Delegate> delegate_;
 
   // Raw pointer to the auth handshake delegate. Used to get detailed error
   // information.
   AuthTransportDelegate* auth_delegate_;
 
+  // List of socket observers.
+  base::ObserverList<Observer> observers_;
+
   DISALLOW_COPY_AND_ASSIGN(CastSocketImpl);
 };
 }  // namespace cast_channel
 
 #endif  // COMPONENTS_CAST_CHANNEL_CAST_SOCKET_H_