blob: 37ca7004e95460a1bac10577fd520a2660085429 [file] [log] [blame]
// Copyright 2016 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 MEDIA_REMOTING_REMOTING_SOURCE_IMPL_H_
#define MEDIA_REMOTING_REMOTING_SOURCE_IMPL_H_
#include <vector>
#include "base/callback.h"
#include "base/memory/weak_ptr.h"
#include "base/threading/thread_checker.h"
#include "media/mojo/interfaces/remoting.mojom.h"
#include "media/remoting/rpc/rpc_broker.h"
#include "mojo/public/cpp/bindings/binding.h"
namespace media {
// State transition diagram:
//
// .--> SESSION_UNAVAILABLE
// | | ^
// | V |
// | SESSION_CAN_START
// | |
// | V
// | .---SESSION_STARTING --.
// | | | |
// | | V |
// | | SESSION_STARTED----|
// | | | |
// | | V |
// | '-> SESSION_STOPPING |
// '-----' | |
// V V
// SESSION_PERMANENTLY_STOPPED
enum RemotingSessionState {
// Remoting sink is not available. Can't start remoting.
SESSION_UNAVAILABLE,
// Remoting sink is available, Can start remoting.
SESSION_CAN_START,
// Starting a remoting session.
SESSION_STARTING,
// Remoting session is successively started.
SESSION_STARTED,
// Stopping the session.
SESSION_STOPPING,
// Remoting session is permanently stopped. This state indicates that the
// video stack cannot continue operation. For example, if a remoting session
// involving CDM content was stopped, there is no way to continue playback
// because the CDM is required but is no longer available.
SESSION_PERMANENTLY_STOPPED,
};
// Maintains a single remoting session for multiple clients. The session will
// start remoting when receiving the first request. Once remoting is started,
// it will be stopped when any of the following happens:
// 1) Receives the request from any client to stop remoting.
// 2) Remote sink is gone.
// 3) Any client requests to permanently terminate the session.
// 4) All clients are destroyed.
//
// This class is ref-counted because, in some cases, an instance will have
// shared ownership between RemotingRendererController and
// RemotingCdmController.
class RemotingSourceImpl final
: public mojom::RemotingSource,
public base::RefCountedThreadSafe<RemotingSourceImpl> {
public:
class Client {
public:
// Get notified whether the remoting session is successively started.
virtual void OnStarted(bool success) = 0;
// Get notified when session state changes.
virtual void OnSessionStateChanged() = 0;
};
RemotingSourceImpl(mojom::RemotingSourceRequest source_request,
mojom::RemoterPtr remoter);
// Get the current session state.
RemotingSessionState state() const {
DCHECK(thread_checker_.CalledOnValidThread());
return state_;
}
mojom::RemotingSinkCapabilities sink_capabilities() const {
return sink_capabilities_;
}
bool is_remote_decryption_available() const {
return sink_capabilities_ ==
mojom::RemotingSinkCapabilities::CONTENT_DECRYPTION_AND_RENDERING;
}
// RemotingSource implementations.
void OnSinkAvailable(mojom::RemotingSinkCapabilities capabilities) override;
void OnSinkGone() override;
void OnStarted() override;
void OnStartFailed(mojom::RemotingStartFailReason reason) override;
void OnMessageFromSink(const std::vector<uint8_t>& message) override;
void OnStopped(mojom::RemotingStopReason reason) override;
using DataPipeStartCallback =
base::Callback<void(mojom::RemotingDataStreamSenderPtrInfo audio,
mojom::RemotingDataStreamSenderPtrInfo video,
mojo::ScopedDataPipeProducerHandle audio_handle,
mojo::ScopedDataPipeProducerHandle video_handle)>;
void StartDataPipe(std::unique_ptr<mojo::DataPipe> audio_data_pipe,
std::unique_ptr<mojo::DataPipe> video_data_pipe,
const DataPipeStartCallback& done_callback);
// Requests to start remoting. Will try start a remoting session if not
// started yet. |client| will get informed whether the session is
// successifully started throught OnStarted().
void StartRemoting(Client* client);
// Requests to stop the current remoting session if started. When the session
// is stopping, all clients will get notified.
void StopRemoting(Client* client);
// Permanently terminates the current remoting session.
void Shutdown();
// Add/remove a client to/from |clients_|.
// Note: Clients can only added/removed through these methods.
// Remoting session will be stopped if all clients are gone.
void AddClient(Client* client);
void RemoveClient(Client* client);
remoting::RpcBroker* GetRpcBroker() const;
private:
friend class base::RefCountedThreadSafe<RemotingSourceImpl>;
~RemotingSourceImpl() override;
// Updates the current session state and notifies all the clients if state
// changes.
void UpdateAndNotifyState(RemotingSessionState state);
// Callback from RpcBroker when sending message to remote sink.
void SendMessageToSink(std::unique_ptr<std::vector<uint8_t>> message);
// TODO(xjz): Might merge RpcBroker into RemotingSourceImpl.
// Handle incomging and outgoing RPC message.
remoting::RpcBroker rpc_broker_;
const mojo::Binding<mojom::RemotingSource> binding_;
const mojom::RemoterPtr remoter_;
// When the sink is available, this describes its capabilities. When not
// available, this is always NONE. Updated by OnSinkAvailable/Gone().
mojom::RemotingSinkCapabilities sink_capabilities_ =
mojom::RemotingSinkCapabilities::NONE;
// The current state.
RemotingSessionState state_ = RemotingSessionState::SESSION_UNAVAILABLE;
// Clients are added/removed to/from this list by calling Add/RemoveClient().
// All the clients are not belong to this class. They are supposed to call
// RemoveClient() before they are gone.
std::vector<Client*> clients_;
// This is used to check all the methods are called on the current thread in
// debug builds.
base::ThreadChecker thread_checker_;
};
} // namespace media
#endif // MEDIA_REMOTING_REMOTING_SOURCE_IMPL_H_