[Media Router] Rename mojo namespace from interfaces to mojom

chrome/browser/media/router/mojo/media_router_mojo_impl.h

 // 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.
 
 #ifndef CHROME_BROWSER_MEDIA_ROUTER_MOJO_MEDIA_ROUTER_MOJO_IMPL_H_
 #define CHROME_BROWSER_MEDIA_ROUTER_MOJO_MEDIA_ROUTER_MOJO_IMPL_H_
 
 #include <stdint.h>
 
 #include <deque>
@@ skipping 29 matching lines @@
 }
 
 namespace media_router {
 
 enum class MediaRouteProviderWakeReason;
 
 // MediaRouter implementation that delegates calls to the component extension.
 // Also handles the suspension and wakeup of the component extension.
 // Lives on the UI thread.
 class MediaRouterMojoImpl : public MediaRouterBase,
-                            public interfaces::MediaRouter {
+                            public mojom::MediaRouter {
  public:
   ~MediaRouterMojoImpl() override;
 
   // Sets up the MediaRouterMojoImpl instance owned by |context| to handle
   // MediaRouterObserver requests from the component extension given by
   // |extension|. Creates the MediaRouterMojoImpl instance if it does not
   // exist.
   // Called by the Mojo module registry.
   // |extension|: The component extension, used for querying
   //     suspension state.
   // |context|: The BrowserContext which owns the extension process.
   // |request|: The Mojo connection request used for binding.
   static void BindToRequest(
       const extensions::Extension* extension,
       content::BrowserContext* context,
-      mojo::InterfaceRequest<interfaces::MediaRouter> request);
+      mojo::InterfaceRequest<mojom::MediaRouter> request);
 
   // MediaRouter implementation.
   // Execution of the requests is delegated to the Do* methods, which can be
   // enqueued for later use if the extension is temporarily suspended.
   void CreateRoute(const MediaSource::Id& source_id,
                    const MediaSink::Id& sink_id,
                    const GURL& origin,
                    content::WebContents* web_contents,
                    const std::vector<MediaRouteResponseCallback>& callbacks,
                    base::TimeDelta timeout,
@@ skipping 121 matching lines @@
 
   // Standard constructor, used by
   // MediaRouterMojoImplFactory::GetApiForBrowserContext.
   explicit MediaRouterMojoImpl(
       extensions::EventPageTracker* event_page_tracker);
 
   // Binds |this| to a Mojo interface request, so that clients can acquire a
   // handle to a MediaRouterMojoImpl instance via the Mojo service connector.
   // Stores the ID of |extension| in |media_route_provider_extension_id_|.
   void BindToMojoRequest(
-      mojo::InterfaceRequest<interfaces::MediaRouter> request,
+      mojo::InterfaceRequest<mojom::MediaRouter> request,
       const extensions::Extension& extension);
 
   // Enqueues a closure for later execution by ExecutePendingRequests().
   void EnqueueTask(const base::Closure& closure);
 
   // Runs a closure if the extension monitored by |extension_monitor_| is
   // active, or defers it for later execution if the extension is suspended.
   void RunOrDefer(const base::Closure& request);
 
   // Dispatches the Mojo requests queued in |pending_requests_|.
@@ skipping 55 matching lines @@
   void DoSearchSinks(
       const MediaSink::Id& sink_id,
       const MediaSource::Id& source_id,
       const std::string& search_input,
       const std::string& domain,
       const MediaSinkSearchResponseCallback& sink_callback);
 
   // Error handler callback for |binding_| and |media_route_provider_|.
   void OnConnectionError();
 
-  // interfaces::MediaRouter implementation.
+  // mojom::MediaRouter implementation.
   void RegisterMediaRouteProvider(
-      interfaces::MediaRouteProviderPtr media_route_provider_ptr,
-      const interfaces::MediaRouter::RegisterMediaRouteProviderCallback&
+      mojom::MediaRouteProviderPtr media_route_provider_ptr,
+      const mojom::MediaRouter::RegisterMediaRouteProviderCallback&
           callback) override;
-  void OnIssue(interfaces::IssuePtr issue) override;
+  void OnIssue(mojom::IssuePtr issue) override;
   void OnSinksReceived(const std::string& media_source,
-                       std::vector<interfaces::MediaSinkPtr> sinks,
+                       std::vector<mojom::MediaSinkPtr> sinks,
                        const std::vector<std::string>& origins) override;
   void OnRoutesUpdated(
-      std::vector<interfaces::MediaRoutePtr> routes,
+      std::vector<mojom::MediaRoutePtr> routes,
       const std::string& media_source,
       const std::vector<std::string>& joinable_route_ids) override;
   void OnSinkAvailabilityUpdated(
-      interfaces::MediaRouter::SinkAvailability availability) override;
+      mojom::MediaRouter::SinkAvailability availability) override;
   void OnPresentationConnectionStateChanged(
       const std::string& route_id,
-      interfaces::MediaRouter::PresentationConnectionState state) override;
+      mojom::MediaRouter::PresentationConnectionState state) override;
   void OnPresentationConnectionClosed(
       const std::string& route_id,
-      interfaces::MediaRouter::PresentationConnectionCloseReason reason,
+      mojom::MediaRouter::PresentationConnectionCloseReason reason,
       const std::string& message) override;
   void OnRouteMessagesReceived(
       const std::string& route_id,
-      std::vector<interfaces::RouteMessagePtr> messages) override;
+      std::vector<mojom::RouteMessagePtr> messages) override;
 
   // Result callback when Mojo terminateRoute is invoked.  |route_id| is bound
   // to the ID of the route that was terminated.
   void OnTerminateRouteResult(const MediaRoute::Id& route_id,
                               const base::Optional<std::string>& error_text,
-                              interfaces::RouteRequestResultCode result_code);
+                              mojom::RouteRequestResultCode result_code);
 
   // Converts the callback result of calling Mojo CreateRoute()/JoinRoute()
   // into a local callback.
   void 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);
 
   // Callback invoked by |event_page_tracker_| after an attempt to wake the
   // component extension. If |success| is false, the pending request queue is
   // drained.
   void EventPageWakeComplete(bool success);
 
   // Removes all requests from the pending requests queue. Called when there is
   // a permanent error connecting to component extension.
   void DrainRequestQueue();
 
@@ skipping 43 matching lines @@
 
   using PresentationSessionMessagesObserverList =
       base::ObserverList<PresentationSessionMessagesObserver>;
   base::ScopedPtrHashMap<
       MediaRoute::Id,
       std::unique_ptr<PresentationSessionMessagesObserverList>>
       messages_observers_;
 
   IssueManager issue_manager_;
 
-  // Binds |this| to a Mojo connection stub for interfaces::MediaRouter.
-  std::unique_ptr<mojo::Binding<interfaces::MediaRouter>> binding_;
+  // Binds |this| to a Mojo connection stub for mojom::MediaRouter.
+  std::unique_ptr<mojo::Binding<mojom::MediaRouter>> binding_;
 
   // Mojo proxy object for the Media Route Provider Manager.
   // Set to null initially, and later set to the Provider Manager proxy object
   // passed in via |RegisterMediaRouteProvider()|.
   // This is set to null again when the component extension is suspended
   // if or a Mojo channel error occured.
-  interfaces::MediaRouteProviderPtr media_route_provider_;
+  mojom::MediaRouteProviderPtr media_route_provider_;
 
   // Id of the component extension. Used for managing its suspend/wake state
   // via event_page_tracker_.
   std::string media_route_provider_extension_id_;
 
   // Allows the extension to be monitored for suspend, and woken.
   // This is a reference to a BrowserContext keyed service that outlives this
   // instance.
   extensions::EventPageTracker* event_page_tracker_;
 
   // GUID unique to each browser run. Component extension uses this to detect
   // when its persisted state was written by an older browser instance, and is
   // therefore stale.
   std::string instance_id_;
 
   // The last reported sink availability from the media route provider manager.
-  interfaces::MediaRouter::SinkAvailability availability_;
+  mojom::MediaRouter::SinkAvailability availability_;
 
   int wakeup_attempt_count_ = 0;
 
   // Records the current reason the extension is being woken up.  Is set to
   // MediaRouteProviderWakeReason::TOTAL_COUNT if there is no pending reason.
   MediaRouteProviderWakeReason current_wake_reason_;
 
   // A flag to ensure that we record the provider version once, during the
   // initial event page wakeup attempt.
   bool provider_version_was_recorded_ = false;
@@ skipping 10 matching lines @@
 #endif
 
   base::WeakPtrFactory<MediaRouterMojoImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaRouterMojoImpl);
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_MEDIA_ROUTER_MOJO_MEDIA_ROUTER_MOJO_IMPL_H_