Cast audio only policy enforcement support.

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 <queue>
 #include <string>
 
@@ skipping 24 matching lines @@
 }
 
 namespace extensions {
 namespace core_api {
 namespace cast_channel {
 class CastMessage;
 class Logger;
 struct LastErrors;
 class MessageFramer;
 
+// Cast device capabilities.
+enum CastDeviceCapability {
+  NONE = 0,
+  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 ApiResource {
  public:
   explicit CastSocket(const std::string& owner_extension_id);
   ~CastSocket() override {}
 
   // Used by BrowserContextKeyedAPIFactory.
   static const char* service_name() { return "CastSocketImplManager"; }
 
   // Connects the channel to the peer. If successful, the channel will be in
@@ skipping 63 matching lines @@
   // |channel_auth|: Authentication method used for connecting to a Cast
   //                 receiver.
   // |net_log|: Log of socket events.
   // |connect_timeout|: Connection timeout interval.
   // |logger|: Log of cast channel events.
   CastSocketImpl(const std::string& owner_extension_id,
                  const net::IPEndPoint& ip_endpoint,
                  ChannelAuthType channel_auth,
                  net::NetLog* net_log,
                  const base::TimeDelta& connect_timeout,
-                 const scoped_refptr<Logger>& logger);
+                 const scoped_refptr<Logger>& logger,
+                 long device_capabilities);
 
   // Ensures that the socket is closed.
   ~CastSocketImpl() override;
 
   // CastSocket interface.
   void Connect(scoped_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;
@@ skipping 19 matching lines @@
     void OnMessage(const CastMessage& message) override;
 
    private:
     CastSocketImpl* socket_;
   };
 
   // Replaces the internally-constructed transport object with one provided
   // by the caller (e.g. a mock).
   void SetTransportForTesting(scoped_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);
+
   // Delegate for receiving handshake messages/errors.
   AuthTransportDelegate auth_delegate_;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestConnectAuthMessageCorrupted);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest,
                            TestConnectChallengeReplyReceiveError);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest,
                            TestConnectChallengeVerificationFails);
   friend class AuthTransportDelegate;
@@ skipping 109 matching lines @@
   // 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_;
 
   // Set when a timeout is triggered and the connection process has
   // canceled.
   bool is_canceled_;
 
+  // Capabilities declared by the cast device.
+  long device_capabilities_;
+
   // Connection flow state machine state.
   proto::ConnectionState connect_state_;
 
   // Write flow state machine state.
   proto::WriteState write_state_;
 
   // Read flow state machine state.
   proto::ReadState read_state_;
 
   // The last error encountered by the channel.
@@ skipping 16 matching lines @@
   // Caller's message read and error handling delegate.
   scoped_ptr<CastTransport::Delegate> read_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(CastSocketImpl);
 };
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_