Media Router Mojo: Use new wrapper types.

chrome/browser/media/router/mojo/media_router_mojo_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/mojo/media_router_mojo_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 28 matching lines @@
 using SinkAvailability = interfaces::MediaRouter::SinkAvailability;
 
 namespace {
 
 std::unique_ptr<content::PresentationSessionMessage>
 ConvertToPresentationSessionMessage(interfaces::RouteMessagePtr input) {
   DCHECK(!input.is_null());
   std::unique_ptr<content::PresentationSessionMessage> output;
   switch (input->type) {
     case interfaces::RouteMessage::Type::TEXT: {
-      DCHECK(!input->message.is_null());
-      DCHECK(input->data.is_null());
+      DCHECK(input->message);
+      DCHECK(!input->data);
       output.reset(new content::PresentationSessionMessage(
           content::PresentationMessageType::TEXT));
-      input->message.Swap(&output->message);
+      output->message = std::move(*input->message);
       return output;
     }
     case interfaces::RouteMessage::Type::BINARY: {
-      DCHECK(!input->data.is_null());
-      DCHECK(input->message.is_null());
+      DCHECK(input->data);
+      DCHECK(!input->message);
       output.reset(new content::PresentationSessionMessage(
           content::PresentationMessageType::ARRAY_BUFFER));
-      output->data.reset(new std::vector<uint8_t>);
-      input->data.Swap(output->data.get());
+      output->data.reset(new std::vector<uint8_t>(std::move(*input->data)));
       return output;
     }
   }
 
   NOTREACHED() << "Invalid route message type " << input->type;
   return output;
 }
 
-void ForwardSinkSearchCallback(const MediaSinkSearchResponseCallback& callback,
-                               mojo::String sink_id) {
-  callback.Run(sink_id);
-}
-
 }  // namespace
 
 MediaRouterMojoImpl::MediaRoutesQuery::MediaRoutesQuery() = default;
 
 MediaRouterMojoImpl::MediaRoutesQuery::~MediaRoutesQuery() = default;
 
 MediaRouterMojoImpl::MediaSinksQuery::MediaSinksQuery() = default;
 
 MediaRouterMojoImpl::MediaSinksQuery::~MediaSinksQuery() = default;
 
@@ skipping 107 matching lines @@
 }
 
 void MediaRouterMojoImpl::OnIssue(const interfaces::IssuePtr issue) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DVLOG_WITH_INSTANCE(1) << "OnIssue " << issue->title;
   const Issue& issue_converted = issue.To<Issue>();
   issue_manager_.AddIssue(issue_converted);
 }
 
 void MediaRouterMojoImpl::OnSinksReceived(
-    const mojo::String& media_source,
-    mojo::Array<interfaces::MediaSinkPtr> sinks,
-    mojo::Array<mojo::String> origins) {
+    const std::string& media_source,
+    std::vector<interfaces::MediaSinkPtr> sinks,
+    const std::vector<std::string>& origins) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DVLOG_WITH_INSTANCE(1) << "OnSinksReceived";
   auto it = sinks_queries_.find(media_source);
   if (it == sinks_queries_.end()) {
     DVLOG_WITH_INSTANCE(1) << "Received sink list without MediaSinksQuery.";
     return;
   }
 
   std::vector<GURL> origin_list;
   origin_list.reserve(origins.size());
   for (size_t i = 0; i < origins.size(); ++i) {
-    GURL origin(origins[i].get());
+    GURL origin(origins[i]);
     if (!origin.is_valid()) {
       LOG(WARNING) << "Received invalid origin: " << origin
                    << ". Dropping result.";
       return;
     }
     origin_list.push_back(origin);
   }
 
   std::vector<MediaSink> sink_list;
   sink_list.reserve(sinks.size());
   for (size_t i = 0; i < sinks.size(); ++i)
     sink_list.push_back(sinks[i].To<MediaSink>());
 
   auto* sinks_query = it->second;
   sinks_query->has_cached_result = true;
   sinks_query->origins.swap(origin_list);
   sinks_query->cached_sink_list.swap(sink_list);
 
   if (!sinks_query->observers.might_have_observers()) {
     DVLOG_WITH_INSTANCE(1)
         << "Received sink list without any active observers: " << media_source;
   } else {
     FOR_EACH_OBSERVER(
         MediaSinksObserver, sinks_query->observers,
         OnSinksUpdated(sinks_query->cached_sink_list, sinks_query->origins));
   }
 }
 
 void MediaRouterMojoImpl::OnRoutesUpdated(
-    mojo::Array<interfaces::MediaRoutePtr> routes,
-    const mojo::String& media_source,
-    mojo::Array<mojo::String> joinable_route_ids) {
+    std::vector<interfaces::MediaRoutePtr> routes,
+    const std::string& media_source,
+    const std::vector<std::string>& joinable_route_ids) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   DVLOG_WITH_INSTANCE(1) << "OnRoutesUpdated";
   auto it = routes_queries_.find(media_source);
   if (it == routes_queries_.end() ||
       !(it->second->observers.might_have_observers())) {
     DVLOG_WITH_INSTANCE(1)
         << "Received route list without any active observers: " << media_source;
     return;
   }
 
   std::vector<MediaRoute> routes_converted;
   routes_converted.reserve(routes.size());
-
   for (size_t i = 0; i < routes.size(); ++i)
     routes_converted.push_back(routes[i].To<MediaRoute>());
 
-  std::vector<MediaRoute::Id> joinable_routes_converted =
-      joinable_route_ids.To<std::vector<std::string>>();
-
   FOR_EACH_OBSERVER(
       MediaRoutesObserver, it->second->observers,
-      OnRoutesUpdated(routes_converted, joinable_routes_converted));
+      OnRoutesUpdated(routes_converted, joinable_route_ids));
 }
 
 void MediaRouterMojoImpl::RouteResponseReceived(
     const std::string& presentation_id,
     bool incognito,
     const std::vector<MediaRouteResponseCallback>& callbacks,
     interfaces::MediaRoutePtr media_route,
-    mojo::String error_text,
+    const base::Optional<std::string>& error_text,
     interfaces::RouteRequestResultCode result_code) {
   std::unique_ptr<RouteRequestResult> result;
   if (media_route.is_null()) {
     // An error occurred.
-    DCHECK(!error_text.is_null());
-    std::string error =
-        !error_text.get().empty() ? error_text.get() : "Unknown error.";
+    const std::string& error = (error_text && !error_text->empty())
+        ? *error_text : std::string("Unknown error.");
     result = RouteRequestResult::FromError(
         error, mojo::RouteRequestResultCodeFromMojo(result_code));
   } else if (media_route->incognito != incognito) {
     std::string error = base::StringPrintf(
         "Mismatch in incognito status: request = %d, response = %d", incognito,
         media_route->incognito);
     result = RouteRequestResult::FromError(
         error, RouteRequestResult::INCOGNITO_MISMATCH);
   } else {
     result = RouteRequestResult::FromSuccess(
@@ skipping 407 matching lines @@
     const SendRouteMessageCallback& callback) {
   DVLOG_WITH_INSTANCE(1) << "SendRouteMessage " << route_id;
   media_route_provider_->SendRouteMessage(route_id, message, callback);
 }
 
 void MediaRouterMojoImpl::DoSendSessionBinaryMessage(
     const MediaRoute::Id& route_id,
     std::unique_ptr<std::vector<uint8_t>> data,
     const SendRouteMessageCallback& callback) {
   DVLOG_WITH_INSTANCE(1) << "SendRouteBinaryMessage " << route_id;
-  mojo::Array<uint8_t> mojo_array;
-  mojo_array.Swap(data.get());
-  media_route_provider_->SendRouteBinaryMessage(route_id, std::move(mojo_array),
-                                                callback);
+  media_route_provider_->SendRouteBinaryMessage(route_id, *data, callback);
 }
 
 void MediaRouterMojoImpl::DoStartListeningForRouteMessages(
     const MediaRoute::Id& route_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStartListeningForRouteMessages";
   media_route_provider_->StartListeningForRouteMessages(route_id);
 }
 
 void MediaRouterMojoImpl::DoStopListeningForRouteMessages(
     const MediaRoute::Id& route_id) {
   DVLOG_WITH_INSTANCE(1) << "StopListeningForRouteMessages";
   media_route_provider_->StopListeningForRouteMessages(route_id);
 }
 
 void MediaRouterMojoImpl::DoSearchSinks(
     const MediaSink::Id& sink_id,
     const MediaSource::Id& source_id,
     const std::string& search_input,
     const std::string& domain,
     const MediaSinkSearchResponseCallback& sink_callback) {
   DVLOG_WITH_INSTANCE(1) << "SearchSinks";
   auto sink_search_criteria = interfaces::SinkSearchCriteria::New();
   sink_search_criteria->input = search_input;
   sink_search_criteria->domain = domain;
   media_route_provider_->SearchSinks(
-      sink_id, source_id, std::move(sink_search_criteria),
-      base::Bind(&ForwardSinkSearchCallback, sink_callback));
+      sink_id, source_id, std::move(sink_search_criteria), sink_callback);
 }
 
 void MediaRouterMojoImpl::OnRouteMessagesReceived(
-    const mojo::String& route_id,
-    mojo::Array<interfaces::RouteMessagePtr> messages) {
+    const std::string& route_id,
+    std::vector<interfaces::RouteMessagePtr> messages) {
   DVLOG_WITH_INSTANCE(1) << "OnRouteMessagesReceived";
 
-  DCHECK(!messages.storage().empty());
+  DCHECK(!messages.empty());
 
   auto* observer_list = messages_observers_.get(route_id);
   if (!observer_list) {
     return;
   }
 
   ScopedVector<content::PresentationSessionMessage> session_messages;
   session_messages.reserve(messages.size());
   for (size_t i = 0; i < messages.size(); ++i) {
     session_messages.push_back(
@@ skipping 25 matching lines @@
   } else {
     // Sinks are now available. Tell MRPM to start all sink queries again.
     for (const auto& source_and_query : sinks_queries_) {
       RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStartObservingMediaSinks,
                             base::Unretained(this), source_and_query.first));
     }
   }
 }
 
 void MediaRouterMojoImpl::OnPresentationConnectionStateChanged(
-    const mojo::String& route_id,
+    const std::string& route_id,
     interfaces::MediaRouter::PresentationConnectionState state) {
   NotifyPresentationConnectionStateChange(
       route_id, mojo::PresentationConnectionStateFromMojo(state));
 }
 
 void MediaRouterMojoImpl::OnPresentationConnectionClosed(
-    const mojo::String& route_id,
+    const std::string& route_id,
     interfaces::MediaRouter::PresentationConnectionCloseReason reason,
-    const mojo::String& message) {
+    const std::string& message) {
   NotifyPresentationConnectionClose(
       route_id, mojo::PresentationConnectionCloseReasonFromMojo(reason),
       message);
 }
 
 void MediaRouterMojoImpl::OnTerminateRouteResult(
     const MediaRoute::Id& route_id,
-    mojo::String error_text,
+    const base::Optional<std::string>& error_text,
     interfaces::RouteRequestResultCode result_code) {
   if (result_code != interfaces::RouteRequestResultCode::OK) {
-    LOG(WARNING) << "Failed to terminate route " << route_id <<
-        ": result_code = " << result_code << ", " << error_text;
+    LOG(WARNING) << "Failed to terminate route " << route_id
+                 << ": result_code = " << result_code << ", "
+                 << error_text.value_or(std::string());
   }
   MediaRouterMojoMetrics::RecordMediaRouteProviderTerminateRoute(
       mojo::RouteRequestResultCodeFromMojo(result_code));
 }
 
 void MediaRouterMojoImpl::DoStartObservingMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStartObservingMediaSinks: " << source_id;
   // No need to call MRPM if there are no sinks available.
   if (availability_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE)
@@ skipping 197 matching lines @@
                         base::Unretained(this), source_id));
 }
 
 void MediaRouterMojoImpl::DoUpdateMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoUpdateMediaSinks" << source_id;
   media_route_provider_->UpdateMediaSinks(source_id);
 }
 
 }  // namespace media_router