[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 "chrome/browser/ui/webui/media_router/media_router_dialog_controller.h"

[imcheng (use chromium acct), 2015/05/18 20:54:07]

This isn't used yet. Please remove it and other unused includes.

[haibinlu, 2015/05/18 23:40:47]

Done.

+#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 {

[imcheng (use chromium acct), 2015/05/18 20:54:07]

You should be able to nest this anonymous namespace into namespace media_router.

[haibinlu, 2015/05/18 23:40:46]

Done.

+
+using RenderFrameHostId =

[imcheng (use chromium acct), 2015/05/18 20:54:06]

typedef not needed if moved into media_router namespace.

[haibinlu, 2015/05/18 23:40:46]

Done.

+    content::PresentationServiceDelegate::RenderFrameHostId;
+
+// 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
+
+namespace media_router {
+
+// Helper class for PresentationServiceDelegateImpl to manage
+// listeners and default presentation info in a render frame.
+class PresentationFrame {
+ public:
+  using DelegateObserver = content::PresentationServiceDelegate::Observer;
+
+  explicit PresentationFrame(content::WebContents* web_contents,
+                             MediaRouter* router);
+  virtual ~PresentationFrame();

[imcheng (use chromium acct), 2015/05/18 20:54:07]

Doesn't need to be virtual.

[haibinlu, 2015/05/18 23:40:47]

Done.

+
+  // Returns true if listener was added.
+  bool AddScreenAvailabilityListener(
+      content::PresentationScreenAvailabilityListener* listener);
+  // Returns true if listener was deleted.
+  bool RemoveScreenAvailabilityListener(
+      content::PresentationScreenAvailabilityListener* listener);
+  // Returns true if there is a listener for |source_id|.
+  bool HasScreenAvailabilityListenerFor(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;

[imcheng (use chromium acct), 2015/05/18 20:54:07]

How about DCHECK(!delegate_observer_) before setting?

[haibinlu, 2015/05/18 23:40:47]

Done.

+  }
+  DelegateObserver* delegate_observer() const { return delegate_observer_; }
+
+  void Reset();
+
+ private:
+  MediaSource GetMediaSourceFromListener(
+      content::PresentationScreenAvailabilityListener* listener);
+
+  // Not owned by this class.
+  DelegateObserver* delegate_observer_;

[imcheng (use chromium acct), 2015/05/18 20:54:07]

Move this to after web_contents_

[haibinlu, 2015/05/18 23:40:47]

Done.

+
+  scoped_ptr<content::PresentationSessionInfo> default_presentation_info_;
+  base::ScopedPtrHashMap<MediaSourceId, scoped_ptr<MediaSinksObserver>>
+      sink_observers_;
+
+  // Does not own these two objects.
+  MediaRouter* router_;

[imcheng (use chromium acct), 2015/05/18 20:54:07]

1. Can these be declared in the same order as ctor arguments?
2. Make the pointers const.

[haibinlu, 2015/05/18 23:40:47]

Done.

+  content::WebContents* web_contents_;
+};
+
+PresentationFrame::PresentationFrame(content::WebContents* web_contents,
+                                     MediaRouter* router)
+    : web_contents_(web_contents), router_(router), delegate_observer_(NULL) {

[imcheng (use chromium acct), 2015/05/18 20:54:07]

s/NULL/nullptr

[haibinlu, 2015/05/18 23:40:46]

Done.

+  DCHECK(router_);

[imcheng (use chromium acct), 2015/05/18 20:54:07]

DCHECK(web_contents_) ?

[haibinlu, 2015/05/18 23:40:47]

Done.

+}
+
+PresentationFrame::~PresentationFrame() {
+  DCHECK(sink_observers_.empty());
+  if (delegate_observer_) {
+    delegate_observer_->OnDelegateDestroyed();
+  }
+}
+
+bool PresentationFrame::AddScreenAvailabilityListener(
+    content::PresentationScreenAvailabilityListener* listener) {
+  MediaSource source(GetMediaSourceFromListener(listener));
+  if (sink_observers_.contains(source.id()))

[imcheng (use chromium acct), 2015/05/18 20:54:06]

A single add() will work:
https://code.google.com/p/chromium/codesearch#chromium/src/base/containers/sc...

[haibinlu, 2015/05/18 23:40:47]

can not remove it. because "new PresentationMediaSinksObserver" will auto add an
observer to router_. 

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

How about: add an empty scoped_ptr to the map, and then if it succeeded, reset
the pointer with new PresentationMediaSinksObserver.

+    return false;
+
+  sink_observers_.add(source.id(),
+                      make_scoped_ptr(new PresentationMediaSinksObserver(
+                          router_, listener, source)));
+  return true;
+}
+
+bool PresentationFrame::RemoveScreenAvailabilityListener(
+    content::PresentationScreenAvailabilityListener* listener) {
+  MediaSource source(GetMediaSourceFromListener(listener));
+  return sink_observers_.erase(source.id()) == 1;
+}
+
+bool PresentationFrame::HasScreenAvailabilityListenerFor(
+    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 {
+ public:
+  using RenderFrameHostId =
+      content::PresentationServiceDelegate::RenderFrameHostId;
+  using DelegateObserver = content::PresentationServiceDelegate::Observer;
+
+  explicit PresentationFrameMap(content::WebContents* web_contents,
+                                MediaRouter* router);
+  virtual ~PresentationFrameMap();

[imcheng (use chromium acct), 2015/05/18 20:54:07]

Does not need to be virtual.

[haibinlu, 2015/05/18 23:40:47]

Done.

+
+  // Returns true if listener was added.
+  bool AddScreenAvailabilityListener(
+      int render_process_id,
+      int render_frame_id,
+      content::PresentationScreenAvailabilityListener* listener);
+  // Returns true if listener was deleted.

[imcheng (use chromium acct), 2015/05/18 20:54:07]

Newline before comments, also s/deleted/removed

[haibinlu, 2015/05/18 23:40:47]

Done.

+  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.

[imcheng (use chromium acct), 2015/05/18 20:54:07]

Newline before comments, same for below

[haibinlu, 2015/05/18 23:40:46]

Done.

+  bool HasScreenAvailabilityListenerFor(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 SetDelegateObserver(int render_process_id,
+                           int render_frame_id,
+                           DelegateObserver* observer);
+  DelegateObserver* GetDelegateObserver(RenderFrameHostId rfh_id) const;
+
+  void Reset(int render_process_id, int render_frame_id);

[imcheng (use chromium acct), 2015/05/18 20:54:08]

RenderFrameHostId rfh_id

[haibinlu, 2015/05/18 23:40:46]

Done.

+
+  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_;

[imcheng (use chromium acct), 2015/05/18 20:54:07]

It looks like we may have a potential memory leak here. How do we ensure
PresentationFrame entries are removed from the map when they are no longer
needed?

[haibinlu, 2015/05/18 23:40:46]

As discussed, use removeObserver to remove the entry. will rename removeObserver
to UnregisterPresentationFrame in a different CL.

+
+  // 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) {

[imcheng (use chromium acct), 2015/05/18 20:54:07]

DCHECKs?

[haibinlu, 2015/05/18 23:40:46]

Done.

+}
+
+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::HasScreenAvailabilityListenerFor(
+    RenderFrameHostId rfh_id,
+    const MediaSourceId& source_id) const {
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  return presentation_frame &&
+         presentation_frame->HasScreenAvailabilityListenerFor(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::SetDelegateObserver(
+    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);
+}
+
+PresentationFrameMap::DelegateObserver*
+PresentationFrameMap::GetDelegateObserver(RenderFrameHostId rfh_id) const {
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  return presentation_frame ? presentation_frame->delegate_observer() : NULL;
+}
+
+void PresentationFrameMap::Reset(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) {

[imcheng (use chromium acct), 2015/05/18 20:54:06]

braces not needed for a single line.

[haibinlu, 2015/05/18 23:40:47]

Done.

+    presentation_frame->Reset();
+  }
+}
+
+PresentationFrame* PresentationFrameMap::GetOrAddFrame(
+    RenderFrameHostId rfh_id) {
+  auto presentation_frame = presentation_frames_.get(rfh_id);

[imcheng (use chromium acct), 2015/05/18 20:54:06]

redundant get.

[haibinlu, 2015/05/18 23:40:47]

Done.

+  if (!presentation_frames_.contains(rfh_id)) {

[imcheng (use chromium acct), 2015/05/18 20:54:07]

For this use case it looks like a single add() is sufficient -- add() does
nothing if the key already exists.

https://code.google.com/p/chromium/codesearch#chromium/src/base/containers/sc...

[haibinlu, 2015/05/18 23:40:47]

But it'd create a new PresentationFrameObject and release if the element already
exists.

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

same comment as above.

+    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),

[imcheng (use chromium acct), 2015/05/18 20:54:07]

s/NULL/nullptr, same for below

[haibinlu, 2015/05/18 23:40:47]

Done.

+      frame_map_(new PresentationFrameMap(web_contents, NULL)),
+      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);

[imcheng (use chromium acct), 2015/05/18 20:54:06]

nullptr

[haibinlu, 2015/05/18 23:40:47]

Done.

+}
+
+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) {
+  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());
+}
+
+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();

[imcheng (use chromium acct), 2015/05/18 20:54:07]

Thinking about this some more, I think this is not quite correct. We need to
iterate through all frames and call observer->OnDefaultPresentationStarted for
each frame that has a matching default presentation URL.

[haibinlu, 2015/05/18 23:40:46]

I am not sure this is the right behavior either. A client can sent arbitrary
presentation URL; what presents it from getting access to the session if it
purposely sets the same URL as the main frame?

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

Per offline chat. This is correct behavior (at least for session started via
browser icon) since the browser icon uses the source on the main frame. So only
the main frame should be notified in this case. We need additional support for
handling autojoin behavior.

+    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()));
+      }
+    }
+  }
+}
+
+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;
+  frame_map_->SetMediaRouterForTest(router);
+}
+
+base::WeakPtr<PresentationServiceDelegateImpl>
+PresentationServiceDelegateImpl::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
+bool PresentationServiceDelegateImpl::HasScreenAvailabilityListenerFor(

[imcheng (use chromium acct), 2015/05/18 20:54:06]

is this used?

[haibinlu, 2015/05/18 23:40:47]

Used in test, which was accessing private member directly.

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

Can we use friend class and FRIEND_TEST_ALL_PREFIXES instead to access private
members instead?

+    RenderFrameHostId rfh_id,
+    const MediaSourceId& source_id) const {
+  return frame_map_->HasScreenAvailabilityListenerFor(rfh_id, source_id);
+}
+
+}  // namespace media_router