Updates SessionMessage to ConnectionMessage.

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 57 matching lines @@
 
 // Observes messages originating from the MediaSink connected to a MediaRoute
 // that represents a presentation. Converts the messages into
 // content::PresentationSessionMessages and dispatches them via the provided
 // PresentationSessionMessageCallback.
 class PresentationSessionMessagesObserver : public RouteMessageObserver {
  public:
   // |message_cb|: The callback to invoke whenever messages are received.
   // |route_id|: ID of MediaRoute to listen for messages.
   PresentationSessionMessagesObserver(
-      MediaRouter* router, const MediaRoute::Id& route_id,
-      const content::PresentationSessionMessageCallback& message_cb)
+      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());
   }
 
   ~PresentationSessionMessagesObserver() final {}
 
   void OnMessagesReceived(const std::vector<RouteMessage>& messages) final {
     DVLOG(2) << __func__ << ", number of messages : " << messages.size();
-    ScopedVector<content::PresentationSessionMessage> presentation_messages;
+    ScopedVector<content::PresentationConnectionMessage> presentation_messages;
     for (const RouteMessage& message : messages) {
       if (message.type == RouteMessage::TEXT && message.text) {
-        presentation_messages.push_back(new content::PresentationSessionMessage(
-            content::PresentationMessageType::TEXT));
+        presentation_messages.push_back(
+            new content::PresentationConnectionMessage(
+                content::PresentationMessageType::TEXT));
         presentation_messages.back()->message = *message.text;
       } else if (message.type == RouteMessage::BINARY && message.binary) {
-        presentation_messages.push_back(new content::PresentationSessionMessage(
-            content::PresentationMessageType::ARRAY_BUFFER));
+        presentation_messages.push_back(
+            new content::PresentationConnectionMessage(
+                content::PresentationMessageType::BINARY));
         presentation_messages.back()->data.reset(
             new std::vector<uint8_t>(*message.binary));
       }
     }
     // TODO(miu): Remove second argument from PresentationSessionMessageCallback
     // since it's always true now.
     message_cb_.Run(presentation_messages, true);
   }
 
  private:
-  const content::PresentationSessionMessageCallback message_cb_;
+  const content::PresentationConnectionMessageCallback message_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(PresentationSessionMessagesObserver);
 };
 
 }  // namespace
 
 // Used by PresentationServiceDelegateImpl to manage
 // listeners and default presentation info in a render frame.
 // Its lifetime:
 //  * PresentationFrameManager AddDelegateObserver
@@ skipping 13 matching lines @@
       content::PresentationScreenAvailabilityListener* listener);
   bool HasScreenAvailabilityListenerForTest(
       const MediaSource::Id& source_id) const;
   std::string GetDefaultPresentationId() const;
   void ListenForConnectionStateChange(
       const content::PresentationSessionInfo& connection,
       const content::PresentationConnectionStateChangedCallback&
           state_changed_cb);
   void ListenForSessionMessages(
       const content::PresentationSessionInfo& session,
-      const content::PresentationSessionMessageCallback& message_cb);
+      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;
   const std::vector<MediaRoute::Id> GetRouteIds() const;
 
   void OnPresentationSessionStarted(
       const content::PresentationSessionInfo& session,
@@ skipping 150 matching lines @@
     return;
   }
 
   connection_state_subscriptions_.insert(std::make_pair(
       route_id, router_->AddPresentationConnectionStateChangedCallback(
                     it->second, state_changed_cb)));
 }
 
 void PresentationFrame::ListenForSessionMessages(
     const content::PresentationSessionInfo& session,
-    const content::PresentationSessionMessageCallback& message_cb) {
+    const content::PresentationConnectionMessageCallback& message_cb) {
   auto it = presentation_id_to_route_id_.find(session.presentation_id);
   if (it == presentation_id_to_route_id_.end()) {
     DVLOG(2) << "ListenForSessionMessages: no route for "
              << session.presentation_id;
     return;
   }
 
   const MediaRoute::Id& route_id = it->second;
   if (session_messages_observers_.find(route_id) !=
       session_messages_observers_.end()) {
@@ skipping 31 matching lines @@
       const RenderFrameHostId& render_frame_host_id,
       content::PresentationScreenAvailabilityListener* listener);
   void ListenForConnectionStateChange(
       const RenderFrameHostId& render_frame_host_id,
       const content::PresentationSessionInfo& connection,
       const content::PresentationConnectionStateChangedCallback&
           state_changed_cb);
   void ListenForSessionMessages(
       const RenderFrameHostId& render_frame_host_id,
       const content::PresentationSessionInfo& session,
-      const content::PresentationSessionMessageCallback& message_cb);
+      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 SetDefaultPresentationUrl(
       const RenderFrameHostId& render_frame_host_id,
       const GURL& default_presentation_url,
       const content::PresentationSessionStartedCallback& callback);
   void AddDelegateObserver(const RenderFrameHostId& render_frame_host_id,
                            DelegateObserver* observer);
@@ skipping 152 matching lines @@
     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::ListenForSessionMessages(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& session,
-    const content::PresentationSessionMessageCallback& message_cb) {
+    const content::PresentationConnectionMessageCallback& message_cb) {
   const auto it = presentation_frames_.find(render_frame_host_id);
   if (it == presentation_frames_.end()) {
     DVLOG(2) << "ListenForSessionMessages: PresentationFrame does not exist "
              << "for: (" << render_frame_host_id.first << ", "
              << render_frame_host_id.second << ")";
     return;
   }
   it->second->ListenForSessionMessages(session, message_cb);
 }
 
@@ skipping 326 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::ListenForSessionMessages(
+void PresentationServiceDelegateImpl::ListenForConnectionMessages(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& session,
-    const content::PresentationSessionMessageCallback& message_cb) {
+    const content::PresentationConnectionMessageCallback& message_cb) {
   frame_manager_->ListenForSessionMessages(
       RenderFrameHostId(render_process_id, render_frame_id), session,
       message_cb);
 }
 
 void PresentationServiceDelegateImpl::SendMessage(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& session,
-    std::unique_ptr<content::PresentationSessionMessage> message,
+    std::unique_ptr<content::PresentationConnectionMessage> message,
     const SendMessageCallback& send_message_cb) {
   const MediaRoute::Id& route_id = frame_manager_->GetRouteId(
       RenderFrameHostId(render_process_id, render_frame_id),
       session.presentation_id);
   if (route_id.empty()) {
     DVLOG(1) << "No active route for  " << session.presentation_id;
     send_message_cb.Run(false);
     return;
   }
 
@@ skipping 62 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