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

chrome/browser/media/router/receiver_presentation_service_delegate_impl.cc

Index: chrome/browser/media/router/receiver_presentation_service_delegate_impl.cc
diff --git a/chrome/browser/media/router/receiver_presentation_service_delegate_impl.cc b/chrome/browser/media/router/receiver_presentation_service_delegate_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b1fc6161f31907dd3dc1023fab7a8c90c375899b
--- /dev/null
+++ b/chrome/browser/media/router/receiver_presentation_service_delegate_impl.cc
@@ -0,0 +1,218 @@
+// 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/receiver_presentation_service_delegate_impl.h"
+
+#include "chrome/browser/media/router/offscreen_presentation_manager.h"
+#include "chrome/browser/media/router/offscreen_presentation_manager_factory.h"
+#include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/presentation_session_state_listener.h"
+
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(
+    media_router::ReceiverPresentationServiceDelegateImpl);
+
+using content::PresentationServiceDelegate;
+using content::RenderFrameHost;
+
+namespace media_router {
+
+// static
+ReceiverPresentationServiceDelegateImpl*
+ReceiverPresentationServiceDelegateImpl::GetOrCreateForWebContents(
+    content::WebContents* web_contents) {
+  DCHECK(web_contents);
+  // CreateForWebContents does nothing if the delegate instance already exists.
+  ReceiverPresentationServiceDelegateImpl::CreateForWebContents(web_contents);
+  return ReceiverPresentationServiceDelegateImpl::FromWebContents(web_contents);
+}
+
+ReceiverPresentationServiceDelegateImpl::
+    ~ReceiverPresentationServiceDelegateImpl() {
+  for (auto& observer_pair : observers_)
+    observer_pair.second->OnDelegateDestroyed();
+}
+
+void ReceiverPresentationServiceDelegateImpl::AddObserver(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationServiceDelegate::Observer* observer) {
+  DCHECK(observer);
+
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  DCHECK(!ContainsKey(observers_, rfh_id));
+  observers_[rfh_id] = observer;
+}
+
+void ReceiverPresentationServiceDelegateImpl::RemoveObserver(
+    int render_process_id,
+    int render_frame_id) {
+  observers_.erase(RenderFrameHostId(render_process_id, render_frame_id));
+}
+
+bool ReceiverPresentationServiceDelegateImpl::AddScreenAvailabilityListener(

[miu, 2015/09/27 00:22:08]

There are a ton of "NOTIMPLEMENTED()" methods.  Consider moving them into the
superclass as default implementations of the interface.

[imcheng, 2015/09/30 01:13:42]

Ack. I think it's not worth the trouble since all of them are pure virtual
methods and it's only unimplemented in this version.

+    int render_process_id,
+    int render_frame_id,
+    content::PresentationScreenAvailabilityListener* listener) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+void ReceiverPresentationServiceDelegateImpl::RemoveScreenAvailabilityListener(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationScreenAvailabilityListener* listener) {
+  NOTIMPLEMENTED();
+}
+
+void ReceiverPresentationServiceDelegateImpl::Reset(int render_process_id,
+                                                    int render_frame_id) {
+  DVLOG(2) << __FUNCTION__ << render_process_id << ", " << render_frame_id;
+
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  if (offscreen_presenter_context_ &&
+      offscreen_presenter_context_->IsPresenterFrame(rfh_id))
+    offscreen_presenter_context_.reset();
+}
+
+void ReceiverPresentationServiceDelegateImpl::SetDefaultPresentationUrl(
+    int render_process_id,
+    int render_frame_id,
+    const std::string& default_presentation_url) {
+  NOTIMPLEMENTED();
+}
+
+void ReceiverPresentationServiceDelegateImpl::StartSession(
+    int render_process_id,
+    int render_frame_id,
+    const std::string& presentation_url,
+    const PresentationSessionSuccessCallback& success_cb,
+    const PresentationSessionErrorCallback& error_cb) {
+  NOTIMPLEMENTED();
+  error_cb.Run(content::PresentationError(content::PRESENTATION_ERROR_UNKNOWN,
+                                          "Not implemented"));
+}
+
+void ReceiverPresentationServiceDelegateImpl::JoinSession(
+    int render_process_id,
+    int render_frame_id,
+    const std::string& presentation_url,
+    const std::string& presentation_id,
+    const PresentationSessionSuccessCallback& success_cb,
+    const PresentationSessionErrorCallback& error_cb) {
+  NOTIMPLEMENTED();
+  error_cb.Run(content::PresentationError(content::PRESENTATION_ERROR_UNKNOWN,
+                                          "Not implemented"));
+}
+
+void ReceiverPresentationServiceDelegateImpl::CloseSession(
+    int render_process_id,
+    int render_frame_id,
+    const std::string& presentation_id) {
+  NOTIMPLEMENTED();
+}
+
+void ReceiverPresentationServiceDelegateImpl::ListenForSessionMessages(
+    int render_process_id,
+    int render_frame_id,
+    const content::PresentationSessionInfo& session,
+    const content::PresentationSessionMessageCallback& message_cb) {
+  DVLOG(2) << __FUNCTION__ << render_process_id << ", " << render_frame_id;
+
+  if (!offscreen_presenter_context_) {
+    DVLOG(2) << __FUNCTION__ << ": no offscreen presenter context";
+    return;
+  }
+
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  offscreen_presenter_context_->ListenForMessages(rfh_id, session, message_cb);
+}
+
+void ReceiverPresentationServiceDelegateImpl::SendMessage(
+    int render_process_id,
+    int render_frame_id,
+    const content::PresentationSessionInfo& session,
+    scoped_ptr<content::PresentationSessionMessage> message,
+    const content::SendMessageCallback& send_message_cb) {
+  DVLOG(2) << __FUNCTION__ << render_process_id << ", " << render_frame_id;
+
+  if (!offscreen_presenter_context_) {
+    DVLOG(2) << __FUNCTION__ << ": no offscreen presenter context";
+    send_message_cb.Run(false);
+    return;
+  }
+
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  offscreen_presenter_context_->SendMessage(rfh_id, session, message.Pass(),
+                                            send_message_cb);
+}
+
+bool ReceiverPresentationServiceDelegateImpl::ListenForSessionStateChange(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationSessionStateListener* listener) {
+  DVLOG(2) << __FUNCTION__ << render_process_id << ", " << render_frame_id;
+
+  if (!offscreen_presenter_context_) {
+    DVLOG(2) << __FUNCTION__ << ": no offscreen presenter context";
+    return false;
+  }
+
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  offscreen_presenter_context_->ListenForStateChanges(rfh_id, listener);
+  return true;
+}
+
+void ReceiverPresentationServiceDelegateImpl::GetPresentationReceiverSession(
+    int render_process_id,
+    int render_frame_id,
+    const content::PresentationReceiverSessionAvailableCallback&
+        success_callback,
+    const base::Callback<void(const std::string&)>& error_callback) {
+  DVLOG(2) << __FUNCTION__ << render_process_id << ", " << render_frame_id;
+
+  if (!offscreen_presenter_context_) {
+    DVLOG(2) << __FUNCTION__ << ": no offscreen presenter context";
+    error_callback.Run("No offscreen presenter context");
+    return;
+  }
+
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  offscreen_presenter_context_->GetPresentationReceiverSession(
+      rfh_id, success_callback, error_callback);
+}
+
+std::vector<content::PresentationSessionInfo>
+ReceiverPresentationServiceDelegateImpl::GetPresentationReceiverSessions(
+    int render_process_id,
+    int render_frame_id) {
+  DVLOG(2) << __FUNCTION__ << render_process_id << ", " << render_frame_id;
+
+  if (!offscreen_presenter_context_) {
+    DVLOG(2) << __FUNCTION__ << ": no offscreen presenter context";
+    return std::vector<content::PresentationSessionInfo>();
+  }
+
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  return offscreen_presenter_context_->GetPresentationReceiverSessions(rfh_id);
+}
+
+ReceiverPresentationServiceDelegateImpl::
+    ReceiverPresentationServiceDelegateImpl(content::WebContents* web_contents)
+    : web_contents_(web_contents),
+      // Get the OffscreenPresentationManager keyed off the controller profile,
+      // since
+      // it is where the offscreen presentation is registered.
+      // Per OffscreenPresentationsOwner, the controller profile is the
+      // presenter
+      // tab's original profile.
+      offscreen_presenter_context_(
+          OffscreenPresentationManagerFactory::GetOrCreateForBrowserContext(
+              Profile::FromBrowserContext(web_contents_->GetBrowserContext())
+                  ->GetOriginalProfile())
+              ->GetOffscreenPresenterContext(web_contents_)) {
+  DCHECK(web_contents_);
+  DCHECK(offscreen_presenter_context_);
+}
+
+}  // namespace media_router