[Media Router] Moves mojo-specific code into mojo/ folder

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/media_router_mojo_impl.h"
+#include "chrome/browser/media/router/mojo/media_router_mojo_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/issues_observer.h"
 #include "chrome/browser/media/router/media_router_factory.h"
-#include "chrome/browser/media/router/media_router_metrics.h"
-#include "chrome/browser/media/router/media_router_type_converters.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
+#include "chrome/browser/media/router/mojo/media_router_mojo_metrics.h"
+#include "chrome/browser/media/router/mojo/media_router_type_converters.h"
 #include "chrome/browser/media/router/presentation_session_messages_observer.h"
 #include "chrome/browser/sessions/session_tab_helper.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 {
@@ skipping 71 matching lines @@
     const extensions::Extension& extension) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   binding_.reset(
       new mojo::Binding<interfaces::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_) {
-    MediaRouterMetrics::RecordMediaRouteProviderVersion(extension);
+    MediaRouterMojoMetrics::RecordMediaRouteProviderVersion(extension);
     provider_version_was_recorded_ = true;
   }
 }
 
 void MediaRouterMojoImpl::OnConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   media_route_provider_.reset();
   binding_.reset();
 
@@ skipping 102 matching lines @@
 
   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));
+  FOR_EACH_OBSERVER(
+      MediaRoutesObserver, it->second->observers,
+      OnRoutesUpdated(routes_converted, joinable_routes_converted));
 }
 
 void MediaRouterMojoImpl::RouteResponseReceived(
     const std::string& presentation_id,
     bool off_the_record,
     const std::vector<MediaRouteResponseCallback>& callbacks,
     interfaces::MediaRoutePtr media_route,
     const mojo::String& error_text,
     interfaces::RouteRequestResultCode result_code) {
   scoped_ptr<RouteRequestResult> result;
@@ skipping 605 matching lines @@
   }
 }
 
 void MediaRouterMojoImpl::AttemptWakeEventPage() {
   ++wakeup_attempt_count_;
   if (wakeup_attempt_count_ > kMaxWakeupAttemptCount) {
     DLOG_WITH_INSTANCE(ERROR) << "Attempted too many times to wake up event "
                               << "page.";
     DrainPendingRequests();
     wakeup_attempt_count_ = 0;
-    MediaRouterMetrics::RecordMediaRouteProviderWakeup(
+    MediaRouterMojoMetrics::RecordMediaRouteProviderWakeup(
         MediaRouteProviderWakeup::ERROR_TOO_MANY_RETRIES);
     return;
   }
 
   DVLOG_WITH_INSTANCE(1) << "Attempting to wake up event page: attempt "
                          << wakeup_attempt_count_;
 
   // This return false if the extension is already awake.
   // Callback is bound using WeakPtr because |event_page_tracker_| outlives
   // |this|.
@@ skipping 12 matching lines @@
   DCHECK(!media_route_provider_extension_id_.empty());
 
   for (const auto& next_request : pending_requests_)
     next_request.Run();
 
   pending_requests_.clear();
 }
 
 void MediaRouterMojoImpl::EventPageWakeComplete(bool success) {
   if (success) {
-    MediaRouterMetrics::RecordMediaRouteProviderWakeReason(
+    MediaRouterMojoMetrics::RecordMediaRouteProviderWakeReason(
         current_wake_reason_);
     ClearWakeReason();
-    MediaRouterMetrics::RecordMediaRouteProviderWakeup(
+    MediaRouterMojoMetrics::RecordMediaRouteProviderWakeup(
         MediaRouteProviderWakeup::SUCCESS);
     return;
   }
 
   // This is likely an non-retriable error. Drop the pending requests.
   DLOG_WITH_INSTANCE(ERROR)
       << "An error encountered while waking the event page.";
   ClearWakeReason();
   DrainPendingRequests();
-  MediaRouterMetrics::RecordMediaRouteProviderWakeup(
+  MediaRouterMojoMetrics::RecordMediaRouteProviderWakeup(
       MediaRouteProviderWakeup::ERROR_UNKNOWN);
 }
 
 void MediaRouterMojoImpl::DrainPendingRequests() {
   DLOG_WITH_INSTANCE(ERROR)
       << "Draining request queue. (queue-length=" << pending_requests_.size()
       << ")";
   pending_requests_.clear();
 }
 
 void MediaRouterMojoImpl::SetWakeReason(MediaRouteProviderWakeReason reason) {
   DCHECK(reason != MediaRouteProviderWakeReason::TOTAL_COUNT);
   if (current_wake_reason_ == MediaRouteProviderWakeReason::TOTAL_COUNT)
     current_wake_reason_ = reason;
 }
 
 void MediaRouterMojoImpl::ClearWakeReason() {
   DCHECK(current_wake_reason_ != MediaRouteProviderWakeReason::TOTAL_COUNT);
   current_wake_reason_ = MediaRouteProviderWakeReason::TOTAL_COUNT;
 }
 
 }  // namespace media_router