[Media Router] Implement an internal Media Routes observer.

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 <memory>
 #include <string>
 #include <utility>
@@ skipping 287 matching lines @@
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->CreateRoute(
       kSource, kSinkId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, OffTheRecordRoutesTerminatedOnProfileShutdown) {
+  interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
+  route->media_source = kSource;
+  route->media_sink_id = kSinkId;
+  route->media_route_id = kRouteId;
+  route->description = kDescription;
+  route->is_local = true;
+  route->for_display = true;
+  route->off_the_record = true;
+
   EXPECT_CALL(mock_media_route_provider_,
               CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
                           mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis,
                           true, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& sink,
              const mojo::String& presentation_id, const mojo::String& origin,
              int tab_id, int64_t timeout_millis, bool off_the_record,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
             interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
             route->media_source = kSource;
             route->media_sink_id = kSinkId;
             route->media_route_id = kRouteId;
             route->description = kDescription;
             route->is_local = true;
             route->for_display = true;
             route->off_the_record = true;
             cb.Run(std::move(route), mojo::String(),
                    interfaces::RouteRequestResultCode::OK);
           }));
   base::RunLoop run_loop;
   router()->CreateRoute(kSource, kSinkId, GURL(kOrigin), nullptr,
                         std::vector<MediaRouteResponseCallback>(),
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         true);
+  mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
+  mojo_routes[0] = route->Clone();
+  router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
+                            mojo::Array<mojo::String>());
 
   // TODO(mfoltz): Where possible, convert other tests to use RunUntilIdle
   // instead of manually calling Run/Quit on the run loop.
   run_loop.RunUntilIdle();
 
   EXPECT_CALL(mock_media_route_provider_,
               TerminateRoute(mojo::String(kRouteId)));
   base::RunLoop run_loop2;
   router()->OnOffTheRecordProfileShutdown();
   run_loop2.RunUntilIdle();
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRoute) {
   MediaSource media_source(kSource);
+
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
   interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
   route->media_source = kSource;
   route->media_sink_id = kSinkId;
   route->media_route_id = kRouteId;
   route->description = kDescription;
   route->is_local = true;
   route->for_display = true;
   route->off_the_record = false;
 
+  // Make sure the MR has received an update with the route, so it knows there
+  // is a local route to join.
+  mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
+  mojo_routes[0] = route->Clone();
+  router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
+                            mojo::Array<mojo::String>());
+
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(
       mock_media_route_provider_,
       JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
                 mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, _, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& presentation_id,
           const mojo::String& origin, int tab_id, int64_t timeout_millis,
@@ skipping 10 matching lines @@
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
                       route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
 }
 
-TEST_F(MediaRouterMojoImplTest, JoinRouteFails) {
+TEST_F(MediaRouterMojoImplTest, JoinRouteNotFoundFails) {
+  RouteResponseCallbackHandler handler;
+  base::RunLoop run_loop;
+  EXPECT_CALL(handler, DoInvoke(nullptr, "", "Route not found",
+                                RouteRequestResult::ROUTE_NOT_FOUND))
+      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  route_response_callbacks.push_back(base::Bind(
+      &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
+  router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
+                      route_response_callbacks,
+                      base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
+  run_loop.Run();
+}
+
+TEST_F(MediaRouterMojoImplTest, JoinRouteTimedOutFails) {
+  interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
+  route->media_source = kSource;
+  route->media_sink_id = kSinkId;
+  route->media_route_id = kRouteId;
+  route->description = kDescription;
+  route->is_local = true;
+  route->for_display = true;
+  route->off_the_record = false;
+
+  // Make sure the MR has received an update with the route, so it knows there
+  // is a local route to join.
+  mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
+  mojo_routes[0] = route->Clone();
+  router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
+                            mojo::Array<mojo::String>());
+
   EXPECT_CALL(
       mock_media_route_provider_,
       JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
                 mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, _, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& presentation_id,
              const mojo::String& origin, int tab_id, int64_t timeout_millis,
              bool off_the_record,
              const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
             cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError),
@@ skipping 17 matching lines @@
 TEST_F(MediaRouterMojoImplTest, JoinRouteOffTheRecordMismatchFails) {
   interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
   route->media_source = kSource;
   route->media_sink_id = kSinkId;
   route->media_route_id = kRouteId;
   route->description = kDescription;
   route->is_local = true;
   route->for_display = true;
   route->off_the_record = false;
 
+  // Make sure the MR has received an update with the route, so it knows there
+  // is a local route to join.
+  mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
+  mojo_routes[0] = route->Clone();
+  router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
+                            mojo::Array<mojo::String>());
+
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(
       mock_media_route_provider_,
       JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
                 mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, true, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& presentation_id,
           const mojo::String& origin, int tab_id, int64_t timeout_millis,
@@ skipping 737 matching lines @@
       .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)));
   router()->DetachRoute(kRouteId);
   router()->DetachRoute(kRouteId2);
   run_loop.Run();
   EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
-      .Times(1)
+      .Times(2)
       .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();
 }
 
 class MediaRouterMojoExtensionTest : public ::testing::Test {
  public:
   MediaRouterMojoExtensionTest()
@@ skipping 372 matching lines @@
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(mojo::String(MediaSourceForDesktop().id())))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
         run_loop2.Quit();
       }));
 
   run_loop2.Run();
 }
 
 }  // namespace media_router