[PresentationSevice] Use PresentationConnection to send messages from

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>
@@ skipping 51 matching lines @@
 // Gets the last committed URL for the render frame specified by
 // |render_frame_host_id|.
 url::Origin 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->GetLastCommittedOrigin();
 }
 
-// Observes messages originating from the MediaSink connected to a MediaRoute
-// that represents a presentation. Converts the messages into
-// content::PresentationConnectionMessages and dispatches them via the provided
-// PresentationConnectionMessageCallback.
-class PresentationConnectionMessagesObserver : public RouteMessageObserver {
- public:
-  // |message_cb|: The callback to invoke whenever messages are received.
-  // |route_id|: ID of MediaRoute to listen for messages.
-  PresentationConnectionMessagesObserver(
-      MediaRouter* router,
-      const MediaRoute::Id& route_id,
-      const content::PresentationConnectionMessageCallback& message_cb)
-      : RouteMessageObserver(router, route_id), message_cb_(message_cb) {
-    DCHECK(!message_cb_.is_null());
-  }
-
-  ~PresentationConnectionMessagesObserver() final {}
-
-  void OnMessagesReceived(const std::vector<RouteMessage>& messages) final {
-    DVLOG(2) << __func__ << ", number of messages : " << messages.size();
-    // TODO(mfoltz): Remove RouteMessage and replace with move-only
-    // PresentationConnectionMessage.
-    std::vector<content::PresentationConnectionMessage> presentation_messages;
-    for (const RouteMessage& message : messages) {
-      if (message.type == RouteMessage::TEXT && message.text) {
-        presentation_messages.emplace_back(message.text.value());
-      } else if (message.type == RouteMessage::BINARY && message.binary) {
-        presentation_messages.emplace_back(message.binary.value());
-      } else {
-        NOTREACHED() << "Unknown route message type";
-      }
-    }
-    message_cb_.Run(std::move(presentation_messages));
-  }
-
- private:
-  const content::PresentationConnectionMessageCallback message_cb_;
-
-  DISALLOW_COPY_AND_ASSIGN(PresentationConnectionMessagesObserver);
-};
-
 }  // namespace
 
 // Used by PresentationServiceDelegateImpl to manage
 // listeners and default presentation info in a render frame.
 // Its lifetime:
 //  * Create an instance with |render_frame_host_id_| if no instance with the
 //    same |render_frame_host_id_| exists in:
 //      PresentationFrameManager::OnPresentationConnection
 //      PresentationFrameManager::OnDefaultPresentationStarted
 //      PresentationFrameManager::SetScreenAvailabilityListener
@@ skipping 11 matching lines @@
       content::PresentationScreenAvailabilityListener* listener);
   void RemoveScreenAvailabilityListener(
       content::PresentationScreenAvailabilityListener* listener);
   bool HasScreenAvailabilityListenerForTest(
       const MediaSource::Id& source_id) const;
   std::string GetDefaultPresentationId() const;
   void ListenForConnectionStateChange(
       const content::PresentationInfo& connection,
       const content::PresentationConnectionStateChangedCallback&
           state_changed_cb);
-  void ListenForConnectionMessages(
-      const content::PresentationInfo& presentation_info,
-      const content::PresentationConnectionMessageCallback& message_cb);
 
   void Reset();
   void RemoveConnection(const std::string& presentation_id,
                         const MediaRoute::Id& route_id);
 
   const MediaRoute::Id GetRouteId(const std::string& presentation_id) const;
 
   void OnPresentationConnection(
       const content::PresentationInfo& presentation_info,
       const MediaRoute& route);
   void OnPresentationServiceDelegateDestroyed() const;
 
   void ConnectToPresentation(
       const content::PresentationInfo& presentation_info,
       content::PresentationConnectionPtr controller_connection_ptr,
       content::PresentationConnectionRequest receiver_connection_request);
 
  private:
   MediaSource GetMediaSourceFromListener(
       content::PresentationScreenAvailabilityListener* listener) const;
   base::small_map<std::map<std::string, MediaRoute>> presentation_id_to_route_;
   base::small_map<
       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<PresentationConnectionMessagesObserver>>
-      connection_messages_observers_;
-  std::unordered_map<MediaRoute::Id,
                      std::unique_ptr<BrowserPresentationConnectionProxy>>
       browser_connection_proxies_;
 
   RenderFrameHostId render_frame_host_id_;
 
   // References to the owning WebContents, and the corresponding MediaRouter.
   content::WebContents* web_contents_;
   MediaRouter* router_;
 };
 
@@ skipping 59 matching lines @@
     url_to_sinks_observer_.erase(sinks_observer_it);
   }
 }
 
 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 : presentation_id_to_route_) {
     if (pid_route.second.is_offscreen_presentation()) {
       auto* offscreen_presentation_manager =
           OffscreenPresentationManagerFactory::GetOrCreateForWebContents(
               web_contents_);
       offscreen_presentation_manager->UnregisterOffscreenPresentationController(
           pid_route.first, render_frame_host_id_);
     } else {
       router_->DetachRoute(pid_route.second.media_route_id());
     }
   }
 
   presentation_id_to_route_.clear();
   url_to_sinks_observer_.clear();
   connection_state_subscriptions_.clear();
-  connection_messages_observers_.clear();
   browser_connection_proxies_.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_.erase(presentation_id);
 
-  // We no longer need to observe route messages.
-  connection_messages_observers_.erase(route_id);
-
   browser_connection_proxies_.erase(route_id);
   // We keep the PresentationConnectionStateChangedCallback registered with MR
   // so the MRP can tell us when terminate() completed.
 }
 
 void PresentationFrame::ListenForConnectionStateChange(
     const content::PresentationInfo& connection,
     const content::PresentationConnectionStateChangedCallback&
         state_changed_cb) {
   auto it = presentation_id_to_route_.find(connection.presentation_id);
@@ skipping 10 matching lines @@
                 << "Already listening connection state change for route: "
                 << route_id;
     return;
   }
 
   connection_state_subscriptions_.insert(std::make_pair(
       route_id, router_->AddPresentationConnectionStateChangedCallback(
                     route_id, state_changed_cb)));
 }
 
-void PresentationFrame::ListenForConnectionMessages(
-    const content::PresentationInfo& presentation_info,
-    const content::PresentationConnectionMessageCallback& message_cb) {
-  auto it = presentation_id_to_route_.find(presentation_info.presentation_id);
-  if (it == presentation_id_to_route_.end()) {
-    DVLOG(2) << "ListenForConnectionMessages: no route for "
-             << presentation_info.presentation_id;
-    return;
-  }
-
-  if (it->second.is_offscreen_presentation()) {
-    DVLOG(2) << "ListenForConnectionMessages: do not listen for offscreen "
-             << "presentation [id]: " << presentation_info.presentation_id;
-    return;
-  }
-
-  const MediaRoute::Id& route_id = it->second.media_route_id();
-  if (connection_messages_observers_.find(route_id) !=
-      connection_messages_observers_.end()) {
-    DLOG(ERROR) << __func__
-                << "Already listening for connection messages for route: "
-                << route_id;
-    return;
-  }
-
-  connection_messages_observers_.insert(std::make_pair(
-      route_id, base::MakeUnique<PresentationConnectionMessagesObserver>(
-                    router_, route_id, message_cb)));
-}
-
 MediaSource PresentationFrame::GetMediaSourceFromListener(
     content::PresentationScreenAvailabilityListener* listener) const {
   // If the default presentation URL is empty then fall back to tab mirroring.
   return listener->GetAvailabilityUrl().is_empty()
              ? MediaSourceForTab(SessionTabHelper::IdForTab(web_contents_))
              : MediaSourceForPresentationUrl(listener->GetAvailabilityUrl());
 }
 
 void PresentationFrame::ConnectToPresentation(
     const content::PresentationInfo& presentation_info,
@@ skipping 14 matching lines @@
             web_contents_);
     offscreen_presentation_manager->RegisterOffscreenPresentationController(
         presentation_info.presentation_id, presentation_info.presentation_url,
         render_frame_host_id_, std::move(controller_connection_ptr),
         std::move(receiver_connection_request), pid_route_it->second);
   } else {
     DVLOG(2)
         << "Creating BrowserPresentationConnectionProxy for [presentation_id]: "
         << presentation_info.presentation_id;
     MediaRoute::Id route_id = pid_route_it->second.media_route_id();
+    if (base::ContainsKey(browser_connection_proxies_, route_id)) {
+      DLOG(ERROR) << __func__
+                  << "Already has a BrowserPresentationConnectionProxy for "
+                  << "route: " << route_id;
+      return;
+    }
+
     auto* proxy = new BrowserPresentationConnectionProxy(
         router_, route_id, std::move(receiver_connection_request),
         std::move(controller_connection_ptr));
-
     browser_connection_proxies_.insert(
         std::make_pair(route_id, base::WrapUnique(proxy)));
   }
 }
 
 // Used by PresentationServiceDelegateImpl to manage PresentationFrames.
 class PresentationFrameManager {
  public:
   PresentationFrameManager(content::WebContents* web_contents,
                            MediaRouter* router);
   ~PresentationFrameManager();
 
   // Mirror corresponding APIs in PresentationServiceDelegateImpl.
   bool SetScreenAvailabilityListener(
       const RenderFrameHostId& render_frame_host_id,
       content::PresentationScreenAvailabilityListener* listener);
   void RemoveScreenAvailabilityListener(
       const RenderFrameHostId& render_frame_host_id,
       content::PresentationScreenAvailabilityListener* listener);
   void ListenForConnectionStateChange(
       const RenderFrameHostId& render_frame_host_id,
       const content::PresentationInfo& connection,
       const content::PresentationConnectionStateChangedCallback&
           state_changed_cb);
-  void ListenForConnectionMessages(
-      const RenderFrameHostId& render_frame_host_id,
-      const content::PresentationInfo& presentation_info,
-      const content::PresentationConnectionMessageCallback& 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 SetDefaultPresentationUrls(
       const RenderFrameHostId& render_frame_host_id,
       const std::vector<GURL>& default_presentation_urls,
       const content::PresentationConnectionCallback& callback);
   void AddDelegateObserver(const RenderFrameHostId& render_frame_host_id,
                            DelegateObserver* observer);
@@ skipping 154 matching lines @@
 void PresentationFrameManager::ListenForConnectionStateChange(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationInfo& connection,
     const content::PresentationConnectionStateChangedCallback&
         state_changed_cb) {
   const auto it = presentation_frames_.find(render_frame_host_id);
   if (it != presentation_frames_.end())
     it->second->ListenForConnectionStateChange(connection, state_changed_cb);
 }
 
-void PresentationFrameManager::ListenForConnectionMessages(
-    const RenderFrameHostId& render_frame_host_id,
-    const content::PresentationInfo& presentation_info,
-    const content::PresentationConnectionMessageCallback& message_cb) {
-  const auto it = presentation_frames_.find(render_frame_host_id);
-  if (it == presentation_frames_.end()) {
-    DVLOG(2) << "ListenForConnectionMessages: PresentationFrame does not exist "
-             << "for: (" << render_frame_host_id.first << ", "
-             << render_frame_host_id.second << ")";
-    return;
-  }
-  it->second->ListenForConnectionMessages(presentation_info, message_cb);
-}
-
 void PresentationFrameManager::SetDefaultPresentationUrls(
     const RenderFrameHostId& render_frame_host_id,
     const std::vector<GURL>& default_presentation_urls,
     const content::PresentationConnectionCallback& callback) {
   if (!IsMainFrame(render_frame_host_id))
     return;
 
   if (default_presentation_urls.empty()) {
     ClearDefaultPresentationRequest();
   } else {
@@ skipping 346 matching lines @@
   const MediaRoute::Id& route_id =
       frame_manager_->GetRouteId(rfh_id, presentation_id);
   if (route_id.empty()) {
     DVLOG(1) << "No active route for: " << presentation_id;
     return;
   }
   router_->TerminateRoute(route_id);
   frame_manager_->RemoveConnection(rfh_id, presentation_id, route_id);
 }
 
-void PresentationServiceDelegateImpl::ListenForConnectionMessages(
-    int render_process_id,
-    int render_frame_id,
-    const content::PresentationInfo& presentation_info,
-    const content::PresentationConnectionMessageCallback& message_cb) {
-  frame_manager_->ListenForConnectionMessages(
-      RenderFrameHostId(render_process_id, render_frame_id), presentation_info,
-      message_cb);
-}
-
 void PresentationServiceDelegateImpl::SendMessage(
     int render_process_id,
     int render_frame_id,
     const content::PresentationInfo& presentation_info,
     content::PresentationConnectionMessage message,
     SendMessageCallback send_message_cb) {
   const MediaRoute::Id& route_id = frame_manager_->GetRouteId(
       RenderFrameHostId(render_process_id, render_frame_id),
       presentation_info.presentation_id);
   if (route_id.empty()) {
@@ skipping 97 matching lines @@
   const base::ListValue* origins =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext())
           ->GetPrefs()
           ->GetList(prefs::kMediaRouterTabMirroringSources);
   return origins &&
          origins->Find(base::Value(origin.Serialize())) != origins->end();
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace media_router