[Presentation API] (3rd) (1-UA) Split PresentationServiceDelegateImpl(PSDImpl)

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 <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/containers/small_map.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/create_presentation_connection_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/offscreen_presentation_manager.h"
+#include "chrome/browser/media/router/offscreen_presentation_manager_factory.h"
 #include "chrome/browser/media/router/presentation_media_sinks_observer.h"
 #include "chrome/browser/media/router/route_message.h"
 #include "chrome/browser/media/router/route_message_observer.h"
 #include "chrome/browser/media/router/route_request_result.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "content/public/browser/browser_context.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"
+#include "url/gurl.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(
     media_router::PresentationServiceDelegateImpl);
 
 using content::RenderFrameHost;
 
 namespace media_router {
 
 namespace {
 
-using DelegateObserver = content::PresentationServiceDelegate::Observer;
+using DelegateObserver = content::PresentationServiceDelegateBase::Observer;
 
 // 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|.
@@ skipping 83 matching lines @@
   void Reset();
   void RemoveConnection(const std::string& presentation_id,
                         const MediaRoute::Id& route_id);
 
   const MediaRoute::Id GetRouteId(const std::string& presentation_id) const;
   const std::vector<MediaRoute::Id> GetRouteIds() const;
 
   void OnPresentationSessionStarted(
       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;
   base::SmallMap<std::map<std::string, MediaRoute::Id>>
       presentation_id_to_route_id_;
   base::SmallMap<
       std::map<std::string, std::unique_ptr<PresentationMediaSinksObserver>>>
       url_to_sinks_observer_;
   std::unordered_map<
       MediaRoute::Id,
       std::unique_ptr<PresentationConnectionStateSubscription>>
       connection_state_subscriptions_;
   std::unordered_map<
       MediaRoute::Id,
       std::unique_ptr<PresentationSessionMessagesObserver>>
       session_messages_observers_;
 
   RenderFrameHostId render_frame_host_id_;
 
   // References to the owning WebContents, and the corresponding MediaRouter.
   const content::WebContents* web_contents_;
   MediaRouter* router_;
-
-  DelegateObserver* delegate_observer_;
 };
 
 PresentationFrame::PresentationFrame(
     const RenderFrameHostId& render_frame_host_id,
     content::WebContents* web_contents,
     MediaRouter* router)
     : render_frame_host_id_(render_frame_host_id),
       web_contents_(web_contents),
-      router_(router),
-      delegate_observer_(nullptr) {
+      router_(router) {
   DCHECK(web_contents_);
   DCHECK(router_);
 }
 
 PresentationFrame::~PresentationFrame() {
 }
 
-void PresentationFrame::OnPresentationServiceDelegateDestroyed() const {
-  if (delegate_observer_)
-    delegate_observer_->OnDelegateDestroyed();
-}
-
 void PresentationFrame::OnPresentationSessionStarted(
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
   presentation_id_to_route_id_[session.presentation_id] = route_id;
 }
 
 const MediaRoute::Id PresentationFrame::GetRouteId(
     const std::string& presentation_id) const {
   auto it = presentation_id_to_route_id_.find(presentation_id);
   return it != presentation_id_to_route_id_.end() ? it->second : "";
@@ skipping 230 matching lines @@
 };
 
 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();
-}
+PresentationFrameManager::~PresentationFrameManager() {}
 
 void PresentationFrameManager::OnPresentationSessionStarted(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
   auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
   presentation_frame->OnPresentationSessionStarted(session, route_id);
 }
 
 void PresentationFrameManager::OnDefaultPresentationSessionStarted(
@@ skipping 87 matching lines @@
     DCHECK(!callback.is_null());
     GURL frame_url(GetLastCommittedURLForFrame(render_frame_host_id));
     PresentationRequest request(render_frame_host_id,
                                 std::vector<GURL>({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) {
-  const auto it = presentation_frames_.find(render_frame_host_id);
-  if (it != presentation_frames_.end()) {
-    it->second->set_delegate_observer(nullptr);
-    presentation_frames_.erase(it);
-  }
-}
-
 void PresentationFrameManager::AddDefaultPresentationRequestObserver(
     PresentationServiceDelegateImpl::DefaultPresentationRequestObserver*
         observer) {
   default_presentation_request_observers_.AddObserver(observer);
 }
 
 void PresentationFrameManager::RemoveDefaultPresentationRequestObserver(
     PresentationServiceDelegateImpl::DefaultPresentationRequestObserver*
         observer) {
   default_presentation_request_observers_.RemoveObserver(observer);
@@ skipping 83 matching lines @@
   DCHECK(web_contents_);
   DCHECK(router_);
 }
 
 PresentationServiceDelegateImpl::~PresentationServiceDelegateImpl() {
 }
 
 void PresentationServiceDelegateImpl::AddObserver(int render_process_id,
                                                   int render_frame_id,
                                                   DelegateObserver* observer) {
-  DCHECK(observer);
-  frame_manager_->AddDelegateObserver(
-      RenderFrameHostId(render_process_id, render_frame_id), observer);
+  PresentationServiceDelegateBaseImpl::AddObserver(render_process_id,
+                                                   render_frame_id, observer);
 }
 
 void PresentationServiceDelegateImpl::RemoveObserver(int render_process_id,
                                                      int render_frame_id) {
-  frame_manager_->RemoveDelegateObserver(
-      RenderFrameHostId(render_process_id, render_frame_id));
+  PresentationServiceDelegateBaseImpl::RemoveObserver(render_process_id,
+                                                      render_frame_id);
 }
 
 bool PresentationServiceDelegateImpl::AddScreenAvailabilityListener(
     int render_process_id,
     int render_frame_id,
     content::PresentationScreenAvailabilityListener* listener) {
   DCHECK(listener);
   return frame_manager_->SetScreenAvailabilityListener(
       RenderFrameHostId(render_process_id, render_frame_id), listener);
 }
@@ skipping 214 matching lines @@
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& connection,
     const content::PresentationConnectionStateChangedCallback&
         state_changed_cb) {
   frame_manager_->ListenForConnectionStateChange(
       RenderFrameHostId(render_process_id, render_frame_id), connection,
       state_changed_cb);
 }
 
+void PresentationServiceDelegateImpl::ConnectToOffscreenPresentation(
+    int render_process_id,
+    int render_frame_id,
+    const content::PresentationSessionInfo& session,
+    content::PresentationConnectionPtr connection) {
+  RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
+  auto* const offscreen_presentation_manager =
+      OffscreenPresentationManagerFactory::
+          GetOrCreateForControllerBrowserContext(web_contents_);
+  offscreen_presentation_manager->RegisterOffscreenPresentationController(
+      session.presentation_id, session.presentation_url, render_frame_host_id,
+      std::move(connection));
+}
+
 void PresentationServiceDelegateImpl::OnRouteResponse(
     const PresentationRequest& presentation_request,
     const RouteRequestResult& result) {
   if (!result.route())
     return;
 
   content::PresentationSessionInfo session_info(
       presentation_request.presentation_url(), result.presentation_id(),
       result.route()->is_offscreen_presentation());
   frame_manager_->OnDefaultPresentationSessionStarted(
@@ skipping 34 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