[Presentation API] Mojo typemap for content::PresentationConnectionMessage

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 71 matching lines @@
       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();
-    std::vector<std::unique_ptr<content::PresentationConnectionMessage>>
-        presentation_messages;
+    // 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.push_back(
-            base::MakeUnique<content::PresentationConnectionMessage>(
-                content::PresentationMessageType::TEXT));
-        presentation_messages.back()->message = *message.text;
+        presentation_messages.emplace_back(message.text.value());
       } else if (message.type == RouteMessage::BINARY && message.binary) {
-        presentation_messages.push_back(
-            base::MakeUnique<content::PresentationConnectionMessage>(
-                content::PresentationMessageType::BINARY));
-        presentation_messages.back()->data.reset(
-            new std::vector<uint8_t>(*message.binary));
+        presentation_messages.emplace_back(message.binary.value());
+      } else {
+        NOTREACHED() << "Unknown route message type";
       }
     }
-    // TODO(miu): Remove second argument from PresentationSessionMessageCallback
-    // since it's always true now.
-    message_cb_.Run(presentation_messages, true);
+    message_cb_.Run(std::move(presentation_messages));
   }
 
  private:
   const content::PresentationConnectionMessageCallback message_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(PresentationSessionMessagesObserver);
 };
 
 }  // namespace
 
@@ skipping 823 matching lines @@
     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::PresentationConnectionMessage> message,
+    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;
   }
 
-  if (message->is_binary()) {
-    router_->SendRouteBinaryMessage(route_id, std::move(message->data),
-                                    send_message_cb);
+  if (message.is_binary()) {
+    router_->SendRouteBinaryMessage(
+        route_id,
+        base::MakeUnique<std::vector<uint8_t>>(std::move(message.data.value())),
+        send_message_cb);
   } else {
-    router_->SendRouteMessage(route_id, message->message, send_message_cb);
+    router_->SendRouteMessage(route_id, message.message.value(),
+                              send_message_cb);
   }
 }
 
 void PresentationServiceDelegateImpl::ListenForConnectionStateChange(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& connection,
     const content::PresentationConnectionStateChangedCallback&
         state_changed_cb) {
   frame_manager_->ListenForConnectionStateChange(
@@ skipping 74 matching lines @@
   const base::ListValue* origins =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext())
           ->GetPrefs()
           ->GetList(prefs::kMediaRouterTabMirroringSources);
   return origins &&
          origins->Find(base::StringValue(origin.Serialize())) != origins->end();
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace media_router