text: // 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>
  
  #include "base/callback.h"
  #include "base/macros.h"
  #include "base/memory/ref_counted.h"
  #include "media/cast/cast_config.h"
  #include "net/base/ip_endpoint.h"
  
  namespace base {
  class BinaryValue;
  class DictionaryValue;
  class SingleThreadTaskRunner;
  }  // namespace base
  
  namespace media {
  namespace cast {
  class AudioFrameInput;
  class VideoFrameInput;
  }  // namespace cast
  }  // namespace media
  
  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:
    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.
    // |enable|: If true, creates an event subscriber. Otherwise destroys
    // existing subscriber and discards logs.
    void ToggleLogging(bool is_audio, bool enable);
  
    // Returns raw event logs in serialized format for either the audio or video
    // stream since last call and returns result in |callback|. Also attaches
    // |extra_data| to the log.
    void GetEventLogsAndReset(bool is_audio,
        const std::string& extra_data, const EventLogsCallback& callback);
  
    // Returns stats in a DictionaryValue format for either the audio or video
    // stream since last call and returns result in |callback|.
    void GetStatsAndReset(bool is_audio, const StatsCallback& callback);
  
   private:
    friend class base::RefCounted<CastSession>;
    virtual ~CastSession();
  
    // This member should never be dereferenced on the main thread.
    // CastSessionDelegate lives only on the IO thread. It is always
    // safe to post task on the IO thread to access CastSessionDelegate
    // 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_
  