[MediaRouter] Add implementation of PresentationServiceDelegate

chrome/browser/media/router/presentation_service_delegate_impl.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/presentation_service_delegate_impl.h"
+
+#include <string>
+
+#include "base/guid.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "chrome/browser/media/router/create_session_request.h"
+#include "chrome/browser/media/router/media_route.h"
+#include "chrome/browser/media/router/media_router.h"
+#include "chrome/browser/media/router/media_router_impl_factory.h"
+#include "chrome/browser/media/router/media_sink.h"
+#include "chrome/browser/media/router/media_source_helper.h"
+#include "chrome/browser/media/router/presentation_helper.h"
+#include "chrome/browser/media/router/presentation_media_sinks_observer.h"
+#include "chrome/browser/sessions/session_tab_helper.h"
+#include "chrome/browser/ui/webui/media_router/media_router_dialog_controller.h"
+#include "content/public/browser/presentation_screen_availability_listener.h"
+#include "content/public/browser/presentation_session.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
+
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(
+    media_router::PresentationServiceDelegateImpl);
+
+using content::RenderFrameHost;
+
+namespace {
+
+using RenderFrameHostId =
+    content::PresentationServiceDelegate::RenderFrameHostId;
+
+// Helper function to extract ID for a RFH.
+RenderFrameHostId GetRenderFrameHostId(RenderFrameHost* rfh) {

[mark a. foltz, 2015/05/14 22:20:46]

It seems like this should be a ctor for RenderFrameHostId

[haibinlu, 2015/05/15 23:32:29]

It is a typedef.

typedef std::pair<int, int> RenderFrameHostId;

+  int render_process_id = rfh->GetProcess()->GetID();
+  int render_frame_id = rfh->GetRoutingID();
+  return RenderFrameHostId(render_process_id, render_frame_id);
+}
+
+// Gets the host name associated with the frame given by |rfh_id|.
+std::string GetSourceHostForFrame(RenderFrameHostId rfh_id) {
+  RenderFrameHost* rfh = RenderFrameHost::FromID(rfh_id.first, rfh_id.second);
+  DCHECK(rfh);
+  std::string host = rfh->GetLastCommittedURL().host();

[mark a. foltz, 2015/05/14 22:20:46]

Is this guaranteed to be a valid URL?  What about chrome://, chrome-extension://
or about: frames?
Please have some sort of fallback as I'm not convinced there is always a valid
host.

+  if (StartsWithASCII(host, "www.", false))
+    host = host.substr(4);
+  return host;
+}
+
+}  // namespace
+
+namespace media_router {
+
+PresentationServiceDelegateImpl::PresentationServiceDelegateImpl(
+    content::WebContents* web_contents)
+    : web_contents_(web_contents),
+      router_(MediaRouterImplFactory::GetMediaRouterForBrowserContext(
+          web_contents_->GetBrowserContext())),
+      frame_map_(web_contents),
+      weak_factory_(this) {
+  DCHECK(router_);
+}
+
+PresentationServiceDelegateImpl::~PresentationServiceDelegateImpl() {
+}
+
+void PresentationServiceDelegateImpl::AddObserver(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationServiceDelegate::Observer* observer) {
+  DCHECK(observer);
+  frame_map_.SetDelegateObserver(render_process_id, render_frame_id, observer);
+}
+
+void PresentationServiceDelegateImpl::RemoveObserver(int render_process_id,
+                                                     int render_frame_id) {
+  frame_map_.SetDelegateObserver(render_process_id, render_frame_id, NULL);

[mark a. foltz, 2015/05/14 22:20:46]

Please add a method RemoveDelegateObserver() instead of passing NULL.

+}
+
+bool PresentationServiceDelegateImpl::AddScreenAvailabilityListener(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationScreenAvailabilityListener* listener) {
+  DCHECK(listener);
+

[mark a. foltz, 2015/05/14 22:20:46]

Extra newline

[haibinlu, 2015/05/15 23:32:30]

Done.

+  return frame_map_.AddScreenAvailabilityListener(render_process_id,
+                                                  render_frame_id, listener);
+}
+
+void PresentationServiceDelegateImpl::RemoveScreenAvailabilityListener(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationScreenAvailabilityListener* listener) {
+  DCHECK(listener);
+  frame_map_.RemoveScreenAvailabilityListener(render_process_id,
+                                              render_frame_id, listener);
+}
+
+void PresentationServiceDelegateImpl::Reset(int render_process_id,
+                                            int render_frame_id) {
+  frame_map_.Reset(render_process_id, render_frame_id);
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  if (IsMainFrame(rfh_id))
+    UpdateDefaultMediaSourceAndNotifyObservers(MediaSource(), std::string());

[mark a. foltz, 2015/05/14 22:20:46]

I would prefer an explicit method, RemoveDefaultMediaSource...

+}
+
+void PresentationServiceDelegateImpl::SetDefaultPresentationUrl(
+    int render_process_id,
+    int render_frame_id,
+    const std::string& default_presentation_url,
+    const std::string& default_presentation_id) {
+  frame_map_.SetDefaultPresentationInfo(render_process_id, render_frame_id,
+                                        default_presentation_url,
+                                        default_presentation_id);
+
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  if (IsMainFrame(rfh_id)) {
+    // This is the main frame, that means tab-level default presentation
+    // might have been updated.
+    MediaSource new_default_source;
+    if (!default_presentation_url.empty())
+      new_default_source = ForPresentationUrl(default_presentation_url);

[mark a. foltz, 2015/05/14 22:20:46]

What about setting |default_presentation_id| on |new_default_source|?

+    std::string new_default_source_host(GetSourceHostForFrame(rfh_id));

[mark a. foltz, 2015/05/14 22:20:46]

Ah, this is not derived from new_default_source, but from the committed URL for
the frame that set it.

Can this be named something like new_default_presentation_frame_host (and the
corresponding other variables updated)?

+    UpdateDefaultMediaSourceAndNotifyObservers(new_default_source,
+                                               new_default_source_host);
+  }
+}
+
+bool PresentationServiceDelegateImpl::IsMainFrame(
+    RenderFrameHostId rfh_id) const {
+  RenderFrameHost* main_frame = web_contents_->GetMainFrame();
+  return main_frame && GetRenderFrameHostId(main_frame) == rfh_id;
+}
+
+void PresentationServiceDelegateImpl::
+    UpdateDefaultMediaSourceAndNotifyObservers(
+        const MediaSource& new_default_source,
+        const std::string& new_default_source_host) {
+  if (!new_default_source.Equals(default_source_) ||
+      new_default_source_host != default_source_host_) {
+    default_source_ = new_default_source;
+    default_source_host_ = new_default_source_host;
+    FOR_EACH_OBSERVER(
+        DefaultMediaSourceObserver, default_media_source_observers_,
+        OnDefaultMediaSourceChanged(default_source_, default_source_host_));
+  }
+}
+
+std::string PresentationServiceDelegateImpl::GetOrGeneratePresentationId(
+    RenderFrameHostId rfh_id,
+    const std::string& presentation_id) const {
+  if (!presentation_id.empty())
+    return presentation_id;
+
+  const std::string& default_presentation_id =
+      frame_map_.GetDefaultPresentationId(rfh_id);
+  return default_presentation_id.empty() ? base::GenerateGUID()
+                                         : default_presentation_id;
+}
+
+void PresentationServiceDelegateImpl::StartSession(
+    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();

[mark a. foltz, 2015/05/14 22:20:46]

It seems like this can be implemented now: call into router_->RequestRoute() and
bind a callback to OnRouteCreated().

[haibinlu, 2015/05/15 23:32:29]

router_ can not be not properly set till the next CL from Kevin.

+}
+
+void PresentationServiceDelegateImpl::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();
+}
+
+void PresentationServiceDelegateImpl::ListenForSessionMessages(
+    int render_process_id,
+    int render_frame_id,
+    const PresentationSessionMessageCallback& message_cb) {
+  NOTIMPLEMENTED();

[mark a. foltz, 2015/05/14 22:20:46]

Can you elaborate on what is required here?  What object will serve as the
MediaRouter::Delegate?

[haibinlu, 2015/05/15 23:32:30]

Same here.

+}
+
+void PresentationServiceDelegateImpl::OnRouteCreated(const MediaRoute& route) {
+  const MediaSource& source = route.media_source();
+  DCHECK(!source.Empty());
+  if (default_source_.Equals(source)) {
+    RenderFrameHost* main_frame = web_contents_->GetMainFrame();
+    if (main_frame) {
+      RenderFrameHostId rfh_id(GetRenderFrameHostId(main_frame));
+      auto observer = frame_map_.GetDelegateObserver(rfh_id);
+      if (observer) {
+        // TODO(imcheng): Pass in valid default presentation ID once it is
+        // available from MediaRoute URN.
+        observer->OnDefaultPresentationStarted(content::PresentationSessionInfo(
+            GetPresentationUrl(source), std::string()));
+      }
+    }
+  }

[mark a. foltz, 2015/05/14 22:20:46]

We need to instantiate a MediaRouter::Delegate for the newly returned route but
we don't have the API to register it yet in MediaRouter.   Can you check with
imcheng@ to find out the status, and add a TODO/NOTE outlining the path forward?

+}
+
+MediaSource PresentationServiceDelegateImpl::GetDefaultMediaSource() const {
+  return default_source_;
+}
+
+void PresentationServiceDelegateImpl::AddDefaultMediaSourceObserver(
+    DefaultMediaSourceObserver* observer) {
+  default_media_source_observers_.AddObserver(observer);
+}
+
+void PresentationServiceDelegateImpl::RemoveDefaultMediaSourceObserver(
+    DefaultMediaSourceObserver* observer) {
+  default_media_source_observers_.RemoveObserver(observer);
+}
+
+void PresentationServiceDelegateImpl::SetMediaRouterForTest(
+    MediaRouter* router) {
+  router_ = router;
+}
+
+base::WeakPtr<PresentationServiceDelegateImpl>
+PresentationServiceDelegateImpl::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
+}  // namespace media_router