[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/containers/scoped_ptr_hash_map.h"
+#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_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 "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 media_router {
+
+namespace {
+
+// Helper function to extract ID for a RFH.
+RenderFrameHostId GetRenderFrameHostId(RenderFrameHost* rfh) {
+  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();
+  if (StartsWithASCII(host, "www.", false))
+    host = host.substr(4);
+  return host;
+}
+
+}  // namespace
+
+// Helper class for PresentationServiceDelegateImpl to manage
+// listeners and default presentation info in a render frame.
+class PresentationFrame final {
+ public:
+  using DelegateObserver = content::PresentationServiceDelegate::Observer;
+
+  explicit PresentationFrame(content::WebContents* web_contents,

[imcheng (use chromium acct), 2015/05/19 20:03:29]

rm explicit

[haibinlu, 2015/05/19 21:14:35]

Done.

+                             MediaRouter* router);
+  ~PresentationFrame();
+
+  // Returns true if listener was added.
+  bool AddScreenAvailabilityListener(
+      content::PresentationScreenAvailabilityListener* listener);
+
+  // Returns true if listener was removed.
+  bool RemoveScreenAvailabilityListener(
+      content::PresentationScreenAvailabilityListener* listener);
+
+  // Returns true if there is a listener for |source_id|.
+  bool HasScreenAvailabilityListenerForTest(
+      const MediaSourceId& source_id) const;
+
+  // Returns the number of screen-availability listeners.
+  int NumScreenAvailabilityListeners() const;
+
+  // Sets the default presentation URL and ID.
+  void SetDefaultPresentationInfo(const std::string& default_presentation_url,
+                                  const std::string& default_presentation_id);
+
+  // Returns empty string if no default presentation ID is set.
+  std::string GetDefaultPresentationId() const;
+  void set_delegate_observer(DelegateObserver* observer) {
+    delegate_observer_ = observer;
+  }
+  DelegateObserver* delegate_observer() const { return delegate_observer_; }
+
+  void Reset();
+
+ private:
+  MediaSource GetMediaSourceFromListener(
+      content::PresentationScreenAvailabilityListener* listener);
+
+  scoped_ptr<content::PresentationSessionInfo> default_presentation_info_;
+  base::ScopedPtrHashMap<MediaSourceId, scoped_ptr<MediaSinksObserver>>
+      sink_observers_;
+
+  // Does not own these objects.
+  const content::WebContents* web_contents_;
+  MediaRouter* router_;
+  DelegateObserver* delegate_observer_;
+};
+
+PresentationFrame::PresentationFrame(content::WebContents* web_contents,
+                                     MediaRouter* router)
+    : web_contents_(web_contents),
+      router_(router),
+      delegate_observer_(nullptr) {
+  DCHECK(web_contents_);
+  DCHECK(router_);
+}
+
+PresentationFrame::~PresentationFrame() {
+  DCHECK(sink_observers_.empty());
+  Reset();

[imcheng (use chromium acct), 2015/05/19 20:03:29]

Why does Reset() need to be called? The dtor will take care of clearing
containers and deleting scoped_ptrs.

[haibinlu, 2015/05/19 21:14:35]

removed

+  if (delegate_observer_) {
+    delegate_observer_->OnDelegateDestroyed();

[imcheng (use chromium acct), 2015/05/19 20:03:29]

OnDelegateDestroyed() should be called in PresesentationServiceDelegateImpl's
dtor. I see that you had to explicitly set the delegate_observer_ to nullptr
before erasing it because OnDelegateDestroyed() is here. You shouldn't have to
do that.

[haibinlu, 2015/05/19 21:14:35]

Done.

+  }
+}
+
+bool PresentationFrame::AddScreenAvailabilityListener(
+    content::PresentationScreenAvailabilityListener* listener) {
+  MediaSource source(GetMediaSourceFromListener(listener));
+  if (sink_observers_.contains(source.id()))
+    return false;
+
+  return sink_observers_.add(source.id(),
+                             make_scoped_ptr(new PresentationMediaSinksObserver(
+                                 router_, listener, source))).second;
+}
+
+bool PresentationFrame::RemoveScreenAvailabilityListener(
+    content::PresentationScreenAvailabilityListener* listener) {
+  MediaSource source(GetMediaSourceFromListener(listener));
+  return sink_observers_.erase(source.id()) == 1;
+}
+
+bool PresentationFrame::HasScreenAvailabilityListenerForTest(
+    const MediaSourceId& source_id) const {
+  return sink_observers_.contains(source_id);
+}
+
+int PresentationFrame::NumScreenAvailabilityListeners() const {
+  return sink_observers_.size();
+}
+
+void PresentationFrame::Reset() {
+  sink_observers_.clear();
+  default_presentation_info_.reset();
+}
+
+void PresentationFrame::SetDefaultPresentationInfo(
+    const std::string& default_presentation_url,
+    const std::string& default_presentation_id) {
+  if (default_presentation_url.empty() && default_presentation_id.empty()) {
+    default_presentation_info_.reset();
+  } else {
+    default_presentation_info_.reset(new content::PresentationSessionInfo(
+        default_presentation_url, default_presentation_id));
+  }
+}
+
+std::string PresentationFrame::GetDefaultPresentationId() const {
+  return default_presentation_info_
+             ? default_presentation_info_->presentation_id
+             : "";
+}
+
+MediaSource PresentationFrame::GetMediaSourceFromListener(
+    content::PresentationScreenAvailabilityListener* listener) {
+  // If the default presentation URL is empty then fall back to 1-UA mode,
+  // i.e. offscreeen tab rendering.
+  std::string presentation_url(listener->GetPresentationUrl());
+  return presentation_url.empty()
+             ? ForTabMediaSource(SessionTabHelper::IdForTab(web_contents_))
+             : ForPresentationUrl(presentation_url);
+}
+
+// Helper class for PresentationServiceDelegateImpl to manage
+// PresentationFrames.
+class PresentationFrameMap final {
+ public:
+  using RenderFrameHostId = std::pair<int, int>;

[imcheng (use chromium acct), 2015/05/19 20:03:29]

I don't think you need this. You can just reuse the type alias defined in the
.h.

[haibinlu, 2015/05/19 21:14:35]

Done.

+  using DelegateObserver = content::PresentationServiceDelegate::Observer;
+
+  explicit PresentationFrameMap(content::WebContents* web_contents,

[imcheng (use chromium acct), 2015/05/19 20:03:29]

rm explicit

[haibinlu, 2015/05/19 21:14:35]

Done.

+                                MediaRouter* router);
+  ~PresentationFrameMap();
+
+  // Returns true if listener was added.
+  bool AddScreenAvailabilityListener(
+      int render_process_id,

[imcheng (use chromium acct), 2015/05/19 20:03:29]

Use RenderFrameHostId here and below?

[haibinlu, 2015/05/19 21:14:35]

Done.

+      int render_frame_id,
+      content::PresentationScreenAvailabilityListener* listener);
+
+  // Returns true if listener was removed.
+  bool RemoveScreenAvailabilityListener(
+      int render_process_id,
+      int render_frame_id,
+      content::PresentationScreenAvailabilityListener* listener);
+
+  // Returns true if there is a listener for |source_id| in the frame.
+  bool HasScreenAvailabilityListenerForTest(
+      RenderFrameHostId rfh_id,
+      const MediaSourceId& source_id) const;
+
+  // Returns the number of screen-availability listeners.
+  int NumScreenAvailabilityListeners() const;
+
+  // Returns the default presentation URL and ID for the frame.
+  void SetDefaultPresentationInfo(int render_process_id,
+                                  int render_frame_id,
+                                  const std::string& default_presentation_url,
+                                  const std::string& default_presentation_id);
+
+  // Returns empty string if no default presentation ID is set in the frame.
+  std::string GetDefaultPresentationId(RenderFrameHostId rfh_id) const;
+
+  void RegisterPresenationFrame(int render_process_id,
+                                int render_frame_id,
+                                DelegateObserver* observer);
+  void UnregisterPresenationFrame(int render_process_id, int render_frame_id);
+
+  DelegateObserver* GetDelegateObserver(RenderFrameHostId rfh_id) const;
+
+  void Reset(RenderFrameHostId rfh_id);
+
+  void SetMediaRouterForTest(MediaRouter* router);
+
+ private:
+  PresentationFrame* GetOrAddFrame(RenderFrameHostId rfh_id);
+
+  // Maps a frame identifier to a PresentationFrame object for frames
+  // that are using presentation API.
+  base::ScopedPtrHashMap<RenderFrameHostId, scoped_ptr<PresentationFrame>>
+      presentation_frames_;
+
+  // Does not own these two objects.
+  MediaRouter* router_;
+  content::WebContents* web_contents_;
+};
+
+PresentationFrameMap::PresentationFrameMap(content::WebContents* web_contents,
+                                           MediaRouter* router)
+    : web_contents_(web_contents), router_(router) {
+  DCHECK(web_contents_);
+}
+
+PresentationFrameMap::~PresentationFrameMap() {
+}
+
+bool PresentationFrameMap::AddScreenAvailabilityListener(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationScreenAvailabilityListener* listener) {
+  if (NumScreenAvailabilityListeners() >=
+      PresentationServiceDelegateImpl::kMaxNumSources) {
+    return false;
+  }
+
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  auto presentation_frame = GetOrAddFrame(rfh_id);
+  return presentation_frame->AddScreenAvailabilityListener(listener);
+}
+
+bool PresentationFrameMap::RemoveScreenAvailabilityListener(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationScreenAvailabilityListener* listener) {
+  DCHECK(listener);
+
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  return presentation_frame &&
+         presentation_frame->RemoveScreenAvailabilityListener(listener);
+}
+
+bool PresentationFrameMap::HasScreenAvailabilityListenerForTest(
+    RenderFrameHostId rfh_id,
+    const MediaSourceId& source_id) const {
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  return presentation_frame &&
+         presentation_frame->HasScreenAvailabilityListenerForTest(source_id);
+}
+
+int PresentationFrameMap::NumScreenAvailabilityListeners() const {
+  int count = 0;
+  for (const auto& pf : presentation_frames_) {
+    count += pf.second->NumScreenAvailabilityListeners();
+  }
+  return count;
+}
+
+void PresentationFrameMap::SetDefaultPresentationInfo(
+    int render_process_id,
+    int render_frame_id,
+    const std::string& default_presentation_url,
+    const std::string& default_presentation_id) {
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  auto presentation_frame = GetOrAddFrame(rfh_id);
+  presentation_frame->SetDefaultPresentationInfo(default_presentation_url,
+                                                 default_presentation_id);
+}
+
+std::string PresentationFrameMap::GetDefaultPresentationId(
+    RenderFrameHostId rfh_id) const {
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  return presentation_frame ? presentation_frame->GetDefaultPresentationId()
+                            : "";
+}
+
+void PresentationFrameMap::RegisterPresenationFrame(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationServiceDelegate::Observer* observer) {
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  auto presentation_frame = GetOrAddFrame(rfh_id);
+  presentation_frame->set_delegate_observer(observer);
+}
+
+void PresentationFrameMap::UnregisterPresenationFrame(int render_process_id,
+                                                      int render_frame_id) {
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  if (presentation_frame) {
+    presentation_frame->set_delegate_observer(nullptr);

[imcheng (use chromium acct), 2015/05/19 20:03:29]

not needed if you move the OnDelegateDestroyed() to PSDelegateImpl dtor. Then
this can simplify into an erase() call.

[haibinlu, 2015/05/19 21:14:35]

Done.

+    presentation_frames_.erase(rfh_id);
+  }
+}
+
+PresentationFrameMap::DelegateObserver*
+PresentationFrameMap::GetDelegateObserver(RenderFrameHostId rfh_id) const {
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  return presentation_frame ? presentation_frame->delegate_observer() : nullptr;
+}
+
+void PresentationFrameMap::Reset(RenderFrameHostId rfh_id) {
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  if (presentation_frame)
+    presentation_frame->Reset();
+}
+
+PresentationFrame* PresentationFrameMap::GetOrAddFrame(
+    RenderFrameHostId rfh_id) {
+  if (!presentation_frames_.contains(rfh_id)) {
+    presentation_frames_.add(
+        rfh_id, scoped_ptr<PresentationFrame>(
+                    new PresentationFrame(web_contents_, router_)));
+  }
+  return presentation_frames_.get(rfh_id);
+}
+
+void PresentationFrameMap::SetMediaRouterForTest(MediaRouter* router) {
+  router_ = router;
+}
+
+// TODO(haibinlu): Get router from MediaRouterMojoImplFactory once it lands.
+PresentationServiceDelegateImpl::PresentationServiceDelegateImpl(
+    content::WebContents* web_contents)
+    : web_contents_(web_contents),
+      router_(NULL),
+      frame_map_(new PresentationFrameMap(web_contents, nullptr)),

[imcheng (use chromium acct), 2015/05/19 20:03:29]

you might as well pass in router_ here if you are not DCHECKing against it.

[haibinlu, 2015/05/19 21:14:35]

will update this once MediaRouterMojoImplFactory lands.

+      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_->RegisterPresenationFrame(render_process_id, render_frame_id,
+                                       observer);
+}
+
+void PresentationServiceDelegateImpl::RemoveObserver(int render_process_id,
+                                                     int render_frame_id) {
+  frame_map_->UnregisterPresenationFrame(render_process_id, render_frame_id);
+}
+
+bool PresentationServiceDelegateImpl::AddScreenAvailabilityListener(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationScreenAvailabilityListener* listener) {
+  DCHECK(listener);
+  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) {
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  frame_map_->Reset(rfh_id);
+  if (IsMainFrame(rfh_id))
+    UpdateDefaultMediaSourceAndNotifyObservers(MediaSource(), std::string());
+}
+
+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);
+    std::string new_default_source_host(GetSourceHostForFrame(rfh_id));
+    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_));
+  }
+}
+
+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();
+}
+
+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();
+}
+
+void PresentationServiceDelegateImpl::SendMessage(
+    int render_process_id,
+    int render_frame_id,
+    scoped_ptr<content::PresentationSessionMessage> message_request,
+    const SendMessageCallback& send_message_cb) {
+  NOTIMPLEMENTED();
+}
+
+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()));
+      }
+    }
+  }
+}
+
+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;
+  frame_map_->SetMediaRouterForTest(router);
+}
+
+base::WeakPtr<PresentationServiceDelegateImpl>
+PresentationServiceDelegateImpl::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
+bool PresentationServiceDelegateImpl::HasScreenAvailabilityListenerForTest(
+    RenderFrameHostId rfh_id,
+    const MediaSourceId& source_id) const {
+  return frame_map_->HasScreenAvailabilityListenerForTest(rfh_id, source_id);
+}
+
+}  // namespace media_router