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

[Wez, 2015/05/27 22:37:51]

RFH->RenderFrameHost.

Suggest: "Returns the unique identifier for the supplied RenderViewHost."

[haibinlu, 2015/05/28 21:44:02]

Done.

+RenderFrameHostId GetRenderFrameHostId(RenderFrameHost* rfh) {

[Wez, 2015/05/27 22:37:51]

nit: rfh->render_view_host

[haibinlu, 2015/05/28 21:44:02]

Done.

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

[Wez, 2015/05/27 22:37:50]

I think you need to be more specific about what the "host name associated with
the frame" is about - you're really pulling out the name of the host from which
the frame's content was loaded, to display in the UI, I think? You might
consider calling this GetDisplayNameForFrame, instead.

[haibinlu, 2015/05/28 21:44:02]

Done.

+std::string GetSourceHostForFrame(RenderFrameHostId rfh_id) {

[Wez, 2015/05/27 22:37:50]

nit: render_view_host_id

[haibinlu, 2015/05/28 21:44:03]

Done.

+  RenderFrameHost* rfh = RenderFrameHost::FromID(rfh_id.first, rfh_id.second);

[Wez, 2015/05/27 22:37:50]

nit: render_view_host

[haibinlu, 2015/05/28 21:44:03]

Done.

+  DCHECK(rfh);

[Wez, 2015/05/27 22:37:51]

Don't DCHECK |rfh| here - you're dereferencing it immediately afterward, which
will crash anyway if it's NULL!

[haibinlu, 2015/05/28 21:44:02]

Done.

+  std::string host = rfh->GetLastCommittedURL().host();
+  if (StartsWithASCII(host, "www.", false))
+    host = host.substr(4);
+  return host;
+}
+
+}  // namespace
+
+// Helper class for PresentationServiceDelegateImpl to manage

[Wez, 2015/05/27 22:37:51]

nit: No need for "Helper class..." intro - suggest "Used by
PresentationServiceDelegateImpl to..."

nit: what does "manage" mean - wording seems vague?

[haibinlu, 2015/05/28 21:44:04]

Done.

+// listeners and default presentation info in a render frame.
+class PresentationFrame final {

[Wez, 2015/05/27 22:37:49]

We rarely use "final" in Chromium code, AFAIK, and in this case this class is
local to this .cc file (incidentally, why is the class not in the anonymous
namespace, as well?

[haibinlu, 2015/05/28 21:44:02]

Removed "final". If it is in anonymous namespace, then we can reference it
presentation_service_delegate_impl.h as a private member.

+ public:
+  using DelegateObserver = content::PresentationServiceDelegate::Observer;
+
+  PresentationFrame(content::WebContents* web_contents, MediaRouter* router);
+  ~PresentationFrame();
+
+  // Returns true if listener was added.

[Wez, 2015/05/27 22:37:50]

It looks like these APIs mirror corresponding APIs in
PresentationServiceDelegate interface, in which case I'd suggest just a block
comment indicating that fact rather than individual comments on each method.

[haibinlu, 2015/05/28 21:44:04]

Mostly mirror PresentationFrameManager API. Updated the comments.

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

[Wez, 2015/05/27 22:37:50]

nit: Why does Has*ForTest() take a |source_id| but this doesn't?

[haibinlu, 2015/05/28 21:44:03]

method removed. Checked the presentation API, there is at most one listener per
presentation frame.

+  int NumScreenAvailabilityListeners() const;
+
+  // Sets the default presentation URL and ID.

[Wez, 2015/05/27 22:37:50]

nit: This comment adds nothing!

[haibinlu, 2015/05/28 21:44:03]

removed

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

[Wez, 2015/05/27 22:37:50]

nit: Blank line after this.

[haibinlu, 2015/05/28 21:44:03]

Acknowledged.

+  void set_delegate_observer(DelegateObserver* observer) {
+    delegate_observer_ = observer;
+  }
+  DelegateObserver* delegate_observer() const { return delegate_observer_; }
+
+  void Reset();
+  void OnDelegateDestroyed();

[Wez, 2015/05/27 22:37:49]

nit: Add comments to explain these.

[haibinlu, 2015/05/28 21:44:03]

method removed

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

[Wez, 2015/05/27 22:37:50]

nit: Suggest "References to the owning WebContents, and the corresponding
MediaRouter."

Don't think you really need a comment on |delegate_observer_| since it's clear
from the setter/getter above how it's owned.

[haibinlu, 2015/05/28 21:44:02]

Done.

+  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());
+}
+
+bool PresentationFrame::AddScreenAvailabilityListener(
+    content::PresentationScreenAvailabilityListener* listener) {
+  MediaSource source(GetMediaSourceFromListener(listener));
+  if (sink_observers_.contains(source.id()))

[Wez, 2015/05/27 22:37:51]

This doesn't look like it'll behave as intended if two listeners A & B are added
for the same Id - in that case you'll early-exit rather than adding B, but if
the caller later tries to remove B then you will actually remove A, below?

[haibinlu, 2015/05/28 21:44:02]

method updated. Checked the presentation API, there is at most one listener per
presentation frame.

+    return false;
+
+  return sink_observers_.add(source.id(),
+                             make_scoped_ptr(new PresentationMediaSinksObserver(
+                                 router_, listener, source))).second;

[Wez, 2015/05/27 22:37:51]

This is weird - why are you returning .second? How can that ever be null/false
here?

[haibinlu, 2015/05/28 21:44:03]

Updated to 'Setter'

+}
+
+bool PresentationFrame::RemoveScreenAvailabilityListener(
+    content::PresentationScreenAvailabilityListener* listener) {
+  MediaSource source(GetMediaSourceFromListener(listener));

[Wez, 2015/05/27 22:37:50]

Do you need to check that the registered listener for the id is the one we're
being asked to remove?

[haibinlu, 2015/05/28 21:44:03]

Done.

+  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::OnDelegateDestroyed() {
+  if (delegate_observer_) {
+    delegate_observer_->OnDelegateDestroyed();
+  }
+}
+
+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
+             : "";

[Wez, 2015/05/27 22:37:49]

nit: I think this would read more clearly as if(...) return ...; return "";

[haibinlu, 2015/05/28 21:44:03]

Done.

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

[Wez, 2015/05/27 22:37:50]

typo: offscreen

Do we have off-screen tab rendering hooked up? Looks like this will actually
mirror the sending tab?

[haibinlu, 2015/05/28 21:44:04]

Off-screen tab mirroring is not hooked up. Updated comments.

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

[Wez, 2015/05/27 22:37:50]

nit: As above, clarify in this comment what it means to "manage" them?

[haibinlu, 2015/05/28 21:44:03]

Done.

+class PresentationFrameMap final {

[Wez, 2015/05/27 22:37:49]

Suggest PresentationFrameManager rather than Map - map implies behaviour akin to
std::map(), whereas this class actually has boilerplate functions that route
through to underlying PresentationFrames, and doesn't expose any actual map
capabilities, just uses one internally.

[haibinlu, 2015/05/28 21:44:04]

Done.

+ public:
+  using DelegateObserver = content::PresentationServiceDelegate::Observer;
+
+  PresentationFrameMap(content::WebContents* web_contents, MediaRouter* router);
+  ~PresentationFrameMap();
+
+  // Returns true if listener was added.

[Wez, 2015/05/27 22:37:51]

See above re having a block comment to indicate that these more or less mirror
the PresentationServiceDelegate interface?

[haibinlu, 2015/05/28 21:44:02]

Done.

+  bool AddScreenAvailabilityListener(
+      const RenderFrameHostId& rfh_id,

[Wez, 2015/05/27 22:37:51]

render_view_host_id here and elsewhere

[haibinlu, 2015/05/28 21:44:04]

Done.

+      content::PresentationScreenAvailabilityListener* listener);
+
+  // Returns true if listener was removed.
+  bool RemoveScreenAvailabilityListener(
+      const RenderFrameHostId& rfh_id,
+      content::PresentationScreenAvailabilityListener* listener);
+
+  // Returns true if there is a listener for |source_id| in the frame.
+  bool HasScreenAvailabilityListenerForTest(
+      const 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(const RenderFrameHostId& rfh_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(const RenderFrameHostId& rfh_id) const;
+
+  void RegisterPresenationFrame(const RenderFrameHostId& rfh_id,

[Wez, 2015/05/27 22:37:50]

typo: RegisterPresentationFrame, and Unregister

Document these two APIs?

Since these register a DelegateObserver for a RenderFrame, why are they called
[Un]registerPresentationFrame?

[haibinlu, 2015/05/28 21:44:03]

Registers a presentation frame and adds an observer. The lifetime of a
PresentationFrame is 

RegisterPresentationFrame (delegate observer added)
Reset
Reset
...
UnregisterPresentationFrame (delegate_observer.OnDelegateDestroyed invoked).

+                                DelegateObserver* observer);
+  void UnregisterPresenationFrame(const RenderFrameHostId& rfh_id);
+
+  DelegateObserver* GetDelegateObserver(const RenderFrameHostId& rfh_id) const;
+
+  void Reset(const RenderFrameHostId& rfh_id);
+  void OnDelegateDestroyed();

[Wez, 2015/05/27 22:37:51]

OnDelegatesDestroyed(), since this applies to all PresentationFrames, not to a
specific one.

[haibinlu, 2015/05/28 21:44:03]

The delegate means PresentationServiceDelegateImpl, only one. Updated the method
names.

+  void SetMediaRouterForTest(MediaRouter* router);
+
+ private:
+  PresentationFrame* GetOrAddFrame(const 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.

[Wez, 2015/05/27 22:37:51]

nit: See elsewhere re wording these comments.

[haibinlu, 2015/05/28 21:44:03]

Done.

+  MediaRouter* router_;
+  content::WebContents* web_contents_;
+};
+
+PresentationFrameMap::PresentationFrameMap(content::WebContents* web_contents,
+                                           MediaRouter* router)
+    : router_(router), web_contents_(web_contents) {
+  DCHECK(web_contents_);

[Wez, 2015/05/27 22:37:50]

nit: DCHECK(router_)?

[haibinlu, 2015/05/28 21:44:04]

cannot do this check now. Need to Derek's CL for MediaRouterMojoImplFactory to
land, then we can get the right MediaRouter* from it.

+}
+
+PresentationFrameMap::~PresentationFrameMap() {
+}
+
+bool PresentationFrameMap::AddScreenAvailabilityListener(
+    const RenderFrameHostId& rfh_id,
+    content::PresentationScreenAvailabilityListener* listener) {
+  DCHECK(listener);
+  if (NumScreenAvailabilityListeners() >=
+      PresentationServiceDelegateImpl::kMaxNumSources) {
+    return false;
+  }
+
+  auto presentation_frame = GetOrAddFrame(rfh_id);
+  return presentation_frame->AddScreenAvailabilityListener(listener);
+}
+
+bool PresentationFrameMap::RemoveScreenAvailabilityListener(
+    const RenderFrameHostId& rfh_id,
+    content::PresentationScreenAvailabilityListener* listener) {
+  DCHECK(listener);
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  return presentation_frame &&
+         presentation_frame->RemoveScreenAvailabilityListener(listener);
+}
+
+bool PresentationFrameMap::HasScreenAvailabilityListenerForTest(
+    const 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_) {

[Wez, 2015/05/27 22:37:50]

nit: pf -> frame

[haibinlu, 2015/05/28 21:44:03]

method updated. with one screen listener per frame, this is just numOfFrames.

+    count += pf.second->NumScreenAvailabilityListeners();
+  }
+  return count;
+}
+
+void PresentationFrameMap::SetDefaultPresentationInfo(
+    const RenderFrameHostId& rfh_id,
+    const std::string& default_presentation_url,
+    const std::string& default_presentation_id) {
+  auto presentation_frame = GetOrAddFrame(rfh_id);
+  presentation_frame->SetDefaultPresentationInfo(default_presentation_url,
+                                                 default_presentation_id);
+}
+
+std::string PresentationFrameMap::GetDefaultPresentationId(
+    const RenderFrameHostId& rfh_id) const {
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  return presentation_frame ? presentation_frame->GetDefaultPresentationId()
+                            : "";

[Wez, 2015/05/27 22:37:49]

nit: May be clearer as if (...) return x; return y;

[haibinlu, 2015/05/28 21:44:04]

Done.

+}
+
+void PresentationFrameMap::RegisterPresenationFrame(
+    const RenderFrameHostId& rfh_id,
+    content::PresentationServiceDelegate::Observer* observer) {
+  auto presentation_frame = GetOrAddFrame(rfh_id);
+  presentation_frame->set_delegate_observer(observer);
+}
+
+void PresentationFrameMap::UnregisterPresenationFrame(
+    const RenderFrameHostId& rfh_id) {
+  presentation_frames_.erase(rfh_id);
+}
+
+PresentationFrameMap::DelegateObserver*
+PresentationFrameMap::GetDelegateObserver(const RenderFrameHostId& rfh_id) const {
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  return presentation_frame ? presentation_frame->delegate_observer() : nullptr;
+}
+
+void PresentationFrameMap::Reset(const RenderFrameHostId& rfh_id) {
+  auto presentation_frame = presentation_frames_.get(rfh_id);
+  if (presentation_frame)
+    presentation_frame->Reset();
+}
+
+void PresentationFrameMap::OnDelegateDestroyed() {
+  for (auto& kv : presentation_frames_)

[Wez, 2015/05/27 22:37:49]

nit: kv -> frame

[haibinlu, 2015/05/28 21:44:03]

Done.

+    kv.second->OnDelegateDestroyed();
+}
+
+PresentationFrame* PresentationFrameMap::GetOrAddFrame(
+    const 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.

[Wez, 2015/05/27 22:37:49]

Add bug # for that change

[haibinlu, 2015/05/28 21:44:03]

Done.

+PresentationServiceDelegateImpl::PresentationServiceDelegateImpl(
+    content::WebContents* web_contents)
+    : frame_map_(new PresentationFrameMap(web_contents, nullptr)),
+      web_contents_(web_contents),
+      router_(NULL),

[Wez, 2015/05/27 22:37:51]

nullptr

[haibinlu, 2015/05/28 21:44:04]

Done.

+      weak_factory_(this) {
+}
+
+PresentationServiceDelegateImpl::~PresentationServiceDelegateImpl() {
+  frame_map_->OnDelegateDestroyed();

[Wez, 2015/05/27 22:37:50]

Given that |frame_map_| is about to be destroyed as well, could you move the
OnDelegateDestroyed() to be dispatched from its destructor, rather than from
here, and get rid of OnDelegatesDestroyed()?

[haibinlu, 2015/05/28 21:44:04]

Done.

+}
+
+void PresentationServiceDelegateImpl::AddObserver(
+    int render_process_id,
+    int render_frame_id,
+    content::PresentationServiceDelegate::Observer* observer) {
+  DCHECK(observer);
+  frame_map_->RegisterPresenationFrame(
+      RenderFrameHostId(render_process_id, render_frame_id), observer);
+}
+
+void PresentationServiceDelegateImpl::RemoveObserver(int render_process_id,
+                                                     int render_frame_id) {
+  frame_map_->UnregisterPresenationFrame(
+      RenderFrameHostId(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(
+      RenderFrameHostId(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(
+      RenderFrameHostId(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) {
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+  frame_map_->SetDefaultPresentationInfo(rfh_id, default_presentation_url,
+                                         default_presentation_id);
+  if (IsMainFrame(rfh_id)) {
+    // This is the main frame, that means tab-level default presentation

[Wez, 2015/05/27 22:37:50]

nit: that -> which

[haibinlu, 2015/05/28 21:44:02]

Done.

+    // might have been updated.

[Wez, 2015/05/27 22:37:50]

Suggest "... which means we may have switched between flinging and tab-level
mirroring."

[haibinlu, 2015/05/28 21:44:04]

This is caused by apps update its default presentation URL.

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

[Wez, 2015/05/27 22:37:51]

Is this and the below going to be implemented? If so then add bug #

[haibinlu, 2015/05/28 21:44:02]

Done.

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

[Wez, 2015/05/27 22:37:51]

Suggest restructuring this to use early-exit if !Equals(), and similarly for the
other if()s, to avoid all this indentation.

[haibinlu, 2015/05/28 21:44:02]

Done.

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

[Wez, 2015/05/27 22:37:51]

Bug #?

[haibinlu, 2015/05/28 21:44:04]

Done.

+        observer->OnDefaultPresentationStarted(content::PresentationSessionInfo(

[Wez, 2015/05/27 22:37:50]

Why not have a boilerplate OnDefaultPresentationStarted() method on the
PresentationFrame[Map], so you don't need GetDelegateObserver?

[haibinlu, 2015/05/28 21:44:03]

Done.

+            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(
+    const RenderFrameHostId& rfh_id,
+    const MediaSourceId& source_id) const {
+  return frame_map_->HasScreenAvailabilityListenerForTest(rfh_id, source_id);
+}
+
+}  // namespace media_router