[Media Router] Implement JoinRoute + update CreateRoute 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 27 matching lines @@
 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 kSink[] = "sink";
 const char kSink2[] = "sink2";
 const char kSinkName[] = "sinkName";
+const char kPresentationId[] = "presentationId";
+const char kOrigin[] = "http://origin/";
+const int kTabId = 123;
 
 }  // namespace
 
 // Adapts Invoke(), which takes a move-only scoped_ptr parameter (not mockable)
 // to a variant that accepts raw pointers instead (mock friendly).
 class RouteResponseCallbackHandler {
  public:
   void Invoke(scoped_ptr<MediaRoute> route, const std::string& error_text) {
     InvokeObserver(route.get(), error_text);
   }
@@ skipping 58 matching lines @@
   route->media_sink = interfaces::MediaSink::New();
   route->media_sink->sink_id = kSink;
   route->media_sink->name = kSinkName;
   route->media_route_id = kRouteId;
   route->description = kDescription;
 
   // 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_mojo_media_router_service_,
-              CreateRoute(mojo::String(kSource), mojo::String(kSink), _))
-      .WillOnce(Invoke(
-          [&route](const mojo::String& source, const mojo::String& sink,
-                   const interfaces::MediaRouter::CreateRouteCallback& cb) {
-            cb.Run(route.Pass(), mojo::String());
-          }));
+              CreateRoute(mojo::String(kSource), mojo::String(kSink), _,
+                          mojo::String(kOrigin), kTabId, _))
+      .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::MediaRouter::CreateRouteCallback& cb) {
+        cb.Run(route.Pass(), mojo::String());
+      }));
 
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, InvokeObserver(Pointee(Equals(expected_route)), ""));
-  router()->CreateRoute(kSource, kSink,
+  router()->CreateRoute(kSource, kSink, GURL(kOrigin), kTabId,
                         base::Bind(&RouteResponseCallbackHandler::Invoke,
                                    base::Unretained(&handler)));
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteFails) {
   EXPECT_CALL(mock_mojo_media_router_service_,
-              CreateRoute(mojo::String(kSource), mojo::String(kSink), _))
-      .WillOnce(
-          Invoke([](const mojo::String& source, const mojo::String& sink,
-                    const interfaces::MediaRouter::CreateRouteCallback& cb) {
+              CreateRoute(mojo::String(kSource), mojo::String(kSink), _,
+                          mojo::String(kOrigin), kTabId, _))
+      .WillOnce(Invoke([](
+          const mojo::String& source, const mojo::String& sink,
+          const mojo::String& presentation_id, const mojo::String& origin,
+          int tab_id, const interfaces::MediaRouter::CreateRouteCallback& cb) {
+        cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError));
+      }));
+
+  RouteResponseCallbackHandler handler;
+  EXPECT_CALL(handler, InvokeObserver(nullptr, kError));
+  router()->CreateRoute(kSource, kSink, GURL(kOrigin), kTabId,
+                        base::Bind(&RouteResponseCallbackHandler::Invoke,
+                                   base::Unretained(&handler)));
+  ProcessEventLoop();
+}
+
+TEST_F(MediaRouterMojoImplTest, JoinRoute) {
+  MediaRoute expected_route(kRouteId, MediaSource(std::string(kSource)),
+                            MediaSink(kSink, kSinkName), "", false);
+  interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
+  route->media_source = kSource;
+  route->media_sink = interfaces::MediaSink::New();
+  route->media_sink->sink_id = kSink;
+  route->media_sink->name = kSinkName;
+  route->media_route_id = kRouteId;
+  route->description = kDescription;
+
+  // 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_mojo_media_router_service_,
+              JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
+                        mojo::String(kOrigin), kTabId, _))
+      .WillOnce(Invoke([&route](
+          const mojo::String& source, const mojo::String& presentation_id,
+          const mojo::String& origin, int tab_id,
+          const interfaces::MediaRouter::JoinRouteCallback& cb) {
+        cb.Run(route.Pass(), mojo::String());
+      }));
+
+  RouteResponseCallbackHandler handler;
+  EXPECT_CALL(handler, InvokeObserver(Pointee(Equals(expected_route)), ""));
+  router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), kTabId,
+                      base::Bind(&RouteResponseCallbackHandler::Invoke,
+                                 base::Unretained(&handler)));
+  ProcessEventLoop();
+}
+
+TEST_F(MediaRouterMojoImplTest, JoinRouteFails) {
+  EXPECT_CALL(mock_mojo_media_router_service_,
+              JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
+                        mojo::String(kOrigin), kTabId, _))
+      .WillOnce(Invoke(
+          [](const mojo::String& source, const mojo::String& presentation_id,
+             const mojo::String& origin, int tab_id,
+             const interfaces::MediaRouter::JoinRouteCallback& cb) {
             cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError));
           }));
 
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, InvokeObserver(nullptr, kError));
-  router()->CreateRoute(kSource, kSink,
-                        base::Bind(&RouteResponseCallbackHandler::Invoke,
-                                   base::Unretained(&handler)));
+  router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), kTabId,
+                      base::Bind(&RouteResponseCallbackHandler::Invoke,
+                                 base::Unretained(&handler)));
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, CloseRoute) {
   EXPECT_CALL(mock_mojo_media_router_service_,
               CloseRoute(mojo::String(kRouteId)));
   router()->CloseRoute(kRouteId);
   ProcessEventLoop();
 }
 
@@ skipping 222 matching lines @@
               CloseRoute(mojo::String(kRouteId2)));
   binding.reset(new mojo::Binding<interfaces::MediaRouter>(
       &mock_mojo_media_router_service, mojo::GetProxy(&mojo_media_router)));
   mojo_media_router_observer->ProvideMediaRouter(
       mojo_media_router.Pass(), base::Bind(&ProvideMediaRouterHandler::Invoke,
                                            base::Unretained(&provide_handler)));
   message_loop.RunUntilIdle();
 }
 
 }  // namespace media_router