[Media Router] Wiring for searching route providers for new sinks.

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 104 matching lines @@
     DoInvoke(result.route(), result.presentation_id(), result.error(),
              result.result_code());
   }
   MOCK_METHOD4(DoInvoke,
                void(const MediaRoute* route,
                     const std::string& presentation_id,
                     const std::string& error_text,
                     RouteRequestResult::ResultCode result_code));
 };
 
+class SinkResponseCallbackHandler {
+public:
+  MOCK_METHOD1(Invoke, void(const std::string& sink_id));
+};
+
 class SendMessageCallbackHandler {
  public:
   MOCK_METHOD1(Invoke, void(bool));
 };
 
 class ListenForMessagesCallbackHandler {
  public:
   ListenForMessagesCallbackHandler(
       ScopedVector<content::PresentationSessionMessage> expected_messages,
       bool pass_ownership)
@@ skipping 1046 matching lines @@
   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();
 }
 
+TEST_F(MediaRouterMojoImplTest, SearchSinksAndCreateRoute) {
+  std::string search_input("input");
+  std::string domain("google.com");
+  MediaSource media_source(kSource);
+  MediaRoute expected_route(kRouteId, media_source, kSinkId2, "", false, "",
+                            false);
+  auto& media_router_proxy = media_router_proxy_;
+
+  EXPECT_CALL(
+      mock_media_route_provider_,
+      SearchSinksAndCreateRoute_(mojo::String(kSinkId), mojo::String(kSource),
+                                 _, _, mojo::String(kOrigin), kInvalidTabId, _,
+                                 false, _))
+      .WillOnce(Invoke([&search_input, &domain, &media_router_proxy](
+          const mojo::String& sink_id, const mojo::String& source,
+          const interfaces::SinkSearchCriteriaPtr& search_criteria,
+          const mojo::String& presentation_id, const mojo::String& origin,
+          int32_t tab_id, int64_t timeout_millis, bool off_the_record,
+          const interfaces::MediaRouteProvider::
+              SearchSinksAndCreateRouteCallback& cb) {
+        interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
+        route->media_source = source;
+        route->media_sink_id = kSinkId2;
+        route->media_route_id = kRouteId;
+        route->description = kDescription;
+        route->is_local = true;
+        route->for_display = true;
+        route->off_the_record = off_the_record;
+        EXPECT_EQ(search_input, search_criteria->input);
+        EXPECT_EQ(domain, search_criteria->domain);
+        media_router_proxy->OnSearchSinkIdReceived(sink_id, kSinkId2);
+        cb.Run(std::move(route), mojo::String(),
+               interfaces::RouteRequestResultCode::OK);
+      }));
+
+  base::RunLoop run_loop;
+  base::RunLoop run_loop2;
+  SinkResponseCallbackHandler sink_handler;
+  EXPECT_CALL(sink_handler, Invoke(kSinkId2))
+      .WillOnce(InvokeWithoutArgs([&run_loop] { run_loop.Quit(); }));
+  RouteResponseCallbackHandler route_handler;
+  EXPECT_CALL(route_handler, DoInvoke(Pointee(Equals(expected_route)), Not(""),
+                                      "", RouteRequestResult::OK))
+      .WillOnce(InvokeWithoutArgs([&run_loop2] { run_loop2.Quit(); }));
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  MediaSinkSearchResponseCallback sink_callback = base::Bind(
+      &SinkResponseCallbackHandler::Invoke, base::Unretained(&sink_handler));
+  route_response_callbacks.push_back(base::Bind(
+      &RouteResponseCallbackHandler::Invoke, base::Unretained(&route_handler)));
+  router()->SearchSinksAndCreateRoute(
+      kSinkId, kSource, search_input, domain, GURL(kOrigin), nullptr,
+      route_response_callbacks, sink_callback,
+      base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
+  run_loop.Run();
+  run_loop2.Run();
+}
+
 class MediaRouterMojoExtensionTest : public ::testing::Test {
  public:
   MediaRouterMojoExtensionTest()
       : process_manager_(nullptr),
         message_loop_(mojo::common::MessagePumpMojo::Create()) {}
 
   ~MediaRouterMojoExtensionTest() override {}
 
  protected:
   void SetUp() override {
@@ skipping 365 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