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

chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.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 <stddef.h>
 #include <stdint.h>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/histogram_tester.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/media_route.h"
-#include "chrome/browser/media/router/media_router_metrics.h"
-#include "chrome/browser/media/router/media_router_mojo_test.h"
-#include "chrome/browser/media/router/media_router_type_converters.h"
 #include "chrome/browser/media/router/mock_media_router.h"
+#include "chrome/browser/media/router/mojo/media_router_mojo_metrics.h"
+#include "chrome/browser/media/router/mojo/media_router_mojo_test.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/media/router/test_helper.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/version_info/version_info.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_factory.h"
 #include "extensions/common/extension.h"
@@ skipping 528 matching lines @@
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->ConnectRouteByRouteId(
       kSource, kRouteId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, DetachRoute) {
   base::RunLoop run_loop;
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() {
-        run_loop.Quit();
-      }));
+      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   router()->DetachRoute(kRouteId);
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, TerminateRoute) {
   base::RunLoop run_loop;
   EXPECT_CALL(mock_media_route_provider_,
               TerminateRoute(mojo::String(kRouteId)))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() {
-        run_loop.Quit();
-      }));
+      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   router()->TerminateRoute(kRouteId);
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, HandleIssue) {
   MockIssuesObserver issue_observer1(router());
   MockIssuesObserver issue_observer2(router());
   issue_observer1.RegisterObserver();
   issue_observer2.RegisterObserver();
 
   interfaces::IssuePtr mojo_issue1 = CreateMojoIssue("title 1");
   const Issue& expected_issue1 = mojo_issue1.To<Issue>();
 
   const Issue* issue;
   EXPECT_CALL(issue_observer1,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue1))))
       .WillOnce(SaveArg<0>(&issue));
   base::RunLoop run_loop;
   EXPECT_CALL(issue_observer2,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue1))))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() {
-        run_loop.Quit();
-      }));
+      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   media_router_proxy_->OnIssue(std::move(mojo_issue1));
   run_loop.Run();
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer1));
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
 
   EXPECT_CALL(issue_observer1, OnIssueUpdated(nullptr));
   EXPECT_CALL(issue_observer2, OnIssueUpdated(nullptr));
 
   router()->ClearIssue(issue->id());
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer1));
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
   router()->UnregisterIssuesObserver(&issue_observer1);
   interfaces::IssuePtr mojo_issue2 = CreateMojoIssue("title 2");
   const Issue& expected_issue2 = mojo_issue2.To<Issue>();
 
   EXPECT_CALL(issue_observer2,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue2))));
   router()->AddIssue(expected_issue2);
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
 
   EXPECT_CALL(issue_observer2, OnIssueUpdated(nullptr));
   router()->ClearIssue(issue->id());
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
 
   base::RunLoop run_loop2;
   EXPECT_CALL(issue_observer2,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue2))))
-      .WillOnce(InvokeWithoutArgs([&run_loop2]() {
-        run_loop2.Quit();
-      }));
+      .WillOnce(InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
   media_router_proxy_->OnIssue(std::move(mojo_issue2));
   run_loop2.Run();
 
   issue_observer1.UnregisterObserver();
   issue_observer2.UnregisterObserver();
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaSinksObserver) {
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::AVAILABLE);
@@ skipping 62 matching lines @@
       new MockMediaSinksObserver(router(), media_source,
                                  GURL("https://youtube.com")));
   EXPECT_CALL(*cached_sinks_observer2, OnSinksReceived(IsEmpty()));
   EXPECT_TRUE(cached_sinks_observer2->Init());
 
   base::RunLoop run_loop2;
   EXPECT_CALL(mock_media_route_provider_,
               StopObservingMediaSinks(mojo::String(kSource)));
   EXPECT_CALL(mock_media_route_provider_,
               StopObservingMediaSinks(mojo::String(kSource2)))
-      .WillOnce(InvokeWithoutArgs([&run_loop2]() {
-        run_loop2.Quit();
-      }));
+      .WillOnce(InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
   sinks_observer.reset();
   extra_sinks_observer.reset();
   unrelated_sinks_observer.reset();
   cached_sinks_observer.reset();
   cached_sinks_observer2.reset();
   run_loop2.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest,
        RegisterMediaSinksObserverWithAvailabilityChange) {
@@ skipping 65 matching lines @@
               StopObservingMediaSinks(mojo::String(kSource2)));
   sinks_observer2.reset();
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaRoutesObserver) {
   MockMediaRouter mock_router;
   MediaSource media_source(kSource);
   MediaSource different_media_source(kSource2);
   EXPECT_CALL(mock_media_route_provider_,
-      StartObservingMediaRoutes(mojo::String(media_source.id()))).Times(2);
-  EXPECT_CALL(mock_media_route_provider_,
-      StartObservingMediaRoutes(
-          mojo::String(different_media_source.id()))).Times(1);
+              StartObservingMediaRoutes(mojo::String(media_source.id())))
+      .Times(2);
+  EXPECT_CALL(
+      mock_media_route_provider_,
+      StartObservingMediaRoutes(mojo::String(different_media_source.id())))
+      .Times(1);
 
   MediaRoutesObserver* observer_captured;
   EXPECT_CALL(mock_router, RegisterMediaRoutesObserver(_))
       .Times(3)
       .WillRepeatedly(SaveArg<0>(&observer_captured));
   MockMediaRoutesObserver routes_observer(&mock_router, media_source.id());
   EXPECT_EQ(observer_captured, &routes_observer);
   MockMediaRoutesObserver extra_routes_observer(&mock_router,
-      media_source.id());
+                                                media_source.id());
   EXPECT_EQ(observer_captured, &extra_routes_observer);
-  MockMediaRoutesObserver different_routes_observer(&mock_router,
-      different_media_source.id());
+  MockMediaRoutesObserver different_routes_observer(
+      &mock_router, different_media_source.id());
   EXPECT_EQ(observer_captured, &different_routes_observer);
   router()->RegisterMediaRoutesObserver(&routes_observer);
   router()->RegisterMediaRoutesObserver(&extra_routes_observer);
   router()->RegisterMediaRoutesObserver(&different_routes_observer);
 
   std::vector<MediaRoute> expected_routes;
   expected_routes.push_back(MediaRoute(kRouteId, media_source, kSinkId,
                                        kDescription, false, "", false));
   MediaRoute incognito_expected_route(kRouteId2, media_source, kSinkId,
                                       kDescription, false, "", false);
@@ skipping 16 matching lines @@
   mojo_routes[0]->is_local = false;
   mojo_routes[0]->off_the_record = false;
   mojo_routes[1] = interfaces::MediaRoute::New();
   mojo_routes[1]->media_route_id = kRouteId2;
   mojo_routes[1]->media_source = kSource;
   mojo_routes[1]->media_sink_id = kSinkId;
   mojo_routes[1]->description = kDescription;
   mojo_routes[1]->is_local = false;
   mojo_routes[1]->off_the_record = true;
 
-  EXPECT_CALL(routes_observer,
-              OnRoutesUpdated(SequenceEquals(expected_routes),
-                              expected_joinable_route_ids));
+  EXPECT_CALL(routes_observer, OnRoutesUpdated(SequenceEquals(expected_routes),
+                                               expected_joinable_route_ids));
   EXPECT_CALL(extra_routes_observer,
               OnRoutesUpdated(SequenceEquals(expected_routes),
                               expected_joinable_route_ids));
   EXPECT_CALL(different_routes_observer,
               OnRoutesUpdated(SequenceEquals(expected_routes),
-                              expected_joinable_route_ids)).Times(0);
+                              expected_joinable_route_ids))
+      .Times(0);
   media_router_proxy_->OnRoutesUpdated(std::move(mojo_routes),
                                        media_source.id(),
                                        std::move(mojo_joinable_routes));
   ProcessEventLoop();
 
   EXPECT_CALL(mock_router, UnregisterMediaRoutesObserver(&routes_observer));
   EXPECT_CALL(mock_router,
               UnregisterMediaRoutesObserver(&extra_routes_observer));
   EXPECT_CALL(mock_router,
               UnregisterMediaRoutesObserver(&different_routes_observer));
   router()->UnregisterMediaRoutesObserver(&routes_observer);
   router()->UnregisterMediaRoutesObserver(&extra_routes_observer);
   router()->UnregisterMediaRoutesObserver(&different_routes_observer);
   EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaRoutes(
-                  mojo::String(media_source.id()))).Times(1);
-  EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaRoutes(
-                  mojo::String(different_media_source.id())));
+              StopObservingMediaRoutes(mojo::String(media_source.id())))
+      .Times(1);
+  EXPECT_CALL(
+      mock_media_route_provider_,
+      StopObservingMediaRoutes(mojo::String(different_media_source.id())));
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, SendRouteMessage) {
   EXPECT_CALL(
       mock_media_route_provider_,
       SendRouteMessage(mojo::String(kRouteId), mojo::String(kMessage), _))
       .WillOnce(Invoke([](
           const MediaRoute::Id& route_id, const std::string& message,
           const interfaces::MediaRouteProvider::SendRouteMessageCallback& cb) {
         cb.Run(true);
       }));
 
   base::RunLoop run_loop;
   SendMessageCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(true))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() {
-        run_loop.Quit();
-      }));
+      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   router()->SendRouteMessage(kRouteId, kMessage,
                              base::Bind(&SendMessageCallbackHandler::Invoke,
                                         base::Unretained(&handler)));
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, SendRouteBinaryMessage) {
   scoped_ptr<std::vector<uint8_t>> expected_binary_data(
       new std::vector<uint8_t>(kBinaryMessage,
                                kBinaryMessage + arraysize(kBinaryMessage)));
 
   EXPECT_CALL(mock_media_route_provider_,
               SendRouteBinaryMessageInternal(mojo::String(kRouteId), _, _))
       .WillOnce(Invoke([](
           const MediaRoute::Id& route_id, const std::vector<uint8_t>& data,
           const interfaces::MediaRouteProvider::SendRouteMessageCallback& cb) {
         EXPECT_EQ(
             0, memcmp(kBinaryMessage, &(data[0]), arraysize(kBinaryMessage)));
         cb.Run(true);
       }));
 
   base::RunLoop run_loop;
   SendMessageCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(true))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() {
-        run_loop.Quit();
-      }));
+      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   router()->SendRouteBinaryMessage(
       kRouteId, std::move(expected_binary_data),
       base::Bind(&SendMessageCallbackHandler::Invoke,
                  base::Unretained(&handler)));
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, PresentationSessionMessagesSingleObserver) {
   mojo::Array<interfaces::RouteMessagePtr> mojo_messages(2);
   mojo_messages[0] = interfaces::RouteMessage::New();
@@ skipping 14 matching lines @@
       content::PresentationMessageType::ARRAY_BUFFER));
   message->data.reset(new std::vector<uint8_t>(1, 1));
   expected_messages.push_back(std::move(message));
 
   base::RunLoop run_loop;
   MediaRoute::Id expected_route_id("foo");
   interfaces::MediaRouteProvider::ListenForRouteMessagesCallback mojo_callback;
   EXPECT_CALL(mock_media_route_provider_,
               ListenForRouteMessages(Eq(expected_route_id), _))
       .WillOnce(DoAll(SaveArg<1>(&mojo_callback),
-                      InvokeWithoutArgs([&run_loop]() {
-                        run_loop.Quit();
-                      })));
+                      InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })));
 
   // |pass_ownership| param is "true" here because there is only one observer.
   ListenForMessagesCallbackHandler handler(std::move(expected_messages), true);
 
   EXPECT_CALL(handler, InvokeObserver());
   // Creating PresentationSessionMessagesObserver will register itself to the
   // MediaRouter, which in turn will start listening for route messages.
   scoped_ptr<PresentationSessionMessagesObserver> observer(
       new PresentationSessionMessagesObserver(
           base::Bind(&ListenForMessagesCallbackHandler::Invoke,
                      base::Unretained(&handler)),
           expected_route_id, router()));
   run_loop.Run();
 
   base::RunLoop run_loop2;
   // Simulate messages by invoking the saved mojo callback.
   // We expect one more ListenForRouteMessages call since |observer| was
   // still registered when the first set of messages arrived.
   mojo_callback.Run(std::move(mojo_messages), false);
   interfaces::MediaRouteProvider::ListenForRouteMessagesCallback
       mojo_callback_2;
   EXPECT_CALL(mock_media_route_provider_, ListenForRouteMessages(_, _))
       .WillOnce(DoAll(SaveArg<1>(&mojo_callback_2),
-                      InvokeWithoutArgs([&run_loop2]() {
-                        run_loop2.Quit();
-                      })));
+                      InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); })));
   run_loop2.Run();
 
   base::RunLoop run_loop3;
   // Stop listening for messages. In particular, MediaRouterMojoImpl will not
   // call ListenForRouteMessages again when it sees there are no more observers.
   mojo::Array<interfaces::RouteMessagePtr> mojo_messages_2(1);
   mojo_messages_2[0] = interfaces::RouteMessage::New();
   mojo_messages_2[0]->type = interfaces::RouteMessage::Type::TEXT;
   mojo_messages_2[0]->message = "foo";
   observer.reset();
   mojo_callback_2.Run(std::move(mojo_messages_2), false);
   EXPECT_CALL(mock_media_route_provider_, StopListeningForRouteMessages(_))
-      .WillOnce(InvokeWithoutArgs([&run_loop3]() {
-        run_loop3.Quit();
-      }));
+      .WillOnce(InvokeWithoutArgs([&run_loop3]() { run_loop3.Quit(); }));
   run_loop3.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, PresentationSessionMessagesMultipleObservers) {
   mojo::Array<interfaces::RouteMessagePtr> mojo_messages(2);
   mojo_messages[0] = interfaces::RouteMessage::New();
   mojo_messages[0]->type = interfaces::RouteMessage::Type::TEXT;
   mojo_messages[0]->message = "text";
   mojo_messages[1] = interfaces::RouteMessage::New();
   mojo_messages[1]->type = interfaces::RouteMessage::Type::BINARY;
@@ skipping 10 matching lines @@
       content::PresentationMessageType::ARRAY_BUFFER));
   message->data.reset(new std::vector<uint8_t>(1, 1));
   expected_messages.push_back(std::move(message));
 
   base::RunLoop run_loop;
   MediaRoute::Id expected_route_id("foo");
   interfaces::MediaRouteProvider::ListenForRouteMessagesCallback mojo_callback;
   EXPECT_CALL(mock_media_route_provider_,
               ListenForRouteMessages(Eq(expected_route_id), _))
       .WillOnce(DoAll(SaveArg<1>(&mojo_callback),
-                      InvokeWithoutArgs([&run_loop]() {
-                        run_loop.Quit();
-                      })));
+                      InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })));
 
   // |pass_ownership| param is "false" here because there are more than one
   // observers.
   ListenForMessagesCallbackHandler handler(std::move(expected_messages), false);
 
   EXPECT_CALL(handler, InvokeObserver()).Times(2);
   // Creating PresentationSessionMessagesObserver will register itself to the
   // MediaRouter, which in turn will start listening for route messages.
   scoped_ptr<PresentationSessionMessagesObserver> observer1(
       new PresentationSessionMessagesObserver(
           base::Bind(&ListenForMessagesCallbackHandler::Invoke,
                      base::Unretained(&handler)),
           expected_route_id, router()));
   scoped_ptr<PresentationSessionMessagesObserver> observer2(
       new PresentationSessionMessagesObserver(
           base::Bind(&ListenForMessagesCallbackHandler::Invoke,
                      base::Unretained(&handler)),
           expected_route_id, router()));
   run_loop.Run();
 
   base::RunLoop run_loop2;
   // Simulate messages by invoking the saved mojo callback.
   // We expect one more ListenForRouteMessages call since |observer| was
   // still registered when the first set of messages arrived.
   mojo_callback.Run(std::move(mojo_messages), false);
   interfaces::MediaRouteProvider::ListenForRouteMessagesCallback
       mojo_callback_2;
   EXPECT_CALL(mock_media_route_provider_, ListenForRouteMessages(_, _))
       .WillOnce(DoAll(SaveArg<1>(&mojo_callback_2),
-                      InvokeWithoutArgs([&run_loop2]() {
-                        run_loop2.Quit();
-                      })));
+                      InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); })));
   run_loop2.Run();
 
   base::RunLoop run_loop3;
   // Stop listening for messages. In particular, MediaRouterMojoImpl will not
   // call ListenForRouteMessages again when it sees there are no more observers.
   mojo::Array<interfaces::RouteMessagePtr> mojo_messages_2(1);
   mojo_messages_2[0] = interfaces::RouteMessage::New();
   mojo_messages_2[0]->type = interfaces::RouteMessage::Type::TEXT;
   mojo_messages_2[0]->message = "foo";
   observer1.reset();
   observer2.reset();
   mojo_callback_2.Run(std::move(mojo_messages_2), false);
   EXPECT_CALL(mock_media_route_provider_, StopListeningForRouteMessages(_))
-      .WillOnce(InvokeWithoutArgs([&run_loop3]() {
-        run_loop3.Quit();
-      }));
+      .WillOnce(InvokeWithoutArgs([&run_loop3]() { run_loop3.Quit(); }));
   run_loop3.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, PresentationSessionMessagesError) {
   MediaRoute::Id expected_route_id("foo");
   interfaces::MediaRouteProvider::ListenForRouteMessagesCallback mojo_callback;
   base::RunLoop run_loop;
   EXPECT_CALL(mock_media_route_provider_,
               ListenForRouteMessages(Eq(expected_route_id), _))
       .WillOnce(DoAll(SaveArg<1>(&mojo_callback),
-                      InvokeWithoutArgs([&run_loop]() {
-                        run_loop.Quit();
-                      })));
+                      InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })));
 
   ListenForMessagesCallbackHandler handler(
       ScopedVector<content::PresentationSessionMessage>(), true);
 
   // Creating PresentationSessionMessagesObserver will register itself to the
   // MediaRouter, which in turn will start listening for route messages.
   scoped_ptr<PresentationSessionMessagesObserver> observer1(
       new PresentationSessionMessagesObserver(
           base::Bind(&ListenForMessagesCallbackHandler::Invoke,
                      base::Unretained(&handler)),
@@ skipping 68 matching lines @@
 }
 
 TEST_F(MediaRouterMojoImplTest, QueuedWhileAsleep) {
   base::RunLoop run_loop;
   EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
       .Times(2)
       .WillRepeatedly(Return(true));
   EXPECT_CALL(mock_event_page_tracker_, WakeEventPage(extension_id(), _))
       .Times(2)
       .WillOnce(Return(true))
-      .WillOnce(DoAll(InvokeWithoutArgs([&run_loop]() {
-                        run_loop.Quit();
-                      }), Return(true)));
+      .WillOnce(DoAll(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }),
+                      Return(true)));
   router()->DetachRoute(kRouteId);
   router()->DetachRoute(kRouteId2);
   run_loop.Run();
   EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
       .Times(1)
       .WillRepeatedly(Return(false));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)));
   ConnectProviderManagerService();
   ProcessEventLoop();
@@ skipping 55 matching lines @@
                                      *extension_);
   }
 
   void RegisterMediaRouteProvider() {
     media_router_proxy_->RegisterMediaRouteProvider(
         std::move(media_route_provider_proxy_),
         base::Bind(&RegisterMediaRouteProviderHandler::Invoke,
                    base::Unretained(&provide_handler_)));
   }
 
-  void ProcessEventLoop() {
-    message_loop_.RunUntilIdle();
-  }
+  void ProcessEventLoop() { message_loop_.RunUntilIdle(); }
 
   void ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason reason,
                                    int expected_count) {
     histogram_tester_.ExpectBucketCount("MediaRouter.Provider.WakeReason",
                                         static_cast<int>(reason),
                                         expected_count);
   }
 
   void ExpectVersionBucketCount(MediaRouteProviderVersion version,
                                 int expected_count) {
@@ skipping 32 matching lines @@
   media_router_->DetachRoute(kRouteId);
 
   BindMediaRouteProvider();
 
   base::RunLoop run_loop, run_loop2;
   // |mojo_media_router| signals its readiness to the MR by registering
   // itself via RegisterMediaRouteProvider().
   // Now that the |media_router| and |mojo_media_router| are fully initialized,
   // the queued DetachRoute() call should be executed.
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() {
-                  run_loop.Quit();
-                }));
+      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)))
-      .WillOnce(InvokeWithoutArgs([&run_loop2]() {
-                  run_loop2.Quit();
-                }));
+      .WillOnce(InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
 
   base::RunLoop run_loop3;
   // Extension is suspended and re-awoken.
   ResetMediaRouteProvider();
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(true));
   EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
       .WillOnce(testing::DoAll(
           media::RunCallback<1>(true),
           InvokeWithoutArgs([&run_loop3]() { run_loop3.Quit(); }),
           Return(true)));
   media_router_->DetachRoute(kRouteId2);
   run_loop3.Run();
 
   base::RunLoop run_loop4, run_loop5;
   // RegisterMediaRouteProvider() is called.
   // The queued DetachRoute(kRouteId2) call should be executed.
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
-      .WillOnce(InvokeWithoutArgs([&run_loop4]() {
-                  run_loop4.Quit();
-                }));
+      .WillOnce(InvokeWithoutArgs([&run_loop4]() { run_loop4.Quit(); }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)))
-      .WillOnce(InvokeWithoutArgs([&run_loop5]() {
-                  run_loop5.Quit();
-                }));
+      .WillOnce(InvokeWithoutArgs([&run_loop5]() { run_loop5.Quit(); }));
   BindMediaRouteProvider();
   RegisterMediaRouteProvider();
   run_loop4.Run();
   run_loop5.Run();
   ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
   ExpectWakeupBucketCount(MediaRouteProviderWakeup::SUCCESS, 1);
   ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
                            1);
 }
 
@@ skipping 83 matching lines @@
 
   // The request queue size should not exceed |kMaxPendingRequests|.
   EXPECT_EQ(kMaxPendingRequests, media_router_->pending_requests_.size());
 
   base::RunLoop run_loop, run_loop2;
   size_t count = 0;
   // The oldest request should have been dropped, so we don't expect to see
   // DetachRoute(kRouteId) here.
   BindMediaRouteProvider();
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() {
-                  run_loop.Quit();
-                }));
+      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)))
       .Times(kMaxPendingRequests)
       .WillRepeatedly(InvokeWithoutArgs([&run_loop2, &count]() {
-                        if (++count == MediaRouterMojoImpl::kMaxPendingRequests)
-                          run_loop2.Quit();
-                      }));
+        if (++count == MediaRouterMojoImpl::kMaxPendingRequests)
+          run_loop2.Quit();
+      }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
   ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
                            1);
 }
 
 }  // namespace media_router