[Presentation API] 1-UA presentation support + presenter APIs.

chrome/browser/media/router/offscreen_presentation_manager.cc

+// Copyright 2015 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.
+
+#include "chrome/browser/media/router/offscreen_presentation_manager.h"
+
+#include "content/public/browser/presentation_session_state_listener.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/web_contents.h"
+
+namespace media_router {
+
+OffscreenPresentationManager::OffscreenPresentationSession::
+    OffscreenPresentationSession(
+        bool is_controller,
+        OffscreenPresentationManager::OffscreenPresentationConnection*
+            connection)
+    : is_controller_(is_controller),
+      state_change_listener_(nullptr),
+      connection_(connection) {
+  DCHECK(connection_);
+}
+
+OffscreenPresentationManager::OffscreenPresentationSession::
+    ~OffscreenPresentationSession() {
+  connection_->RemoveSession(is_controller_);
+}
+
+void OffscreenPresentationManager::OffscreenPresentationSession::SendMessage(
+    scoped_ptr<content::PresentationSessionMessage> message,
+    const content::SendMessageCallback& callback) {
+  connection_->SendMessage(is_controller_, message.Pass(), callback);
+}
+
+void OffscreenPresentationManager::OffscreenPresentationSession::
+    ListenForMessages(
+        const content::PresentationSessionMessageCallback& callback) {
+  messages_callback_ = callback;
+}
+
+void OffscreenPresentationManager::OffscreenPresentationSession::
+    ListenForStateChanges(content::PresentationSessionStateListener* listener) {
+  state_change_listener_ = listener;
+}
+
+void OffscreenPresentationManager::OffscreenPresentationSession::
+    OnSessionStateChanged(content::PresentationSessionState state) {
+  if (state_change_listener_)
+    state_change_listener_->OnSessionStateChanged(state);
+}
+
+void OffscreenPresentationManager::OffscreenPresentationSession::
+    OnMessageReceived(scoped_ptr<content::PresentationSessionMessage> message) {

[mark a. foltz, 2015/10/01 18:39:12]

IIUC the PresentationService gets batches of messages.  Can we propagate them in
batches here?

https://code.google.com/p/chromium/codesearch#chromium/src/content/common/pre...

[imcheng, 2015/10/06 00:59:14]

Yes. I added a TODO here. I want to make sure it works on the high level before
adding more logic.

+  if (!messages_callback_.is_null()) {
+    ScopedVector<content::PresentationSessionMessage> messages;
+    messages.push_back(message.release());
+    messages_callback_.Run(messages.Pass(), true);
+  }
+}
+
+OffscreenPresentationManager::~OffscreenPresentationManager() {}
+
+void OffscreenPresentationManager::RegisterOffscreenPresentationReceiver(
+    const std::string& presentation_id,
+    const ReceiverSessionAvailableCallback& receiver_available_callback) {
+  DCHECK(!ContainsKey(offscreen_presentations_, presentation_id));

[mark a. foltz, 2015/10/01 18:39:12]

Well this will be a no-op in release builds.  Maybe DLOG(WARNING) and return
early instead?

[imcheng, 2015/10/06 00:59:13]

insert() will also be no-op if there is already an existing entry. Or, do you
mean we should log in release build?

+
+  offscreen_presentations_.insert(
+      presentation_id,
+      make_scoped_ptr(new OffscreenPresentation(
+          presentation_id, receiver_available_callback, this)));
+}
+
+void OffscreenPresentationManager::UnregisterOffscreenPresentationReceiver(
+    const std::string& presentation_id) {
+  auto it = offscreen_presentations_.find(presentation_id);
+  DCHECK(it != offscreen_presentations_.end());

[mark a. foltz, 2015/10/01 18:39:12]

Similar comment here - it would be better to DLOG and return rather than
dereference the invalid iterator below.

[imcheng, 2015/10/06 00:59:13]

We are always deleting the OffscreenPresentation here by calling
erase(presentation_id) so it's not an issue anymore.

+  it->second->OnReceiverDetached();
+}
+
+scoped_ptr<OffscreenPresentationManager::OffscreenPresentationSession>
+OffscreenPresentationManager::CreateOffscreenPresentationConnection(
+    const std::string& presentation_id,
+    const RenderFrameHostId& controller_frame_id) {
+  auto it = offscreen_presentations_.find(presentation_id);
+  if (it == offscreen_presentations_.end())
+    return scoped_ptr<
+        OffscreenPresentationManager::OffscreenPresentationSession>();
+
+  return it->second->AddConnectionAndNotifyReceiver(controller_frame_id);
+}
+
+OffscreenPresentationManager::OffscreenPresentationManager() {}
+
+void OffscreenPresentationManager::RemovePresentation(

[mark a. foltz, 2015/10/01 18:39:12]

This must only be called on presentations that are completely disconnected and
about to be torn down, right?

[imcheng, 2015/10/06 00:59:14]

This function is removed. But that is correct - I added a DCHECK in
~OffscreenPresentation to check offscreen_presentations_ is empty. Also added
contract for UnregisterOffscreenPresentationReceiver that all connections must
be destroyed before calling it.

+    const std::string& presentation_id) {
+  offscreen_presentations_.erase(presentation_id);
+}
+
+OffscreenPresentationManager::OffscreenPresentationConnection::
+    OffscreenPresentationConnection(
+        const RenderFrameHostId& controller_frame_id,
+        OffscreenPresentation* presentation)
+    : presentation_(presentation),
+      controller_frame_id_(controller_frame_id),
+      controller_(nullptr),

[mark a. foltz, 2015/10/01 18:39:12]

This class would be simpler by accepting a non-null controller_ and receiver_ in
the ctor.

[imcheng, 2015/10/06 00:59:13]

The issue is that OffscreenPresentationConnection and
OffscreenPresentationSession reference each other.  So to do that I would have
to set the Connection* separately on the sessions. Another way is to construct
the Sessions here, then call a method to get the Session*'s, then wrap them in
scoped_ptr<>s and return them to the controller and receiver. After weighing all
3 I went with what I have now.

+      receiver_(nullptr) {
+  DCHECK(presentation_);
+}
+
+void OffscreenPresentationManager::OffscreenPresentationConnection::Init(
+    OffscreenPresentationManager::OffscreenPresentationSession* controller,
+    OffscreenPresentationManager::OffscreenPresentationSession* receiver) {
+  DCHECK(!controller_);
+  DCHECK(!receiver_);
+  DCHECK(controller);
+  DCHECK(receiver);
+  controller_ = controller;
+  receiver_ = receiver;
+}
+
+OffscreenPresentationManager::OffscreenPresentationConnection::
+    ~OffscreenPresentationConnection() {
+  DCHECK(!controller_);
+  DCHECK(!receiver_);
+}
+
+void OffscreenPresentationManager::OffscreenPresentationConnection::
+    RemoveSession(bool is_controller) {
+  OffscreenPresentationManager::OffscreenPresentationSession* other_session =
+      nullptr;
+  if (is_controller) {

[mark a. foltz, 2015/10/01 18:39:12]

This would seem simpler as:

if (is_controller && controller_) {
  controller_->OnSessionStateChanged()
  return;
}

etc.

[imcheng, 2015/10/06 00:59:14]

Ack

+    DCHECK(controller_);
+    controller_ = nullptr;
+    other_session = receiver_;
+  } else {
+    DCHECK(receiver_);
+    receiver_ = nullptr;
+    other_session = controller_;
+  }
+
+  if (other_session) {
+    other_session->OnSessionStateChanged(
+        content::PRESENTATION_SESSION_STATE_DISCONNECTED);
+  } else {
+    presentation_->RemoveConnection(controller_frame_id_);
+    // |this| is deleted beyond this point.
+  }
+}
+
+void OffscreenPresentationManager::OffscreenPresentationConnection::SendMessage(
+    bool is_controller,
+    scoped_ptr<content::PresentationSessionMessage> message,
+    const content::SendMessageCallback& callback) {
+  OffscreenPresentationManager::OffscreenPresentationSession* other_session =

[mark a. foltz, 2015/10/01 18:39:12]

Help me understand - the connection will always have ptrs to the controller and
receiver but the is_controller flag controls which one will be used?

IMO adding methods like GetSession() and GetRemoteSession() would be more
readable, e.g. this becomes GetRemoteSession()->OnMessageReceived()

[imcheng, 2015/10/06 00:59:13]

Went with your other comment in the .h - SendMessageTo{Controller,Receiver},
etc.

+      is_controller ? receiver_ : controller_;
+  if (!other_session) {
+    callback.Run(false);
+    return;
+  } else {
+    other_session->OnMessageReceived(message.Pass());
+    callback.Run(true);
+  }
+}
+
+OffscreenPresentationManager::OffscreenPresentation::OffscreenPresentation(
+    const std::string& presentation_id,
+    const ReceiverSessionAvailableCallback& receiver_available_callback,
+    OffscreenPresentationManager* manager)
+    : presentation_id_(presentation_id),
+      receiver_available_callback_(receiver_available_callback),
+      manager_(manager) {
+  DCHECK(!receiver_available_callback_.is_null());
+  DCHECK(manager_);
+}
+
+OffscreenPresentationManager::OffscreenPresentation::~OffscreenPresentation() {}
+
+void OffscreenPresentationManager::OffscreenPresentation::OnReceiverDetached() {
+  receiver_available_callback_.Reset();
+  MaybeSelfDestruct();
+}
+
+scoped_ptr<OffscreenPresentationManager::OffscreenPresentationSession>
+OffscreenPresentationManager::OffscreenPresentation::
+    AddConnectionAndNotifyReceiver(
+        const RenderFrameHostId& controller_frame_id) {
+  DCHECK(!ContainsKey(connections_, controller_frame_id));
+
+  if (IsReceiverGone()) {
+    return scoped_ptr<
+        OffscreenPresentationManager::OffscreenPresentationSession>();
+  }
+
+  scoped_ptr<OffscreenPresentationConnection> connection(
+      new OffscreenPresentationManager::OffscreenPresentationConnection(
+          controller_frame_id, this));

[mark a. foltz, 2015/10/01 18:39:12]

ISTM the connection should create and own the receiver_session and
controller_session.

This would seem to avoid a lot of the null checking above as well as the need
for the Init() call below.

[imcheng, 2015/10/06 00:59:14]

Per comment above, I could new these Session objects in the Connection's ctor
(cleanest way get around the circular reference), but then I would have to get
the Sessions back as raw ptrs, wrap them in scoped_ptr<>s to return them to
controller/receiver. It just feels a bit weird to me.

+  scoped_ptr<OffscreenPresentationManager::OffscreenPresentationSession>
+      controller_session(
+          new OffscreenPresentationManager::OffscreenPresentationSession(
+              true, connection.get()));
+  scoped_ptr<OffscreenPresentationManager::OffscreenPresentationSession>
+      receiver_session(
+          new OffscreenPresentationManager::OffscreenPresentationSession(
+              false, connection.get()));
+
+  connection->Init(controller_session.get(), receiver_session.get());
+  connections_.insert(controller_frame_id, connection.Pass());
+  receiver_available_callback_.Run(receiver_session.Pass());
+  return controller_session.Pass();
+}
+
+void OffscreenPresentationManager::OffscreenPresentation::RemoveConnection(

[mark a. foltz, 2015/10/01 18:39:12]

What guarantees that the two sessions are in the disconnected state before they
are removed from the controller/presentation?

[imcheng, 2015/10/06 00:59:13]

In the new patchset, this is only called from OffscreenPresentationConnection
when one side has been removed and other has been notified of disconnection.

+    const RenderFrameHostId& controller_frame_id) {
+  DCHECK(ContainsKey(connections_, controller_frame_id));
+
+  connections_.erase(controller_frame_id);
+  MaybeSelfDestruct();
+}
+
+void OffscreenPresentationManager::OffscreenPresentation::MaybeSelfDestruct() {
+  if (IsReceiverGone() && connections_.empty())
+    manager_->RemovePresentation(presentation_id_);
+  // |this| will be deleted beyond this point.
+}
+
+}  // namespace media_router