[Presentation API] (MR side) 1-UA: notify receiver page when receiver connection becomes available

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"
@@ skipping 107 matching lines @@
 
   void OnPresentationSessionStarted(
       const content::PresentationSessionInfo& session,
       const MediaRoute::Id& route_id);
   void OnPresentationServiceDelegateDestroyed() const;
 
   void set_delegate_observer(DelegateObserver* observer) {
     delegate_observer_ = observer;
   }
 
+  void SetOffscreenPresentationClient(
+      content::OffscreenPresentationClient* client) {
+    offscreen_presentation_client_ = client;
+  }
+
  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_;
 
+  OffscreenPresentationManager* const offscreen_presentation_manager_;
   DelegateObserver* delegate_observer_;
+  content::OffscreenPresentationClient* offscreen_presentation_client_;
 };
 
 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) {
+      offscreen_presentation_manager_(
+          OffscreenPresentationManagerFactory::GetOrCreateForBrowserContext(
+              web_contents_->GetBrowserContext())),
+      delegate_observer_(nullptr),
+      offscreen_presentation_client_(nullptr) {
   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;
+  offscreen_presentation_manager_->RegisterOffscreenPresentationController(

[imcheng, 2016/09/28 07:28:37]

Don't we need to check the started presentation is an offscreen presentation
before calling this?

[zhaobin, 2016/09/29 17:20:44]

Yes, we need to check if it is offscreen presentation.

Would it still be a problem if we change to PresentationConnectionProxy
approach? We do not create PresentationConnection for MR session, right?

+      session.presentation_id, render_frame_host_id_.second,
+      offscreen_presentation_client_);
 }
 
 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 : "";
 }
 
 const std::vector<MediaRoute::Id> PresentationFrame::GetRouteIds() const {
   std::vector<MediaRoute::Id> route_ids;
@@ skipping 33 matching lines @@
   }
   return false;
 }
 
 bool PresentationFrame::HasScreenAvailabilityListenerForTest(
     const MediaSource::Id& source_id) const {
   return url_to_sinks_observer_.find(source_id) != url_to_sinks_observer_.end();
 }
 
 void PresentationFrame::Reset() {
-  for (const auto& pid_route_id : presentation_id_to_route_id_)
+  for (const auto& pid_route_id : presentation_id_to_route_id_) {
     router_->DetachRoute(pid_route_id.second);
+    offscreen_presentation_manager_->UnregisterOffscreenPresentationController(

[imcheng, 2016/09/28 07:28:37]

Something to think about: how do we tell the receiver side of the
PresentationConnection that the controller side has closed the connection and
vice versa? i.e. the receiver PresentationConnection should get a state change
to CLOSED.

[zhaobin, 2016/09/29 17:20:44]

Original plan: In receiver's PSImpl::CloseConnection(), it can invoke
offscreen_presentation_client_ (controller's PSImpl)->OnConnectionStateChanged()
to notify connection state change.

OPM will not handle connection state change.

Code has been removed in new patch.

+        pid_route_id.first, render_frame_host_id_.second);
+  }
 
   presentation_id_to_route_id_.clear();
   url_to_sinks_observer_.clear();
   connection_state_subscriptions_.clear();
   session_messages_observers_.clear();
 }
 
 void PresentationFrame::RemoveConnection(const std::string& presentation_id,
                                          const MediaRoute::Id& route_id) {
   // Remove the presentation id mapping so a later call to Reset is a no-op.
   presentation_id_to_route_id_.erase(presentation_id);
 
   // We no longer need to observe route messages.
   session_messages_observers_.erase(route_id);
 
   // We keep the PresentationConnectionStateChangedCallback registered with MR
   // so the MRP can tell us when terminate() completed.
+
+  offscreen_presentation_manager_->UnregisterOffscreenPresentationController(
+      presentation_id, render_frame_host_id_.second);
 }
 
 void PresentationFrame::ListenForConnectionStateChange(
     const content::PresentationSessionInfo& connection,
     const content::PresentationConnectionStateChangedCallback&
         state_changed_cb) {
   auto it = presentation_id_to_route_id_.find(connection.presentation_id);
   if (it == presentation_id_to_route_id_.end()) {
     DLOG(ERROR) << __func__ << "route id not found for presentation: "
                 << connection.presentation_id;
@@ skipping 97 matching lines @@
   void SetMediaRouterForTest(MediaRouter* router);
 
   void OnPresentationSessionStarted(
       const RenderFrameHostId& render_frame_host_id,
       const content::PresentationSessionInfo& session,
       const MediaRoute::Id& route_id);
   void OnDefaultPresentationSessionStarted(
       const PresentationRequest& request,
       const content::PresentationSessionInfo& session,
       const MediaRoute::Id& route_id);
+  void RegisterOffscreenPresentationClient(
+      const RenderFrameHostId& render_frame_host_id,
+      content::OffscreenPresentationClient* client);
 
   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();
   }
 
@@ skipping 244 matching lines @@
   FOR_EACH_OBSERVER(
       PresentationServiceDelegateImpl::DefaultPresentationRequestObserver,
       default_presentation_request_observers_,
       OnDefaultPresentationChanged(*default_presentation_request_));
 }
 
 void PresentationFrameManager::SetMediaRouterForTest(MediaRouter* router) {
   router_ = router;
 }
 
+void PresentationFrameManager::RegisterOffscreenPresentationClient(
+    const RenderFrameHostId& render_frame_host_id,
+    content::OffscreenPresentationClient* client) {
+  auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
+  presentation_frame->SetOffscreenPresentationClient(client);
+}
+
 PresentationServiceDelegateImpl*
 PresentationServiceDelegateImpl::GetOrCreateForWebContents(
     content::WebContents* web_contents) {
   DCHECK(web_contents);
   // CreateForWebContents does nothing if the delegate instance already exists.
   PresentationServiceDelegateImpl::CreateForWebContents(web_contents);
   return PresentationServiceDelegateImpl::FromWebContents(web_contents);
 }
 
 PresentationServiceDelegateImpl::PresentationServiceDelegateImpl(
@@ skipping 295 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);
 }
 
+void PresentationServiceDelegateImpl::RegisterOffscreenPresentationClient(
+    int render_process_id,
+    int render_frame_id,
+    content::OffscreenPresentationClient* client) {
+  RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
+  frame_manager_->RegisterOffscreenPresentationClient(render_frame_host_id,
+                                                      client);
+}
+
 }  // namespace media_router