Adding CastRemotingSender for media remoting.

chrome/renderer/media/cast_session.h

 // Copyright 2013 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 CHROME_RENDERER_MEDIA_CAST_SESSION_H_
 #define CHROME_RENDERER_MEDIA_CAST_SESSION_H_
 
 #include <memory>
 #include <vector>
 
@@ skipping 21 matching lines @@
 class P2PSocketClient;
 }  // namespace content
 
 class CastSessionDelegate;
 
 // This class represents a Cast session and allows the session to be
 // configured on the main thread. Actual work is forwarded to
 // CastSessionDelegate on the IO thread.
 class CastSession : public base::RefCounted<CastSession> {
  public:
-  typedef base::Callback<void(const scoped_refptr<
-      media::cast::AudioFrameInput>&)> AudioFrameInputAvailableCallback;
-  typedef base::Callback<void(const scoped_refptr<
-      media::cast::VideoFrameInput>&)> VideoFrameInputAvailableCallback;
-  typedef base::Callback<void(const std::vector<char>&)> SendPacketCallback;
-  typedef base::Callback<void(std::unique_ptr<base::BinaryValue>)>
-      EventLogsCallback;
-  typedef base::Callback<void(std::unique_ptr<base::DictionaryValue>)>
-      StatsCallback;
-  typedef base::Callback<void(const std::string&)> ErrorCallback;
+  using AudioFrameInputAvailableCallback =
+      base::Callback<void(const scoped_refptr<media::cast::AudioFrameInput>&)>;
+  using VideoFrameInputAvailableCallback =
+      base::Callback<void(const scoped_refptr<media::cast::VideoFrameInput>&)>;
+  using SendPacketCallback = base::Callback<void(const std::vector<char>&)>;
+  using EventLogsCallback =
+      base::Callback<void(std::unique_ptr<base::BinaryValue>)>;
+  using StatsCallback =
+      base::Callback<void(std::unique_ptr<base::DictionaryValue>)>;
+  using ErrorCallback = base::Callback<void(const std::string&)>;
 
   CastSession();
 
   // Start encoding of audio and video using the provided configuration.
   //
   // When Cast sender is started and ready to be used
   // media::cast::FrameInput will be given through |callback|.
   // If it encounters an error, |error_callback| will be invoked with the
   // error message. Both |callback| and |error_callback| will be made on
   // the main thread.
   // |StartUDP()| must be called before these methods.
   void StartAudio(const media::cast::FrameSenderConfig& config,
                   const AudioFrameInputAvailableCallback& callback,
                   const ErrorCallback& error_callback);
   void StartVideo(const media::cast::FrameSenderConfig& config,
                   const VideoFrameInputAvailableCallback& callback,
                   const ErrorCallback& error_callback);
 
+  // Start remoting a stream. |error_callback| will be invoked when any error
+  // occurs. |StartUDP()| must be called before calling this method.
+  void StartRemotingStream(int32_t stream_id,
+                           const media::cast::FrameSenderConfig& config,
+                           const ErrorCallback& error_callback);
+
   // This will create the Cast transport and connect to |remote_endpoint|.
   // |options| is a dictionary which contain optional configuration for the
   // udp transport.
   // Must be called before initialization of audio or video.
   void StartUDP(const net::IPEndPoint& remote_endpoint,
                 std::unique_ptr<base::DictionaryValue> options,
                 const ErrorCallback& error_callback);
 
   // Creates or destroys event subscriber for the audio or video stream.
   // |is_audio|: true if the event subscriber is for audio. Video otherwise.
@@ skipping 21 matching lines @@
   // because it is owned by this object.
   std::unique_ptr<CastSessionDelegate> delegate_;
 
   // Proxy to the IO task runner.
   const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(CastSession);
 };
 
 #endif  // CHROME_RENDERER_MEDIA_CAST_SESSION_H_