[Presentation API] 1-UA presentation support + presenter APIs.

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"
-#include "base/guid.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/create_presentation_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_router_dialog_controller.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_sink.h"
 #include "chrome/browser/media/router/media_source_helper.h"
+#include "chrome/browser/media/router/one_ua_presentation_router.h"
+#include "chrome/browser/media/router/one_ua_presentation_router_factory.h"
 #include "chrome/browser/media/router/presentation_media_sinks_observer.h"
 #include "chrome/browser/media/router/presentation_session_messages_observer.h"
 #include "chrome/browser/media/router/presentation_session_state_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 {
 
 using DelegateObserver = content::PresentationServiceDelegate::Observer;
 using PresentationSessionErrorCallback =
     content::PresentationServiceDelegate::PresentationSessionErrorCallback;
 using PresentationSessionSuccessCallback =
     content::PresentationServiceDelegate::PresentationSessionSuccessCallback;
 
-using RenderFrameHostId = std::pair<int, int>;
-
 // 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) {
@@ skipping 185 matching lines @@
   std::string availability_url(listener->GetAvailabilityUrl());
   return availability_url.empty()
              ? MediaSourceForTab(SessionTabHelper::IdForTab(web_contents_))
              : MediaSourceForPresentationUrl(availability_url);
 }
 
 // Used by PresentationServiceDelegateImpl to manage PresentationFrames.
 class PresentationFrameManager {
  public:
   PresentationFrameManager(content::WebContents* web_contents,
-                           MediaRouter* router);
+                           MediaRouter* router,
+                           OneUAPresentationRouter* one_ua_presentation_router);
   ~PresentationFrameManager();
 
   // Mirror corresponding APIs in PresentationServiceDelegateImpl.
   bool SetScreenAvailabilityListener(
       const RenderFrameHostId& render_frame_host_id,
       content::PresentationScreenAvailabilityListener* listener);
   bool RemoveScreenAvailabilityListener(
       const RenderFrameHostId& render_frame_host_id,
       content::PresentationScreenAvailabilityListener* listener);
   void SetDefaultPresentationUrl(const RenderFrameHostId& render_frame_host_id,
@@ skipping 11 matching lines @@
   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);
+      const MediaRoute::Id& route_id,
+      bool is_one_ua_presentation);
 
   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;
 
  private:
   PresentationFrame* GetOrAddPresentationFrame(
       const RenderFrameHostId& render_frame_host_id);
 
   // Maps a frame identifier to a PresentationFrame object for frames
   // that are using presentation API.
   base::ScopedPtrHashMap<RenderFrameHostId, scoped_ptr<PresentationFrame>>
       presentation_frames_;
 
-  // References to the owning WebContents, and the corresponding MediaRouter.
+  // References to the owning WebContents, and the corresponding MediaRouter
+  // and OneUAPresenationRouter.
+  content::WebContents* const web_contents_;
   MediaRouter* router_;
-  content::WebContents* web_contents_;
+  OneUAPresentationRouter* const one_ua_presentation_router_;
 };
 
 PresentationFrameManager::PresentationFrameManager(
     content::WebContents* web_contents,
-    MediaRouter* router)
-    : router_(router), web_contents_(web_contents) {
+    MediaRouter* router,
+    OneUAPresentationRouter* one_ua_presentation_router)
+    : web_contents_(web_contents),
+      router_(router),
+      one_ua_presentation_router_(one_ua_presentation_router) {
   DCHECK(web_contents_);
   DCHECK(router_);
+  DCHECK(one_ua_presentation_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) {
+    const MediaRoute::Id& route_id,
+    bool is_one_ua_presentation) {
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
-  if (presentation_frame)
+  if (presentation_frame) {
+    if (is_one_ua_presentation) {
+      one_ua_presentation_router_->RegisterController(session,
+                                                      render_frame_host_id);
+    }
     presentation_frame->OnPresentationSessionStarted(is_default_presentation,
                                                      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 78 matching lines @@
     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::Reset(
     const RenderFrameHostId& render_frame_host_id) {
+  one_ua_presentation_router_->Reset(render_frame_host_id);
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame)
     presentation_frame->Reset();
 }
 
 PresentationFrame* PresentationFrameManager::GetOrAddPresentationFrame(
     const RenderFrameHostId& render_frame_host_id) {
   if (!presentation_frames_.contains(render_frame_host_id)) {
     presentation_frames_.add(
         render_frame_host_id,
@@ skipping 14 matching lines @@
   // CreateForWebContents does nothing if the delegate instance already exists.
   PresentationServiceDelegateImpl::CreateForWebContents(web_contents);
   return PresentationServiceDelegateImpl::FromWebContents(web_contents);
 }
 
 PresentationServiceDelegateImpl::PresentationServiceDelegateImpl(
     content::WebContents* web_contents)
     : web_contents_(web_contents),
       router_(MediaRouterFactory::GetApiForBrowserContext(
           web_contents_->GetBrowserContext())),
-      frame_manager_(new PresentationFrameManager(web_contents, router_)),
+      one_ua_presentation_router_(
+          OneUAPresentationRouterFactory::GetOrCreateForBrowserContext(
+              web_contents_->GetBrowserContext())),
+      frame_manager_(new PresentationFrameManager(web_contents,
+                                                  router_,
+                                                  one_ua_presentation_router_)),
       weak_factory_(this) {
   DCHECK(web_contents_);
   DCHECK(router_);
+  DCHECK(one_ua_presentation_router_);
 }
 
 PresentationServiceDelegateImpl::~PresentationServiceDelegateImpl() {
 }
 
 void PresentationServiceDelegateImpl::AddObserver(int render_process_id,
                                                   int render_frame_id,
                                                   DelegateObserver* observer) {
   DCHECK(observer);
   frame_manager_->AddDelegateObserver(
@@ skipping 75 matching lines @@
 }
 
 void PresentationServiceDelegateImpl::OnJoinRouteResponse(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& session,
     const PresentationSessionSuccessCallback& success_cb,
     const PresentationSessionErrorCallback& error_cb,
     const MediaRoute* route,
     const std::string& presentation_id,
-    const std::string& error_text) {
+    const std::string& error_text,
+    bool is_one_ua_presentation) {
   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;
+             << ", presentation ID: " << session.presentation_id << ", 1UA? "
+             << is_one_ua_presentation;
     DCHECK_EQ(session.presentation_id, presentation_id);
-    frame_manager_->OnPresentationSessionStarted(
-        RenderFrameHostId(render_process_id, render_frame_id), false, session,
-        route->media_route_id());
+    RenderFrameHostId rfh_id(render_process_id, render_frame_id);
+    frame_manager_->OnPresentationSessionStarted(rfh_id, false, session,
+                                                 route->media_route_id(),
+                                                 is_one_ua_presentation);
     success_cb.Run(session);
   }
 }
 
 void PresentationServiceDelegateImpl::OnStartSessionSucceeded(
     int render_process_id,
     int render_frame_id,
     const PresentationSessionSuccessCallback& success_cb,
     const content::PresentationSessionInfo& new_session,
-    const MediaRoute::Id& route_id) {
+    const MediaRoute::Id& route_id,
+    bool is_one_ua_presentation) {
   DVLOG(1) << "OnStartSessionSucceeded: "
            << "route_id: " << route_id
            << ", presentation URL: " << new_session.presentation_url
            << ", presentation ID: " << new_session.presentation_id;
+  RenderFrameHostId rfh_id(render_process_id, render_frame_id);
   frame_manager_->OnPresentationSessionStarted(
-      RenderFrameHostId(render_process_id, render_frame_id), false, new_session,
-      route_id);
+      rfh_id, false, new_session, route_id, is_one_ua_presentation);
   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) {
   if (presentation_url.empty() || !IsValidPresentationUrl(presentation_url)) {
@@ skipping 52 matching lines @@
     return;
   }
   router_->CloseRoute(route_id);
 }
 
 void PresentationServiceDelegateImpl::ListenForSessionMessages(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& session,
     const content::PresentationSessionMessageCallback& message_cb) {
-  frame_manager_->ListenForSessionMessages(
-      RenderFrameHostId(render_process_id, render_frame_id), session,
-      message_cb);
+  DCHECK(!session.presentation_id.empty());
+  DCHECK(!session.presentation_url.empty());
+
+  RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
+  if (one_ua_presentation_router_->IsController(session.presentation_id,
+                                                render_frame_host_id)) {
+    // 1-UA session; listen for messages with OneUAPresentationRouter.
+    one_ua_presentation_router_->ListenForMessages(session, message_cb);
+  } else {
+    // Non 1-UA session; listen for messages with MediaRouter.
+    frame_manager_->ListenForSessionMessages(render_frame_host_id, session,
+                                             message_cb);
+  }
 }
 
 void PresentationServiceDelegateImpl::SendMessage(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& session,
     scoped_ptr<content::PresentationSessionMessage> message,
-    const SendMessageCallback& send_message_cb) {
-  const MediaRoute::Id& route_id = frame_manager_->GetRouteId(
-      RenderFrameHostId(render_process_id, render_frame_id),
-      session.presentation_id);
+    const content::SendMessageCallback& send_message_cb) {
+  DCHECK(!session.presentation_id.empty());
+  DCHECK(!session.presentation_url.empty());
+
+  RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
+  const MediaRoute::Id& route_id =
+      frame_manager_->GetRouteId(render_frame_host_id, session.presentation_id);
   if (route_id.empty()) {
     DVLOG(1) << "No active route for  " << session.presentation_id;
     send_message_cb.Run(false);
     return;
   }
 
-  if (message->is_binary()) {
-    router_->SendRouteBinaryMessage(route_id, message->data.Pass(),
-                                    send_message_cb);
+  if (one_ua_presentation_router_->IsController(session.presentation_id,
+                                                render_frame_host_id)) {
+    // 1-UA session; send message with OneUAPresentationRouter.
+    one_ua_presentation_router_->SendMessage(session, message.Pass(),
+                                             send_message_cb);
   } else {
-    router_->SendRouteMessage(route_id, message->message, send_message_cb);
+    // Non 1-UA session; send message with MediaRouter.
+    if (message->is_binary()) {
+      router_->SendRouteBinaryMessage(route_id, message->data.Pass(),
+                                      send_message_cb);
+    } else {
+      router_->SendRouteMessage(route_id, message->message, send_message_cb);
+    }
   }
 }
 
 void PresentationServiceDelegateImpl::ListenForSessionStateChange(
     int render_process_id,
     int render_frame_id,
     const content::SessionStateChangedCallback& state_changed_cb) {
+  // TODO(imcheng): Implement 1-UA controller state change when
+  // ListenForSessionStateChange takes a PresentationSessionInfo as input.
   frame_manager_->ListenForSessionStateChange(
       RenderFrameHostId(render_process_id, render_frame_id), state_changed_cb);
 }
 
+void PresentationServiceDelegateImpl::GetPresenterSession(
+    int render_process_id,
+    int render_frame_id,
+    const content::PresenterSessionAvailableCallback& success_callback,
+    const base::Callback<void(const std::string&)>& error_callback) {
+  // We only have presenters in offscreen tabs, which are created in incognito
+  // Profiles. See IncognitoPresentationServiceDelegate.
+  NOTIMPLEMENTED();
+  error_callback.Run("Not a presenter frame");
+}
+
+std::vector<content::PresentationSessionInfo>
+PresentationServiceDelegateImpl::GetPresenterSessions(int render_process_id,
+                                                      int render_frame_id) {
+  // See comment on GetPresentersession().
+  NOTIMPLEMENTED();
+  return std::vector<content::PresentationSessionInfo>();
+}
+
 void PresentationServiceDelegateImpl::OnRouteResponse(
     const MediaRoute* route,
     const std::string& presentation_id,
-    const std::string& error) {
+    const std::string& error,
+    bool is_one_ua_presentation) {
   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(
+      PresentationUrlFromMediaSource(source), presentation_id);
+
+  frame_manager_->OnPresentationSessionStarted(render_frame_host_id, true,
+                                               session, route->media_route_id(),
+                                               is_one_ua_presentation);
 }
 
 void PresentationServiceDelegateImpl::AddDefaultMediaSourceObserver(
     DefaultMediaSourceObserver* observer) {
   default_media_source_observers_.AddObserver(observer);
 }
 
 void PresentationServiceDelegateImpl::RemoveDefaultMediaSourceObserver(
     DefaultMediaSourceObserver* observer) {
   default_media_source_observers_.RemoveObserver(observer);
@@ skipping 13 matching lines @@
 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