Media Remoting: Add remoting control logic for encrypted contents.

media/remoting/remoting_source_impl.h

Index: media/remoting/remoting_source_impl.h
diff --git a/media/remoting/remoting_source_impl.h b/media/remoting/remoting_source_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..87dc887b8567b2cc6430db1b40f44a62b654e431
--- /dev/null
+++ b/media/remoting/remoting_source_impl.h
@@ -0,0 +1,115 @@
+// 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/threading/thread_checker.h"
+#include "media/mojo/interfaces/remoting.mojom.h"
+#include "mojo/public/cpp/bindings/binding.h"
+
+namespace media {
+
+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,

[xhwang, 2016/11/01 08:21:29]

if "starting a remoting session" failed, what state will we end up with?

[xjz, 2016/11/01 21:55:54]

It could be either SESSION_UNAVAILABLE, or SESSION_PERMANENTLY_STOPPED.

+  // Remoting session is successively started.
+  SESSION_STARTED,
+  // Stopping the session.
+  SESSION_STOPPING,

[xhwang, 2016/11/01 08:21:30]

Can we get back to STARTED after STOPPING?

More generally, can you describe a state machine about possible transitions?

[xjz, 2016/11/01 21:55:53]

Done.

+  // 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_;
+  }
+
+  // RemotingSource implementations.
+  void OnSinkAvailable() 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;
+
+  // 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_|.
+  // Remoting session will be stopped if all clients are gone.
+  void AddClient(Client* client);

[xhwang, 2016/11/01 08:21:29]

It's odd that a Client can be added here, but is also specified in
StartRemoting() and StopRemoting(). It's more confusing that for
StartRemoting(), only |client| will be notified, even though all clients
implemented OnStarted(). Then for StopRemoting(), actually all clients will get
notified.

Does it make sense to simply this so that we only add client through
AddClient(), then for StartRemoting() and StopRemoting(), all clients will get
notified? If this doesn't work, you can add a callback for StartRemoting():

StartRemoting(const OnStartedCB& cb);
Stopremoting();
AddClient(Client* client);
// Remove OnStarted() from the Client interface.

[xhwang, 2016/11/01 08:21:29]

Who owns the |client|? Maybe worth commenting that clients are supposed to call
RemoveClient() before it's gone.

[xjz, 2016/11/01 21:55:53]

This class doesn't own the clients. Added comment.

[xjz, 2016/11/01 21:55:53]

Clients can only be added/removed through the Add/RemoveClient() functions.
StartRemoting() or StopRemoting() will not add/remove client. The parameter
|client| is just the client that requires to start/stop remoting. e.g., If one
client call StartRemoting() and the remoting is already started (might by
another client), that client will simply get notified by calling
OnStarted(true). Other clients will not get notified in this case.

[xhwang, 2016/11/02 06:47:05]

This is not documented (and is a bit confusing)...

Also, at least in the StopRemoting() case, |client| isn't used at all...

[xjz, 2016/11/02 17:38:11]

Added comments. In StopRemoting() case, |client| is used to confirm that it is a
valid client that requires stopping remoting.

+  void RemoveClient(Client* client);
+
+ 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);
+
+  const mojo::Binding<mojom::RemotingSource> binding_;
+  const mojom::RemoterPtr remoter_;
+
+  // The current state.
+  RemotingSessionState state_ = RemotingSessionState::SESSION_UNAVAILABLE;
+
+  // Clients are added/removed to/from this list by calling Add/RemoveClient().
+  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_