[Presentation API / Media Router] Clean up default pres URL logic.

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/containers/small_map.h"
@@ skipping 19 matching lines @@
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(
     media_router::PresentationServiceDelegateImpl);
 
 using content::RenderFrameHost;
 
 namespace media_router {
 
 namespace {
 
 using DelegateObserver = content::PresentationServiceDelegate::Observer;
-using PresentationSessionErrorCallback =
-    content::PresentationServiceDelegate::PresentationSessionErrorCallback;
-using PresentationSessionSuccessCallback =
-    content::PresentationServiceDelegate::PresentationSessionSuccessCallback;
-
-// Returns the unique identifier for the supplied RenderFrameHost.
-RenderFrameHostId GetRenderFrameHostId(RenderFrameHost* render_frame_host) {
-  int render_process_id = render_frame_host->GetProcess()->GetID();
-  int render_frame_id = render_frame_host->GetRoutingID();
-  return RenderFrameHostId(render_process_id, render_frame_id);
-}
 
 // Gets the last committed URL for the render frame specified by
 // |render_frame_host_id|.
 GURL GetLastCommittedURLForFrame(RenderFrameHostId render_frame_host_id) {
   RenderFrameHost* render_frame_host = RenderFrameHost::FromID(
       render_frame_host_id.first, render_frame_host_id.second);
   DCHECK(render_frame_host);
   return render_frame_host->GetLastCommittedURL();
 }
 
@@ skipping 16 matching lines @@
   bool RemoveScreenAvailabilityListener(
       content::PresentationScreenAvailabilityListener* listener);
   bool HasScreenAvailabilityListenerForTest(
       const MediaSource::Id& source_id) const;
   std::string GetDefaultPresentationId() const;
   void ListenForSessionStateChange(
       const content::SessionStateChangedCallback& state_changed_cb);
   void ListenForSessionMessages(
       const content::PresentationSessionInfo& session,
       const content::PresentationSessionMessageCallback& message_cb);
+
+  // Sets this frame's default prsentation request and callback.

[mark a. foltz, 2015/10/20 20:15:25]

Typo in presentation request.

Also a slight preference to use the term "PresentationRequest" since there's an
API object that matches this concept.

[imcheng, 2015/10/24 00:41:19]

Done.

+  void SetDefaultPresentationRequest(
+      const PresentationRequest& default_presentation_request,
+      const content::PresentationSessionStartedCallback& callback);
+
+  // Clear this frame's default prsentation request and callback.

[mark a. foltz, 2015/10/20 20:15:25]

Typo here

[imcheng, 2015/10/24 00:41:19]

Done.

+  void ClearDefaultPresentationRequest();
   void Reset();
 
   const MediaRoute::Id GetRouteId(const std::string& presentation_id) const;
   const std::vector<MediaRoute::Id> GetRouteIds() const;
   void OnPresentationSessionClosed(const std::string& presentation_id);
 
   void OnPresentationSessionStarted(
-      bool is_default_presentation,
+      const content::PresentationSessionInfo& session,
+      const MediaRoute::Id& route_id);
+  void OnDefaultPresentationSessionStarted(

[mark a. foltz, 2015/10/20 20:15:25]

I wonder if this class needs to expose two different code paths for starting
presentation connections (one via .start() and one via the default request).  In
either case you are going to fire a connectionavailable event on the
PresentationRequest; the difference is that you also need to resolve a pending
Promise in response to start().  Blink could use the presentation URL returned
with the connection to match up to the Promise.

Maybe this is the cleanest way w.r.t. Mojo, since start() will have a pending
Mojo callback and the default request will not.

[imcheng, 2015/10/24 00:41:19]

This is motivated by the need to pass in a callback from PSImpl to PSDImpl when
the default PresentationRequest is set, so that PSDImpl can notify PSImpl when
the default PresentationRequest is initiated from the browser.

If there is a default PresentationRequest set, and the page calls
defaultRequest.start() and succeeds, then we only answer the pending callback
from StartSession() not the default_presentation_started_callback_ so we don't
fire connectionavailable twice.

+      const PresentationRequest& request,
       const content::PresentationSessionInfo& session,
       const MediaRoute::Id& route_id);
   void OnPresentationServiceDelegateDestroyed() const;
 
   void set_delegate_observer(DelegateObserver* observer) {
     delegate_observer_ = observer;
   }
 
  private:
   MediaSource GetMediaSourceFromListener(
       content::PresentationScreenAvailabilityListener* listener) const;
   MediaRouteIdToPresentationSessionMapping route_id_to_presentation_;
   base::SmallMap<std::map<std::string, MediaRoute::Id>>
       presentation_id_to_route_id_;
   scoped_ptr<PresentationMediaSinksObserver> sinks_observer_;
   scoped_ptr<PresentationSessionStateObserver> session_state_observer_;
   ScopedVector<PresentationSessionMessagesObserver> session_messages_observers_;
 
+  // Default presentation request for this frame, if any.
+  scoped_ptr<PresentationRequest> default_presentation_request_;
+
+  // Callback to invoke when default presentation has started.
+  content::PresentationSessionStartedCallback
+      default_presentation_started_callback_;
+
   // References to the owning WebContents, and the corresponding MediaRouter.
   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() {
 }
 
 void PresentationFrame::OnPresentationServiceDelegateDestroyed() const {
   if (delegate_observer_)
     delegate_observer_->OnDelegateDestroyed();
 }
 
 void PresentationFrame::OnPresentationSessionStarted(
-    bool is_default_presentation,
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
   presentation_id_to_route_id_[session.presentation_id] = route_id;
   route_id_to_presentation_.Add(route_id, session);
   if (session_state_observer_)
     session_state_observer_->OnPresentationSessionConnected(route_id);
-  if (is_default_presentation && delegate_observer_)
-    delegate_observer_->OnDefaultPresentationStarted(session);
+}
+
+void PresentationFrame::OnDefaultPresentationSessionStarted(

[mark a. foltz, 2015/10/20 20:15:25]

Is this called only for browser initiated requests, or also in response to
presentation.defaultRequest.start()?

[imcheng, 2015/10/24 00:41:19]

Only for browser initiated requests.

+    const PresentationRequest& request,
+    const content::PresentationSessionInfo& session,
+    const MediaRoute::Id& route_id) {
+  OnPresentationSessionStarted(session, route_id);
+  if (default_presentation_request_ &&
+      default_presentation_request_->Equals(request)) {
+    default_presentation_started_callback_.Run(session);
+  }
 }
 
 void PresentationFrame::OnPresentationSessionClosed(
     const std::string& presentation_id) {
   auto it = presentation_id_to_route_id_.find(presentation_id);
   if (it != presentation_id_to_route_id_.end()) {
     route_id_to_presentation_.Remove(it->second);
     presentation_id_to_route_id_.erase(it);
   }
   // TODO(imcheng): Notify |session_state_observer_|?
@@ skipping 48 matching lines @@
   route_id_to_presentation_.Clear();
 
   for (const auto& pid_route_id : presentation_id_to_route_id_)
     router_->OnPresentationSessionDetached(pid_route_id.second);
 
   presentation_id_to_route_id_.clear();
   sinks_observer_.reset();
   if (session_state_observer_)
     session_state_observer_->Reset();
   session_messages_observers_.clear();
+

[mark a. foltz, 2015/10/20 20:15:25]

Extra newline

[imcheng, 2015/10/24 00:41:19]

Ok. But added a new line after L228 for the if block.

+  ClearDefaultPresentationRequest();
 }
 
 void PresentationFrame::ListenForSessionStateChange(
     const content::SessionStateChangedCallback& state_changed_cb) {
   CHECK(!session_state_observer_.get());
   session_state_observer_.reset(new PresentationSessionStateObserver(
       state_changed_cb, &route_id_to_presentation_, router_));
 }
 
 void PresentationFrame::ListenForSessionMessages(
     const content::PresentationSessionInfo& session,
     const content::PresentationSessionMessageCallback& message_cb) {
   auto it = presentation_id_to_route_id_.find(session.presentation_id);
   if (it == presentation_id_to_route_id_.end()) {
     DVLOG(2) << "ListenForSessionMessages: no route for "
              << session.presentation_id;
     return;
   }
 
   session_messages_observers_.push_back(
       new PresentationSessionMessagesObserver(message_cb, it->second, router_));
 }
 
+void PresentationFrame::SetDefaultPresentationRequest(
+    const PresentationRequest& default_presentation_request,
+    const content::PresentationSessionStartedCallback& callback) {
+  default_presentation_started_callback_ = callback;

[mark a. foltz, 2015/10/20 20:15:25]

Do we need to reset default_presentation_started_callback_ first?  Maybe this
should call ClearDefaultPresentationRequest().

Or, it seems like a single callback is re-used for multiple calls to start the
default request.
Maybe setting the callback and the default request should be separate?

[imcheng, 2015/10/24 00:41:19]

The Equals check below is just an optimization. There's no need to reset
default_presentation_started_callback_ first. Both the callback and the request
can be reused so there's no need to clear them after defaultRequest has been
triggered.

+  if (!default_presentation_request_ ||
+      !default_presentation_request_->Equals(default_presentation_request)) {
+    default_presentation_request_.reset(
+        new PresentationRequest(default_presentation_request));
+  }
+}
+
+void PresentationFrame::ClearDefaultPresentationRequest() {
+  default_presentation_request_.reset();
+  default_presentation_started_callback_.Reset();
+}
+
 MediaSource PresentationFrame::GetMediaSourceFromListener(
     content::PresentationScreenAvailabilityListener* listener) const {
   // If the default presentation URL is empty then fall back to tab mirroring.
   std::string availability_url(listener->GetAvailabilityUrl());
   return availability_url.empty()
              ? MediaSourceForTab(SessionTabHelper::IdForTab(web_contents_))
              : MediaSourceForPresentationUrl(availability_url);
 }
 
 // Used by PresentationServiceDelegateImpl to manage PresentationFrames.
@@ skipping 10 matching lines @@
   bool RemoveScreenAvailabilityListener(
       const RenderFrameHostId& render_frame_host_id,
       content::PresentationScreenAvailabilityListener* listener);
   void ListenForSessionStateChange(
       const RenderFrameHostId& render_frame_host_id,
       const content::SessionStateChangedCallback& state_changed_cb);
   void ListenForSessionMessages(
       const RenderFrameHostId& render_frame_host_id,
       const content::PresentationSessionInfo& session,
       const content::PresentationSessionMessageCallback& message_cb);
+
+  // Sets or clears the default presentation request and callback for the given
+  // frame. Also sets / clears the default presentation requests for the owning
+  // tab WebContents.
+  void SetDefaultPresentationUrl(
+      const RenderFrameHostId& render_frame_host_id,
+      const std::string& default_presentation_url,
+      const content::PresentationSessionStartedCallback& callback);
   void AddDelegateObserver(const RenderFrameHostId& render_frame_host_id,
                            DelegateObserver* observer);
   void RemoveDelegateObserver(const RenderFrameHostId& render_frame_host_id);
+  void AddDefaultPresentationRequestObserver(
+      PresentationServiceDelegateImpl::DefaultPresentationRequestObserver*
+          observer);
+  void RemoveDefaultPresentationRequestObserver(
+      PresentationServiceDelegateImpl::DefaultPresentationRequestObserver*
+          observer);
   void Reset(const RenderFrameHostId& render_frame_host_id);
   bool HasScreenAvailabilityListenerForTest(
       const RenderFrameHostId& render_frame_host_id,
       const MediaSource::Id& source_id) const;
   void SetMediaRouterForTest(MediaRouter* router);
 
   void OnPresentationSessionStarted(
       const RenderFrameHostId& render_frame_host_id,
-      bool is_default_presentation,
+      const content::PresentationSessionInfo& session,
+      const MediaRoute::Id& route_id);
+  void OnDefaultPresentationSessionStarted(
+      const PresentationRequest& request,
       const content::PresentationSessionInfo& session,
       const MediaRoute::Id& route_id);
 
   void OnPresentationSessionClosed(
       const RenderFrameHostId& render_frame_host_id,
       const std::string& presentation_id);
   const MediaRoute::Id GetRouteId(const RenderFrameHostId& render_frame_host_id,
                                   const std::string& presentation_id) const;
   const std::vector<MediaRoute::Id> GetRouteIds(
       const RenderFrameHostId& render_frame_host_id) const;
 
+  const PresentationRequest* default_presentation_request() const {

[mark a. foltz, 2015/10/20 20:15:25]

Which request is this returning?  Isn't there potentially one per frame?

[imcheng, 2015/10/24 00:41:19]

This returns the "tab-level" default presentation request, which is specific for
our ui.

As you mentioned, how default requests from child frames remains unspecified in
the spec. Before this patch we only consider the the default request from the
main frame to be the tab-level default request. This is too restrictive because
some sites (as documented in internal bug) use an iframe to set the default
request, which would get ignored by our algorithm.

The new patch defines tab-level default request as the latest default request
that was set on this tab. This will solve the issue. The only complication I can
think of is if more than one frame sets the default request, but that should be
unlikely.

+    return default_presentation_request_.get();
+  }
+
  private:
   PresentationFrame* GetOrAddPresentationFrame(
       const RenderFrameHostId& render_frame_host_id);
 
+  // Sets the default presentation request for the owning WebContents and
+  // notifies observers of changes.
+  void SetDefaultPresentationRequest(
+      const PresentationRequest& default_presentation_request);
+
+  // Clears the default presentation request for the owning WebContents and
+  // notifies observers of changes.
+  void ClearDefaultPresentationRequest();
+
   // Maps a frame identifier to a PresentationFrame object for frames
   // that are using presentation API.
   base::ScopedPtrHashMap<RenderFrameHostId, scoped_ptr<PresentationFrame>>
       presentation_frames_;
 
+  // Default presentation request for the owning tab WebContents.
+  scoped_ptr<PresentationRequest> default_presentation_request_;
+
+  // References to the observers listening for changes to this tab WebContent's
+  // default presentation.
+  base::ObserverList<
+      PresentationServiceDelegateImpl::DefaultPresentationRequestObserver>
+      default_presentation_request_observers_;
+
   // References to the owning WebContents, and the corresponding MediaRouter.
   MediaRouter* router_;
   content::WebContents* web_contents_;
 };
 
 PresentationFrameManager::PresentationFrameManager(
     content::WebContents* web_contents,
     MediaRouter* router)
     : router_(router), web_contents_(web_contents) {
   DCHECK(web_contents_);
   DCHECK(router_);
 }
 
 PresentationFrameManager::~PresentationFrameManager() {
   for (auto& frame : presentation_frames_)
     frame.second->OnPresentationServiceDelegateDestroyed();
 }
 
 void PresentationFrameManager::OnPresentationSessionStarted(
     const RenderFrameHostId& render_frame_host_id,
-    bool is_default_presentation,
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame)
-    presentation_frame->OnPresentationSessionStarted(is_default_presentation,
-                                                     session, route_id);
+    presentation_frame->OnPresentationSessionStarted(session, route_id);
+}
+
+void PresentationFrameManager::OnDefaultPresentationSessionStarted(
+    const PresentationRequest& request,
+    const content::PresentationSessionInfo& session,
+    const MediaRoute::Id& route_id) {
+  auto presentation_frame =
+      presentation_frames_.get(request.render_frame_host_id());
+  if (presentation_frame)
+    presentation_frame->OnDefaultPresentationSessionStarted(request, session,
+                                                            route_id);
 }
 
 void PresentationFrameManager::OnPresentationSessionClosed(
     const RenderFrameHostId& render_frame_host_id,
     const std::string& presentation_id) {
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame)
     presentation_frame->OnPresentationSessionClosed(presentation_id);
 }
 
@@ skipping 53 matching lines @@
       presentation_frames_.get(render_frame_host_id);
   if (!presentation_frame) {
     DVLOG(2) << "ListenForSessionMessages: PresentationFrame does not exist "
              << "for: (" << render_frame_host_id.first << ", "
              << render_frame_host_id.second << ")";
     return;
   }
   presentation_frame->ListenForSessionMessages(session, message_cb);
 }
 
+void PresentationFrameManager::SetDefaultPresentationUrl(
+    const RenderFrameHostId& render_frame_host_id,
+    const std::string& default_presentation_url,
+    const content::PresentationSessionStartedCallback& callback) {
+  PresentationFrame* presentation_frame =
+      GetOrAddPresentationFrame(render_frame_host_id);
+  if (default_presentation_url.empty()) {
+    ClearDefaultPresentationRequest();

[mark a. foltz, 2015/10/20 20:15:25]

This design keeps track of default requests at two levels: the WebContents level
and the frame level.  It seems a little redundant?

The PresentationFrameManager could keep track of the RenderFrameHostId for the
top level document, and use that to set and retrieve the default request (if
any) for it.

[imcheng, 2015/10/24 00:41:19]

This patch fixes the issue where the default request is not set at the top level
document. It does so by changing the tab-level default request algorithm to also
consider defaultRequest from other frames (i.e., whichever frame-level
defaultRequest is seen last is the tab-level default request)

I was thinking in the future we could consider enumerating all default requests
in our ui, which is why I also added frame-level tracking. I removed it for the
time being and moved the callback logic to PFM.

+    presentation_frame->ClearDefaultPresentationRequest();
+  } else {
+    DCHECK(!callback.is_null());
+
+    GURL frame_url(GetLastCommittedURLForFrame(render_frame_host_id));
+    PresentationRequest request(render_frame_host_id, default_presentation_url,
+                                frame_url);
+    presentation_frame->SetDefaultPresentationRequest(request, callback);
+    SetDefaultPresentationRequest(request);
+  }
+}
+
 void PresentationFrameManager::AddDelegateObserver(
     const RenderFrameHostId& render_frame_host_id,
     DelegateObserver* observer) {
   auto presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
   presentation_frame->set_delegate_observer(observer);
 }
 
 void PresentationFrameManager::RemoveDelegateObserver(
     const RenderFrameHostId& render_frame_host_id) {
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame) {
     presentation_frame->set_delegate_observer(nullptr);
     presentation_frames_.erase(render_frame_host_id);
   }
 }
 
+void PresentationFrameManager::AddDefaultPresentationRequestObserver(
+    PresentationServiceDelegateImpl::DefaultPresentationRequestObserver*
+        observer) {
+  default_presentation_request_observers_.AddObserver(observer);
+}
+
+void PresentationFrameManager::RemoveDefaultPresentationRequestObserver(
+    PresentationServiceDelegateImpl::DefaultPresentationRequestObserver*
+        observer) {
+  default_presentation_request_observers_.RemoveObserver(observer);
+}
+
 void PresentationFrameManager::Reset(
     const RenderFrameHostId& render_frame_host_id) {
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame)
     presentation_frame->Reset();
+
+  if (default_presentation_request_ &&
+      render_frame_host_id ==
+          default_presentation_request_->render_frame_host_id()) {
+    ClearDefaultPresentationRequest();
+  }
 }
 
 PresentationFrame* PresentationFrameManager::GetOrAddPresentationFrame(
     const RenderFrameHostId& render_frame_host_id) {
   if (!presentation_frames_.contains(render_frame_host_id)) {
     presentation_frames_.add(
         render_frame_host_id,
         scoped_ptr<PresentationFrame>(
             new PresentationFrame(web_contents_, router_)));
   }
   return presentation_frames_.get(render_frame_host_id);
 }
 
+void PresentationFrameManager::ClearDefaultPresentationRequest() {
+  if (!default_presentation_request_)
+    return;
+
+  default_presentation_request_.reset();
+  FOR_EACH_OBSERVER(
+      PresentationServiceDelegateImpl::DefaultPresentationRequestObserver,
+      default_presentation_request_observers_,
+      OnDefaultPresentationChanged(nullptr));
+}
+
+void PresentationFrameManager::SetDefaultPresentationRequest(
+    const PresentationRequest& default_presentation_request) {
+  if (default_presentation_request_ &&
+      default_presentation_request_->Equals(default_presentation_request))
+    return;
+
+  default_presentation_request_.reset(
+      new PresentationRequest(default_presentation_request));
+  FOR_EACH_OBSERVER(
+      PresentationServiceDelegateImpl::DefaultPresentationRequestObserver,
+      default_presentation_request_observers_,
+      OnDefaultPresentationChanged(default_presentation_request_.get()));
+}
+
 void PresentationFrameManager::SetMediaRouterForTest(MediaRouter* router) {
   router_ = router;
 }
 
 PresentationServiceDelegateImpl*
 PresentationServiceDelegateImpl::GetOrCreateForWebContents(
     content::WebContents* web_contents) {
   DCHECK(web_contents);
   // CreateForWebContents does nothing if the delegate instance already exists.
   PresentationServiceDelegateImpl::CreateForWebContents(web_contents);
@@ skipping 43 matching lines @@
     content::PresentationScreenAvailabilityListener* listener) {
   DCHECK(listener);
   frame_manager_->RemoveScreenAvailabilityListener(
       RenderFrameHostId(render_process_id, render_frame_id), listener);
 }
 
 void PresentationServiceDelegateImpl::Reset(int render_process_id,
                                             int render_frame_id) {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
   frame_manager_->Reset(render_frame_host_id);
-  if (render_frame_host_id == default_presentation_render_frame_host_id_) {
-    UpdateDefaultMediaSourceAndNotifyObservers(RenderFrameHostId(),
-                                               MediaSource(), GURL());
-  }
 }
 
 void PresentationServiceDelegateImpl::SetDefaultPresentationUrl(
     int render_process_id,
     int render_frame_id,
-    const std::string& default_presentation_url) {
+    const std::string& default_presentation_url,
+    const content::PresentationSessionStartedCallback& callback) {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
-  if (IsMainFrame(render_process_id, render_frame_id)) {
-    // This is the main frame, which means tab-level default presentation
-    // might have been updated.
-    MediaSource default_source;
-    if (!default_presentation_url.empty())
-      default_source = MediaSourceForPresentationUrl(default_presentation_url);
-
-    GURL default_frame_url = GetLastCommittedURLForFrame(render_frame_host_id);
-    UpdateDefaultMediaSourceAndNotifyObservers(
-        render_frame_host_id, default_source, default_frame_url);
-  }
-}
-
-bool PresentationServiceDelegateImpl::IsMainFrame(int render_process_id,
-                                                  int render_frame_id) const {
-  RenderFrameHost* main_frame = web_contents_->GetMainFrame();
-  return main_frame &&
-         GetRenderFrameHostId(main_frame) ==
-             RenderFrameHostId(render_process_id, render_frame_id);
-}
-
-void PresentationServiceDelegateImpl::
-    UpdateDefaultMediaSourceAndNotifyObservers(
-        const RenderFrameHostId& render_frame_host_id,
-        const MediaSource& new_default_source,
-        const GURL& new_default_frame_url) {
-  default_presentation_render_frame_host_id_ = render_frame_host_id;
-  if (!new_default_source.Equals(default_source_) ||
-      new_default_frame_url != default_frame_url_) {
-    default_source_ = new_default_source;
-    default_frame_url_ = new_default_frame_url;
-    FOR_EACH_OBSERVER(
-        DefaultMediaSourceObserver, default_media_source_observers_,
-        OnDefaultMediaSourceChanged(default_source_, default_frame_url_));
-  }
+  frame_manager_->SetDefaultPresentationUrl(render_frame_host_id,
+                                            default_presentation_url, callback);
 }
 
 void PresentationServiceDelegateImpl::OnJoinRouteResponse(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& session,
-    const PresentationSessionSuccessCallback& success_cb,
-    const PresentationSessionErrorCallback& error_cb,
+    const content::PresentationSessionStartedCallback& success_cb,
+    const content::PresentationSessionErrorCallback& error_cb,
     const MediaRoute* route,
     const std::string& presentation_id,
     const std::string& error_text) {
   if (!route) {
     error_cb.Run(content::PresentationError(
         content::PRESENTATION_ERROR_NO_PRESENTATION_FOUND, error_text));
   } else {
     DVLOG(1) << "OnJoinRouteResponse: "
              << "route_id: " << route->media_route_id()
              << ", presentation URL: " << session.presentation_url
              << ", presentation ID: " << session.presentation_id;
     DCHECK_EQ(session.presentation_id, presentation_id);
     frame_manager_->OnPresentationSessionStarted(
-        RenderFrameHostId(render_process_id, render_frame_id), false, session,
+        RenderFrameHostId(render_process_id, render_frame_id), session,
         route->media_route_id());
     success_cb.Run(session);
   }
 }
 
 void PresentationServiceDelegateImpl::OnStartSessionSucceeded(
     int render_process_id,
     int render_frame_id,
-    const PresentationSessionSuccessCallback& success_cb,
+    const content::PresentationSessionStartedCallback& success_cb,
     const content::PresentationSessionInfo& new_session,
     const MediaRoute::Id& route_id) {
   DVLOG(1) << "OnStartSessionSucceeded: "
            << "route_id: " << route_id
            << ", presentation URL: " << new_session.presentation_url
            << ", presentation ID: " << new_session.presentation_id;
   frame_manager_->OnPresentationSessionStarted(
-      RenderFrameHostId(render_process_id, render_frame_id), false, new_session,
+      RenderFrameHostId(render_process_id, render_frame_id), new_session,
       route_id);
   success_cb.Run(new_session);
 }
 
 void PresentationServiceDelegateImpl::StartSession(
     int render_process_id,
     int render_frame_id,
     const std::string& presentation_url,
-    const PresentationSessionSuccessCallback& success_cb,
-    const PresentationSessionErrorCallback& error_cb) {
+    const content::PresentationSessionStartedCallback& success_cb,
+    const content::PresentationSessionErrorCallback& error_cb) {
   if (presentation_url.empty() || !IsValidPresentationUrl(presentation_url)) {
     error_cb.Run(content::PresentationError(content::PRESENTATION_ERROR_UNKNOWN,
                                             "Invalid presentation arguments."));
     return;
   }
+
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
-
   scoped_ptr<CreatePresentationSessionRequest> context(
       new CreatePresentationSessionRequest(
-          presentation_url, GetLastCommittedURLForFrame(render_frame_host_id),
+          render_frame_host_id, presentation_url,
+          GetLastCommittedURLForFrame(render_frame_host_id),
           base::Bind(&PresentationServiceDelegateImpl::OnStartSessionSucceeded,
                      weak_factory_.GetWeakPtr(), render_process_id,
                      render_frame_id, success_cb),
           error_cb));
   MediaRouterDialogController* controller =
       MediaRouterDialogController::GetOrCreateForWebContents(web_contents_);
   if (!controller->ShowMediaRouterDialogForPresentation(context.Pass())) {
     LOG(ERROR) << "Media router dialog already exists. Ignoring StartSession.";
     error_cb.Run(content::PresentationError(content::PRESENTATION_ERROR_UNKNOWN,
                                             "Unable to create dialog."));
     return;
   }
 }
 
 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) {
+    const content::PresentationSessionStartedCallback& success_cb,
+    const content::PresentationSessionErrorCallback& error_cb) {
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &PresentationServiceDelegateImpl::OnJoinRouteResponse,
       weak_factory_.GetWeakPtr(), render_process_id, render_frame_id,
       content::PresentationSessionInfo(presentation_url, presentation_id),
       success_cb, error_cb));
   router_->JoinRoute(
       MediaSourceForPresentationUrl(presentation_url).id(), presentation_id,
       GetLastCommittedURLForFrame(
           RenderFrameHostId(render_process_id, render_frame_id))
@@ skipping 49 matching lines @@
 
 void PresentationServiceDelegateImpl::ListenForSessionStateChange(
     int render_process_id,
     int render_frame_id,
     const content::SessionStateChangedCallback& state_changed_cb) {
   frame_manager_->ListenForSessionStateChange(
       RenderFrameHostId(render_process_id, render_frame_id), state_changed_cb);
 }
 
 void PresentationServiceDelegateImpl::OnRouteResponse(
+    const PresentationRequest& presentation_request,
     const MediaRoute* route,
     const std::string& presentation_id,
     const std::string& error) {
   if (!route)
     return;
-  const MediaSource& source = route->media_source();
-  DCHECK(!source.Empty());
-  if (!default_source_.Equals(source))
-    return;
-  RenderFrameHost* main_frame = web_contents_->GetMainFrame();
-  if (!main_frame)
-    return;
-  RenderFrameHostId render_frame_host_id(GetRenderFrameHostId(main_frame));
-  frame_manager_->OnPresentationSessionStarted(
-      render_frame_host_id, true,
-      content::PresentationSessionInfo(PresentationUrlFromMediaSource(source),
-                                       presentation_id),
-      route->media_route_id());
+
+  content::PresentationSessionInfo session_info(
+      presentation_request.presentation_url(), presentation_id);
+  frame_manager_->OnDefaultPresentationSessionStarted(
+      presentation_request, session_info, route->media_route_id());
 }
 
-void PresentationServiceDelegateImpl::AddDefaultMediaSourceObserver(
-    DefaultMediaSourceObserver* observer) {
-  default_media_source_observers_.AddObserver(observer);
+void PresentationServiceDelegateImpl::AddDefaultPresentationRequestObserver(
+    DefaultPresentationRequestObserver* observer) {
+  frame_manager_->AddDefaultPresentationRequestObserver(observer);
 }
 
-void PresentationServiceDelegateImpl::RemoveDefaultMediaSourceObserver(
-    DefaultMediaSourceObserver* observer) {
-  default_media_source_observers_.RemoveObserver(observer);
+void PresentationServiceDelegateImpl::RemoveDefaultPresentationRequestObserver(
+    DefaultPresentationRequestObserver* observer) {
+  frame_manager_->RemoveDefaultPresentationRequestObserver(observer);
+}
+
+const PresentationRequest*
+PresentationServiceDelegateImpl::GetDefaultPresentationRequest() const {
+  return frame_manager_->default_presentation_request();
 }
 
 base::WeakPtr<PresentationServiceDelegateImpl>
 PresentationServiceDelegateImpl::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 void PresentationServiceDelegateImpl::SetMediaRouterForTest(
     MediaRouter* router) {
   router_ = router;
   frame_manager_->SetMediaRouterForTest(router);
 }
 
 bool PresentationServiceDelegateImpl::HasScreenAvailabilityListenerForTest(
     int render_process_id,
     int render_frame_id,
     const MediaSource::Id& source_id) const {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
   return frame_manager_->HasScreenAvailabilityListenerForTest(
       render_frame_host_id, source_id);
 }
 
 }  // namespace media_router