[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);
+
   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 OnPresentationServiceDelegateDestroyed() const;
 
   void set_delegate_observer(DelegateObserver* observer) {
     delegate_observer_ = observer;
   }
 
  private:
   MediaSource GetMediaSourceFromListener(
@@ skipping 23 matching lines @@
 
 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::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 47 matching lines @@
 void PresentationFrame::Reset() {
   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();
 }
 
 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_));
 }
 
@@ skipping 34 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 {
+    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. Also resets
+  // |default_presentation_started_callback_|.
+  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_;
+
+  // Callback to invoke when default presentation has started.
+  content::PresentationSessionStartedCallback
+      default_presentation_started_callback_;
+
+  // 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->OnPresentationSessionStarted(session, route_id);
+
+  if (default_presentation_request_ &&
+      default_presentation_request_->Equals(request)) {
+    default_presentation_started_callback_.Run(session);
+  }
 }
 
 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();
+  } else {
+    DCHECK(!callback.is_null());
+
+    GURL frame_url(GetLastCommittedURLForFrame(render_frame_host_id));
+    PresentationRequest request(render_frame_host_id, default_presentation_url,
+                                frame_url);
+    default_presentation_started_callback_ = 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() {
+  default_presentation_started_callback_.Reset();
+  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