[Media Router] Rename mojo namespace from interfaces to mojom

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 18 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/process_manager.h"
 
 #define DVLOG_WITH_INSTANCE(level) \
   DVLOG(level) << "MR #" << instance_id_ << ": "
 
 #define DLOG_WITH_INSTANCE(level) DLOG(level) << "MR #" << instance_id_ << ": "
 
 namespace media_router {
 
-using SinkAvailability = interfaces::MediaRouter::SinkAvailability;
+using SinkAvailability = mojom::MediaRouter::SinkAvailability;
 
 namespace {
 
 std::unique_ptr<content::PresentationSessionMessage>
-ConvertToPresentationSessionMessage(interfaces::RouteMessagePtr input) {
+ConvertToPresentationSessionMessage(mojom::RouteMessagePtr input) {
   DCHECK(!input.is_null());
   std::unique_ptr<content::PresentationSessionMessage> output;
   switch (input->type) {
-    case interfaces::RouteMessage::Type::TEXT: {
+    case mojom::RouteMessage::Type::TEXT: {
       DCHECK(input->message);
       DCHECK(!input->data);
       output.reset(new content::PresentationSessionMessage(
           content::PresentationMessageType::TEXT));
       output->message = std::move(*input->message);
       return output;
     }
-    case interfaces::RouteMessage::Type::BINARY: {
+    case mojom::RouteMessage::Type::BINARY: {
       DCHECK(input->data);
       DCHECK(!input->message);
       output.reset(new content::PresentationSessionMessage(
           content::PresentationMessageType::ARRAY_BUFFER));
       output->data.reset(new std::vector<uint8_t>(std::move(*input->data)));
       return output;
     }
   }
 
   NOTREACHED() << "Invalid route message type " << input->type;
   return output;
 }
 
 }  // namespace
 
 MediaRouterMojoImpl::MediaRoutesQuery::MediaRoutesQuery() = default;
 
 MediaRouterMojoImpl::MediaRoutesQuery::~MediaRoutesQuery() = default;
 
 MediaRouterMojoImpl::MediaSinksQuery::MediaSinksQuery() = default;
 
 MediaRouterMojoImpl::MediaSinksQuery::~MediaSinksQuery() = default;
 
 MediaRouterMojoImpl::MediaRouterMojoImpl(
     extensions::EventPageTracker* event_page_tracker)
     : event_page_tracker_(event_page_tracker),
       instance_id_(base::GenerateGUID()),
-      availability_(interfaces::MediaRouter::SinkAvailability::UNAVAILABLE),
+      availability_(mojom::MediaRouter::SinkAvailability::UNAVAILABLE),
       current_wake_reason_(MediaRouteProviderWakeReason::TOTAL_COUNT),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(event_page_tracker_);
 #if defined(OS_WIN)
   CanFirewallUseLocalPorts(
       base::Bind(&MediaRouterMojoImpl::OnFirewallCheckComplete,
                  weak_factory_.GetWeakPtr()));
 #endif
 }
 
 MediaRouterMojoImpl::~MediaRouterMojoImpl() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
 // static
 void MediaRouterMojoImpl::BindToRequest(
     const extensions::Extension* extension,
     content::BrowserContext* context,
-    mojo::InterfaceRequest<interfaces::MediaRouter> request) {
+    mojo::InterfaceRequest<mojom::MediaRouter> request) {
   MediaRouterMojoImpl* impl = static_cast<MediaRouterMojoImpl*>(
       MediaRouterFactory::GetApiForBrowserContext(context));
   DCHECK(impl);
 
   impl->BindToMojoRequest(std::move(request), *extension);
 }
 
 void MediaRouterMojoImpl::BindToMojoRequest(
-    mojo::InterfaceRequest<interfaces::MediaRouter> request,
+    mojo::InterfaceRequest<mojom::MediaRouter> request,
     const extensions::Extension& extension) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   binding_.reset(
-      new mojo::Binding<interfaces::MediaRouter>(this, std::move(request)));
+      new mojo::Binding<mojom::MediaRouter>(this, std::move(request)));
   binding_->set_connection_error_handler(base::Bind(
       &MediaRouterMojoImpl::OnConnectionError, base::Unretained(this)));
 
   media_route_provider_extension_id_ = extension.id();
   if (!provider_version_was_recorded_) {
     MediaRouterMojoMetrics::RecordMediaRouteProviderVersion(extension);
     provider_version_was_recorded_ = true;
   }
 }
 
 void MediaRouterMojoImpl::OnConnectionError() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   media_route_provider_.reset();
   binding_.reset();
 
   // If |OnConnectionError| is invoked while there are pending requests, then
   // it means we tried to wake the extension, but weren't able to complete the
   // connection to media route provider. Since we do not know whether the error
   // is transient, reattempt the wakeup.
   if (!pending_requests_.empty()) {
     DLOG_WITH_INSTANCE(ERROR) << "A connection error while there are pending "
                                  "requests.";
     SetWakeReason(MediaRouteProviderWakeReason::CONNECTION_ERROR);
     AttemptWakeEventPage();
   }
 }
 
 void MediaRouterMojoImpl::RegisterMediaRouteProvider(
-    interfaces::MediaRouteProviderPtr media_route_provider_ptr,
-    const interfaces::MediaRouter::RegisterMediaRouteProviderCallback&
+    mojom::MediaRouteProviderPtr media_route_provider_ptr,
+    const mojom::MediaRouter::RegisterMediaRouteProviderCallback&
         callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 #if defined(OS_WIN)
   // The MRPM may have been upgraded or otherwise reload such that we could be
   // seeing an MRPM that doesn't know mDNS is enabled, even if we've told a
   // previously registered MRPM it should be enabled. Furthermore, there may be
   // a pending request to enable mDNS, so don't clear this flag after
   // ExecutePendingRequests().
   is_mdns_enabled_ = false;
 #endif
@@ skipping 19 matching lines @@
   // Windows. It only relies on this signalling from MR on Windows to avoid
   // triggering a firewall prompt out of the context of MR from the user's
   // perspective. This particular call reminds the extension to enable mDNS
   // discovery when it wakes up, has been upgraded, etc.
   if (should_enable_mdns_discovery_) {
     DoEnsureMdnsDiscoveryEnabled();
   }
 #endif
 }
 
-void MediaRouterMojoImpl::OnIssue(const interfaces::IssuePtr issue) {
+void MediaRouterMojoImpl::OnIssue(const mojom::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 std::string& media_source,
-    std::vector<interfaces::MediaSinkPtr> sinks,
+    std::vector<mojom::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;
@@ skipping 22 matching lines @@
     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(
-    std::vector<interfaces::MediaRoutePtr> routes,
+    std::vector<mojom::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>());
 
   FOR_EACH_OBSERVER(
       MediaRoutesObserver, it->second->observers,
       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,
+    mojom::MediaRoutePtr media_route,
     const base::Optional<std::string>& error_text,
-    interfaces::RouteRequestResultCode result_code) {
+    mojom::RouteRequestResultCode result_code) {
   std::unique_ptr<RouteRequestResult> result;
   if (media_route.is_null()) {
     // An error occurred.
     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,
@@ skipping 186 matching lines @@
     new_query = true;
     sinks_query = new MediaSinksQuery;
     sinks_queries_.add(source_id, base::WrapUnique(sinks_query));
   } else {
     DCHECK(!sinks_query->observers.HasObserver(observer));
   }
 
   // If sink availability is UNAVAILABLE, then there is no need to call MRPM.
   // |observer| can be immediately notified with an empty list.
   sinks_query->observers.AddObserver(observer);
-  if (availability_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE) {
+  if (availability_ == mojom::MediaRouter::SinkAvailability::UNAVAILABLE) {
     observer->OnSinksUpdated(std::vector<MediaSink>(), std::vector<GURL>());
   } else {
     // Need to call MRPM to start observing sinks if the query is new.
     if (new_query) {
       SetWakeReason(MediaRouteProviderWakeReason::START_OBSERVING_MEDIA_SINKS);
       RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStartObservingMediaSinks,
                             base::Unretained(this), source_id));
     } else if (sinks_query->has_cached_result) {
       observer->OnSinksUpdated(sinks_query->cached_sink_list,
                                sinks_query->origins);
@@ skipping 15 matching lines @@
   // If we are removing the final observer for the source, then stop
   // observing sinks for it.
   // might_have_observers() is reliable here on the assumption that this call
   // is not inside the ObserverList iteration.
   sinks_query->observers.RemoveObserver(observer);
   if (!sinks_query->observers.might_have_observers()) {
     // Only ask MRPM to stop observing media sinks if the availability is not
     // UNAVAILABLE.
     // Otherwise, the MRPM would have discarded the queries already.
     if (availability_ !=
-        interfaces::MediaRouter::SinkAvailability::UNAVAILABLE) {
+        mojom::MediaRouter::SinkAvailability::UNAVAILABLE) {
       SetWakeReason(MediaRouteProviderWakeReason::STOP_OBSERVING_MEDIA_SINKS);
       // The |sinks_queries_| entry will be removed in the immediate or deferred
       // |DoStopObservingMediaSinks| call.
       RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStopObservingMediaSinks,
                             base::Unretained(this), source_id));
     } else {
       sinks_queries_.erase(source_id);
     }
   }
 }
@@ skipping 191 matching lines @@
   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();
+  auto sink_search_criteria = mojom::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), sink_callback);
 }
 
 void MediaRouterMojoImpl::OnRouteMessagesReceived(
     const std::string& route_id,
-    std::vector<interfaces::RouteMessagePtr> messages) {
+    std::vector<mojom::RouteMessagePtr> messages) {
   DVLOG_WITH_INSTANCE(1) << "OnRouteMessagesReceived";
 
   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(
         ConvertToPresentationSessionMessage(std::move(messages[i])));
   }
   base::ObserverList<PresentationSessionMessagesObserver>::Iterator observer_it(
       observer_list);
   bool single_observer =
       observer_it.GetNext() != nullptr && observer_it.GetNext() == nullptr;
   FOR_EACH_OBSERVER(PresentationSessionMessagesObserver, *observer_list,
                     OnMessagesReceived(session_messages, single_observer));
 }
 
 void MediaRouterMojoImpl::OnSinkAvailabilityUpdated(
     SinkAvailability availability) {
   if (availability_ == availability)
     return;
 
   availability_ = availability;
-  if (availability_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE) {
+  if (availability_ == mojom::MediaRouter::SinkAvailability::UNAVAILABLE) {
     // Sinks are no longer available. MRPM has already removed all sink queries.
     for (auto& source_and_query : sinks_queries_) {
       auto* query = source_and_query.second;
       query->is_active = false;
       query->has_cached_result = false;
       query->cached_sink_list.clear();
       query->origins.clear();
     }
   } 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 std::string& route_id,
-    interfaces::MediaRouter::PresentationConnectionState state) {
+    mojom::MediaRouter::PresentationConnectionState state) {
   NotifyPresentationConnectionStateChange(
       route_id, mojo::PresentationConnectionStateFromMojo(state));
 }
 
 void MediaRouterMojoImpl::OnPresentationConnectionClosed(
     const std::string& route_id,
-    interfaces::MediaRouter::PresentationConnectionCloseReason reason,
+    mojom::MediaRouter::PresentationConnectionCloseReason reason,
     const std::string& message) {
   NotifyPresentationConnectionClose(
       route_id, mojo::PresentationConnectionCloseReasonFromMojo(reason),
       message);
 }
 
 void MediaRouterMojoImpl::OnTerminateRouteResult(
     const MediaRoute::Id& route_id,
     const base::Optional<std::string>& error_text,
-    interfaces::RouteRequestResultCode result_code) {
-  if (result_code != interfaces::RouteRequestResultCode::OK) {
+    mojom::RouteRequestResultCode result_code) {
+  if (result_code != mojom::RouteRequestResultCode::OK) {
     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)
+  if (availability_ == mojom::MediaRouter::SinkAvailability::UNAVAILABLE)
     return;
 
   // No need to call MRPM if all observers have been removed in the meantime.
   auto* sinks_query = sinks_queries_.get(source_id);
   if (!sinks_query || !sinks_query->observers.might_have_observers())
     return;
 
   DVLOG_WITH_INSTANCE(1) << "MRPM.StartObservingMediaSinks: " << source_id;
   media_route_provider_->StartObservingMediaSinks(source_id);
   sinks_query->is_active = true;
@@ skipping 187 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