Non-Local Join for Media Router and Presentation API

chrome/browser/media/router/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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 35 matching lines @@
 namespace {
 
 const char kDescription[] = "description";
 const char kError[] = "error";
 const char kExtensionId[] = "extension1234";
 const char kMessage[] = "message";
 const char kSource[] = "source1";
 const char kSource2[] = "source2";
 const char kRouteId[] = "routeId";
 const char kRouteId2[] = "routeId2";
+const char kJoinableRouteId[] = "joinableRouteId";
+const char kJoinableRouteId2[] = "joinableRouteId2";
 const char kSinkId[] = "sink";
 const char kSinkId2[] = "sink2";
 const char kSinkName[] = "sinkName";
 const char kPresentationId[] = "presentationId";
 const char kOrigin[] = "http://origin/";
 const int kInvalidTabId = -1;
 const uint8 kBinaryMessage[] = {0x01, 0x02, 0x03, 0x04};
 
 bool ArePresentationSessionMessagesEqual(
     const content::PresentationSessionMessage* expected,
@@ skipping 97 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestProcessManager);
 };
 
 // Mockable class for awaiting RegisterMediaRouteProvider callbacks.
 class RegisterMediaRouteProviderHandler {
  public:
   MOCK_METHOD1(Invoke, void(const std::string& instance_id));
 };
 
 TEST_F(MediaRouterMojoImplTest, CreateRoute) {
-  MediaRoute expected_route(kRouteId, MediaSource(std::string(kSource)),
+  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;
 
   // 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_,
               CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
                           mojo::String(kOrigin), kInvalidTabId, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& sink,
           const mojo::String& presentation_id, const mojo::String& origin,
           int tab_id,
           const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
         cb.Run(route.Pass(), mojo::String());
       }));
-
   // MediaRouterMojoImpl will start observing local displayable routes as a
   // result of having one created.
-  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaRoutes());
+  EXPECT_CALL(mock_media_route_provider_,
+      StartObservingMediaRoutes(mojo::String("")));
 
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(Pointee(Equals(expected_route)), Not(""), ""));
   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);
   ProcessEventLoop();
 }
@@ skipping 14 matching lines @@
   EXPECT_CALL(handler, Invoke(nullptr, "", kError));
   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);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRoute) {
-  MediaRoute expected_route(kRouteId, MediaSource(std::string(kSource)),
+  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;
 
   // 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, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& presentation_id,
           const mojo::String& origin, int tab_id,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(route.Pass(), mojo::String());
       }));
 
   // MediaRouterMojoImpl will start observing local displayable routes as a
   // result of having one created.
-  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaRoutes());
+  EXPECT_CALL(mock_media_route_provider_,
+      StartObservingMediaRoutes(mojo::String("")));
 
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(Pointee(Equals(expected_route)), Not(""), ""));
   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);
   ProcessEventLoop();
 }
@@ skipping 12 matching lines @@
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(nullptr, "", kError));
   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);
   ProcessEventLoop();
 }
 
+TEST_F(MediaRouterMojoImplTest, JoinRouteByRouteId) {
+  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;
+
+  std::string expected_presentation_id("non-local-join_");
+  expected_presentation_id += kRouteId;
+  // 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(expected_presentation_id),
+                        mojo::String(kOrigin), kInvalidTabId, _))
+      .WillOnce(Invoke([&route](
+          const mojo::String& source, const mojo::String& presentation_id,
+          const mojo::String& origin, int tab_id,
+          const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
+        cb.Run(route.Pass(), mojo::String());
+      }));
+  EXPECT_CALL(mock_media_route_provider_,
+      StartObservingMediaRoutes(mojo::String("")));

[mark a. foltz, 2015/12/09 00:48:17]

Shouldn't a real media source be passed to StartObservingMediaRoutes for this
test case?

[matt.boetger, 2015/12/15 19:21:20]

No, because this StartObservingMediaRoutes comes from the
MediaRouterMojoImpl::RouteResponseReceived method in which it resets it's own
local routes_observer without a media source.

+
+  RouteResponseCallbackHandler handler;
+  EXPECT_CALL(handler, Invoke(Pointee(Equals(expected_route)), Not(""), ""));
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  route_response_callbacks.push_back(base::Bind(
+      &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
+  router()->JoinRouteByRouteId(kSource, kRouteId, GURL(kOrigin), nullptr,
+                      route_response_callbacks);
+  ProcessEventLoop();
+}
+
+TEST_F(MediaRouterMojoImplTest, JoinRouteByRouteIdFails) {
+  std::string expected_presentation_id("non-local-join_");
+  expected_presentation_id += kRouteId;
+  EXPECT_CALL(mock_media_route_provider_,
+              JoinRoute(mojo::String(kSource),
+                        mojo::String(expected_presentation_id),
+                        mojo::String(kOrigin), kInvalidTabId, _))
+      .WillOnce(Invoke(
+          [](const mojo::String& source, const mojo::String& presentation_id,
+             const mojo::String& origin, int tab_id,
+             const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
+            cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError));
+          }));
+
+  RouteResponseCallbackHandler handler;
+  EXPECT_CALL(handler, Invoke(nullptr, "", kError));
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  route_response_callbacks.push_back(base::Bind(
+      &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
+  router()->JoinRouteByRouteId(kSource, kRouteId, GURL(kOrigin), nullptr,
+                      route_response_callbacks);
+  ProcessEventLoop();
+}
+
 TEST_F(MediaRouterMojoImplTest, CloseRoute) {
   EXPECT_CALL(mock_media_route_provider_, CloseRoute(mojo::String(kRouteId)));
   router()->CloseRoute(kRouteId);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, HandleIssue) {
   MockIssuesObserver issue_observer1(router());
   MockIssuesObserver issue_observer2(router());
   issue_observer1.RegisterObserver();
@@ skipping 190 matching lines @@
   EXPECT_CALL(mock_media_route_provider_,
               StopObservingMediaSinks(mojo::String(kSource2)))
       .Times(1);
   sinks_observer.reset();   // Unregisters kSource from router().
   sinks_observer2.reset();  // Unregisters kSource2 from router().
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaRoutesObserver) {
   MockMediaRouter mock_router;
-  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaRoutes()).Times(2);
+  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);
 
   MediaRoutesObserver* observer_captured;
   EXPECT_CALL(mock_router, RegisterMediaRoutesObserver(_))
-      .Times(2)
+      .Times(3)
       .WillRepeatedly(SaveArg<0>(&observer_captured));
-  MockMediaRoutesObserver routes_observer(&mock_router);
+  MockMediaRoutesObserver routes_observer(&mock_router, media_source.id());
   EXPECT_EQ(observer_captured, &routes_observer);
-  MockMediaRoutesObserver extra_routes_observer(&mock_router);
+  MockMediaRoutesObserver extra_routes_observer(&mock_router,
+      media_source.id());
   EXPECT_EQ(observer_captured, &extra_routes_observer);
+  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, MediaSource(kSource), kSinkId,
+  expected_routes.push_back(MediaRoute(kRouteId, media_source, kSinkId,
                                        kDescription, false, "", false));
-  expected_routes.push_back(MediaRoute(kRouteId2, MediaSource(kSource), kSinkId,
+  expected_routes.push_back(MediaRoute(kRouteId2, media_source, kSinkId,
                                        kDescription, false, "", false));
+  std::vector<MediaRoute::Id> expected_joinable_route_ids;
+  expected_joinable_route_ids.push_back(kJoinableRouteId);
+  expected_joinable_route_ids.push_back(kJoinableRouteId2);
+
+  mojo::Array<mojo::String> mojo_joinable_routes(2);
+  mojo_joinable_routes[0] = kJoinableRouteId;
+  mojo_joinable_routes[1] = kJoinableRouteId2;
 
   mojo::Array<interfaces::MediaRoutePtr> mojo_routes(2);
   mojo_routes[0] = interfaces::MediaRoute::New();
   mojo_routes[0]->media_route_id = kRouteId;
   mojo_routes[0]->media_source = kSource;
   mojo_routes[0]->media_sink_id = kSinkId;
   mojo_routes[0]->description = kDescription;
   mojo_routes[0]->is_local = 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;
 
   EXPECT_CALL(routes_observer,
-              OnRoutesUpdated(SequenceEquals(expected_routes)));
+              OnRoutesUpdated(SequenceEquals(expected_routes),
+                              expected_joinable_route_ids));
   EXPECT_CALL(extra_routes_observer,
-              OnRoutesUpdated(SequenceEquals(expected_routes)));
-  media_router_proxy_->OnRoutesUpdated(mojo_routes.Pass());
+              OnRoutesUpdated(SequenceEquals(expected_routes),
+                              expected_joinable_route_ids));
+  EXPECT_CALL(different_routes_observer,
+              OnRoutesUpdated(SequenceEquals(expected_routes),
+                              expected_joinable_route_ids)).Times(0);
+  media_router_proxy_->OnRoutesUpdated(media_source.id(),
+                                       mojo_routes.Pass(),
+                                       mojo_joinable_routes.Pass());
   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);
-  EXPECT_CALL(mock_media_route_provider_, StopObservingMediaRoutes());
+  router()->UnregisterMediaRoutesObserver(&different_routes_observer);
+  EXPECT_CALL(mock_media_route_provider_,
+              StopObservingMediaRoutes(mojo::String(media_source.id())));
+  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) {
@@ skipping 501 matching lines @@
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_, CloseRoute(mojo::String(kRouteId2)))
       .Times(kMaxPendingRequests);
   RegisterMediaRouteProvider();
   ProcessEventLoop();
 }
 
 }  // namespace media_router