chrome/browser/media/router/test/media_router_mojo_test.cc - chromium/src.git - Git at Google

 // Copyright 2015 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "chrome/browser/media/router/test/media_router_mojo_test.h"

 #include <utility>

 #include "base/compiler_specific.h"
 #include "base/functional/bind.h"
 #include "base/run_loop.h"

 using testing::_;
 using testing::ByRef;
 using testing::NiceMock;
 using testing::Not;
 using testing::Pointee;
 using testing::WithArg;

 namespace media_router {

 namespace {

 const char kDescription[] = "description";
 const char kMessage[] = "message";
 const char kOrigin[] = "http://origin/";
 const char kPresentationId[] = "presentationId";
 const char kRouteId[] = "routeId";
 const char kSource[] = "source1";
 const char kSinkId[] = "sink";
 const int kInvalidFrameTreeNodeId = -1;
 const int kTimeoutMillis = 5 * 1000;
 const uint8_t kBinaryMessage[] = {0x01, 0x02, 0x03, 0x04};

 MATCHER_P(Equals, value, "") {
   return arg.Equals(value.get());
 }

 // Creates a media route whose ID is |kRouteId|.
 MediaRoute CreateMediaRoute() {
   MediaRoute route(kRouteId, MediaSource(kSource), kSinkId, kDescription, true);
   route.set_presentation_id(kPresentationId);
   route.set_controller_type(RouteControllerType::kGeneric);
   return route;
 }

 class SendMessageCallbackHandler {
  public:
   MOCK_METHOD1(Invoke, void(bool));
 };

 class SinkResponseCallbackHandler {
  public:
   MOCK_METHOD1(Invoke, void(const std::string& sink_id));
 };

 }  // namespace

 MockMediaRouteProvider::MockMediaRouteProvider() = default;

 MockMediaRouteProvider::~MockMediaRouteProvider() = default;

 void MockMediaRouteProvider::RouteRequestSuccess(RouteCallback& cb) const {
   DCHECK(route_);
   std::move(cb).Run(route_, nullptr, std::string(),
                     mojom::RouteRequestResultCode::OK);
 }

 void MockMediaRouteProvider::RouteRequestTimeout(RouteCallback& cb) const {
   std::move(cb).Run(std::nullopt, nullptr, std::string("error"),
                     mojom::RouteRequestResultCode::TIMED_OUT);
 }

 void MockMediaRouteProvider::TerminateRouteSuccess(
     TerminateRouteCallback& cb) const {
   std::move(cb).Run(std::string(), mojom::RouteRequestResultCode::OK);
 }

 void MockMediaRouteProvider::BindMediaControllerSuccess(
     BindMediaControllerCallback& cb) const {
   std::move(cb).Run(true);
 }

 void MockMediaRouteProvider::SetRouteToReturn(const MediaRoute& route) {
   route_ = route;
 }

 MockMediaStatusObserver::MockMediaStatusObserver(
     mojo::PendingReceiver<mojom::MediaStatusObserver> receiver)
     : receiver_(this, std::move(receiver)) {}

 MockMediaStatusObserver::~MockMediaStatusObserver() = default;

 MockMediaController::MockMediaController() = default;

 MockMediaController::~MockMediaController() = default;

 void MockMediaController::Bind(
     mojo::PendingReceiver<mojom::MediaController> receiver) {
   receiver_.reset();
   receiver_.Bind(std::move(receiver));
 }

 mojo::PendingRemote<mojom::MediaController>
 MockMediaController::BindInterfaceRemote() {
   return receiver_.BindNewPipeAndPassRemote();
 }

 void MockMediaController::CloseReceiver() {
   receiver_.reset();
 }

 MediaRouterMojoTest::MediaRouterMojoTest() = default;

 MediaRouterMojoTest::~MediaRouterMojoTest() = default;

 void MediaRouterMojoTest::RegisterCastProvider() {
   RegisterMediaRouteProvider(&mock_cast_provider_,
                              mojom::MediaRouteProviderId::CAST);
 }

 void MediaRouterMojoTest::RegisterWiredDisplayProvider() {
   RegisterMediaRouteProvider(&mock_wired_display_provider_,
                              mojom::MediaRouteProviderId::WIRED_DISPLAY);
 }

 void MediaRouterMojoTest::SetUp() {
   media_router_ = CreateMediaRouter();
   RegisterCastProvider();
   media_router_->Initialize();
   base::RunLoop().RunUntilIdle();
 }

 void MediaRouterMojoTest::TearDown() {
   sinks_observer_.reset();
   routes_observer_.reset();
   media_router_->Shutdown();
   media_router_.reset();
 }

 void MediaRouterMojoTest::ProvideTestRoute(
     mojom::MediaRouteProviderId provider_id,
     const MediaRoute::Id& route_id) {
   if (!routes_observer_) {
     routes_observer_ = std::make_unique<MediaRoutesObserver>(router());
   }
   MediaRoute route = CreateMediaRoute();
   route.set_media_route_id(route_id);
   router()->OnRoutesUpdated(provider_id, {route});
 }

 void MediaRouterMojoTest::ProvideTestSink(
     mojom::MediaRouteProviderId provider_id,
     const MediaSink::Id& sink_id) {
   if (!sinks_observer_) {
     sinks_observer_ = std::make_unique<NiceMock<MockMediaSinksObserver>>(
         router(), MediaSource(kSource), url::Origin::Create(GURL(kOrigin)));
     router()->RegisterMediaSinksObserver(sinks_observer_.get());
   }

   MediaSinkInternal test_sink;
   test_sink.sink().set_sink_id(sink_id);
   test_sink.sink().set_provider_id(provider_id);
   router()->OnSinksReceived(provider_id, kSource, {test_sink}, {});
 }

 void MediaRouterMojoTest::TestCreateRoute() {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, kDescription,
                             true);
   expected_route.set_presentation_id(kPresentationId);
   expected_route.set_controller_type(RouteControllerType::kGeneric);

   ProvideTestSink(mojom::MediaRouteProviderId::CAST, kSinkId);

   // 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_cast_provider_,
               CreateRouteInternal(kSource, kSinkId, _,
                                   url::Origin::Create(GURL(kOrigin)),
                                   kInvalidFrameTreeNodeId, _, _))
       .WillOnce(
           WithArg<6>([](mojom::MediaRouteProvider::CreateRouteCallback& cb) {
             std::move(cb).Run(CreateMediaRoute(), nullptr, std::string(),
                               mojom::RouteRequestResultCode::OK);
           }));

   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, DoInvoke(Pointee(expected_route), Not(""), "",
                                 mojom::RouteRequestResultCode::OK, _));
   router()->CreateRoute(kSource, kSinkId, url::Origin::Create(GURL(kOrigin)),
                         nullptr,
                         base::BindOnce(&RouteResponseCallbackHandler::Invoke,
                                        base::Unretained(&handler)),
                         base::Milliseconds(kTimeoutMillis));
   base::RunLoop().RunUntilIdle();
 }

 void MediaRouterMojoTest::TestJoinRoute(const std::string& presentation_id) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, kDescription,
                             true);
   expected_route.set_presentation_id(kPresentationId);
   expected_route.set_controller_type(RouteControllerType::kGeneric);

   MediaRoute route = CreateMediaRoute();
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
   std::vector<MediaRoute> routes;
   routes.push_back(route);
   router()->OnRoutesUpdated(mojom::MediaRouteProviderId::CAST, routes);
   EXPECT_TRUE(router()->HasJoinableRoute());

   // 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_cast_provider_,
               JoinRouteInternal(kSource, presentation_id,
                                 url::Origin::Create(GURL(kOrigin)),
                                 kInvalidFrameTreeNodeId,
                                 base::Milliseconds(kTimeoutMillis), _))
       .WillOnce(WithArg<5>(
           [&route](mojom::MediaRouteProvider::JoinRouteCallback& cb) {
             std::move(cb).Run(route, nullptr, std::string(),
                               mojom::RouteRequestResultCode::OK);
           }));

   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, DoInvoke(Pointee(expected_route), Not(""), "",
                                 mojom::RouteRequestResultCode::OK, _));
   router()->JoinRoute(kSource, presentation_id,
                       url::Origin::Create(GURL(kOrigin)), nullptr,
                       base::BindOnce(&RouteResponseCallbackHandler::Invoke,
                                      base::Unretained(&handler)),
                       base::Milliseconds(kTimeoutMillis));
   base::RunLoop().RunUntilIdle();
 }

 void MediaRouterMojoTest::TestTerminateRoute() {
   ProvideTestRoute(mojom::MediaRouteProviderId::CAST, kRouteId);
   EXPECT_CALL(mock_cast_provider_, TerminateRouteInternal(kRouteId, _))
       .WillOnce([](const std::string& route_id,
                    mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
         std::move(cb).Run(std::nullopt, mojom::RouteRequestResultCode::OK);
       });
   router()->TerminateRoute(kRouteId);
   base::RunLoop().RunUntilIdle();
 }

 void MediaRouterMojoTest::TestSendRouteMessage() {
   ProvideTestRoute(mojom::MediaRouteProviderId::CAST, kRouteId);
   EXPECT_CALL(mock_cast_provider_, SendRouteMessage(kRouteId, kMessage));
   router()->SendRouteMessage(kRouteId, kMessage);
   base::RunLoop().RunUntilIdle();
 }

 void MediaRouterMojoTest::TestSendRouteBinaryMessage() {
   ProvideTestRoute(mojom::MediaRouteProviderId::CAST, kRouteId);
   auto expected_binary_data = std::make_unique<std::vector<uint8_t>>(
       std::begin(kBinaryMessage), std::end(kBinaryMessage));
   EXPECT_CALL(mock_cast_provider_, SendRouteBinaryMessage(kRouteId, _))
       .WillOnce([](const MediaRoute::Id& route_id,
                    const std::vector<uint8_t>& data) {
         UNSAFE_TODO(EXPECT_EQ(
             0, memcmp(kBinaryMessage, &(data[0]), std::size(kBinaryMessage))));
       });

   router()->SendRouteBinaryMessage(kRouteId, std::move(expected_binary_data));
   base::RunLoop().RunUntilIdle();
 }

 void MediaRouterMojoTest::TestDetachRoute() {
   ProvideTestRoute(mojom::MediaRouteProviderId::CAST, kRouteId);
   EXPECT_CALL(mock_cast_provider_, DetachRoute(kRouteId));
   router()->DetachRoute(kRouteId);
   base::RunLoop().RunUntilIdle();
 }

 void MediaRouterMojoTest::RegisterMediaRouteProvider(
     mojom::MediaRouteProvider* provider,
     mojom::MediaRouteProviderId provider_id) {
   mojo::PendingRemote<mojom::MediaRouteProvider> mojo_provider;
   provider_receivers_.Add(provider,
                           mojo_provider.InitWithNewPipeAndPassReceiver());
   media_router_->RegisterMediaRouteProvider(provider_id,
                                             std::move(mojo_provider));
 }

 RouteResponseCallbackHandler::RouteResponseCallbackHandler() = default;
 RouteResponseCallbackHandler::~RouteResponseCallbackHandler() = default;

 void RouteResponseCallbackHandler::Invoke(
     mojom::RoutePresentationConnectionPtr connection,
     const RouteRequestResult& result) {
   DoInvoke(result.route(), result.presentation_id(), result.error(),
            result.result_code(), connection);
 }

 }  // namespace media_router
	// Copyright 2015 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "chrome/browser/media/router/test/media_router_mojo_test.h"

	#include <utility>

	#include "base/compiler_specific.h"
	#include "base/functional/bind.h"
	#include "base/run_loop.h"

	using testing::_;
	using testing::ByRef;
	using testing::NiceMock;
	using testing::Not;
	using testing::Pointee;
	using testing::WithArg;

	namespace media_router {

	namespace {

	const char kDescription[] = "description";
	const char kMessage[] = "message";
	const char kOrigin[] = "http://origin/";
	const char kPresentationId[] = "presentationId";
	const char kRouteId[] = "routeId";
	const char kSource[] = "source1";
	const char kSinkId[] = "sink";
	const int kInvalidFrameTreeNodeId = -1;
	const int kTimeoutMillis = 5 * 1000;
	const uint8_t kBinaryMessage[] = {0x01, 0x02, 0x03, 0x04};

	MATCHER_P(Equals, value, "") {
	return arg.Equals(value.get());
	}

	// Creates a media route whose ID is \|kRouteId\|.
	MediaRoute CreateMediaRoute() {
	MediaRoute route(kRouteId, MediaSource(kSource), kSinkId, kDescription, true);
	route.set_presentation_id(kPresentationId);
	route.set_controller_type(RouteControllerType::kGeneric);
	return route;
	}

	class SendMessageCallbackHandler {
	public:
	MOCK_METHOD1(Invoke, void(bool));
	};

	class SinkResponseCallbackHandler {
	public:
	MOCK_METHOD1(Invoke, void(const std::string& sink_id));
	};

	} // namespace

	MockMediaRouteProvider::MockMediaRouteProvider() = default;

	MockMediaRouteProvider::~MockMediaRouteProvider() = default;

	void MockMediaRouteProvider::RouteRequestSuccess(RouteCallback& cb) const {
	DCHECK(route_);
	std::move(cb).Run(route_, nullptr, std::string(),
	mojom::RouteRequestResultCode::OK);
	}

	void MockMediaRouteProvider::RouteRequestTimeout(RouteCallback& cb) const {
	std::move(cb).Run(std::nullopt, nullptr, std::string("error"),
	mojom::RouteRequestResultCode::TIMED_OUT);
	}

	void MockMediaRouteProvider::TerminateRouteSuccess(
	TerminateRouteCallback& cb) const {
	std::move(cb).Run(std::string(), mojom::RouteRequestResultCode::OK);
	}

	void MockMediaRouteProvider::BindMediaControllerSuccess(
	BindMediaControllerCallback& cb) const {
	std::move(cb).Run(true);
	}

	void MockMediaRouteProvider::SetRouteToReturn(const MediaRoute& route) {
	route_ = route;
	}

	MockMediaStatusObserver::MockMediaStatusObserver(
	mojo::PendingReceiver<mojom::MediaStatusObserver> receiver)
	: receiver_(this, std::move(receiver)) {}

	MockMediaStatusObserver::~MockMediaStatusObserver() = default;

	MockMediaController::MockMediaController() = default;

	MockMediaController::~MockMediaController() = default;

	void MockMediaController::Bind(
	mojo::PendingReceiver<mojom::MediaController> receiver) {
	receiver_.reset();
	receiver_.Bind(std::move(receiver));
	}

	mojo::PendingRemote<mojom::MediaController>
	MockMediaController::BindInterfaceRemote() {
	return receiver_.BindNewPipeAndPassRemote();
	}

	void MockMediaController::CloseReceiver() {
	receiver_.reset();
	}

	MediaRouterMojoTest::MediaRouterMojoTest() = default;

	MediaRouterMojoTest::~MediaRouterMojoTest() = default;

	void MediaRouterMojoTest::RegisterCastProvider() {
	RegisterMediaRouteProvider(&mock_cast_provider_,
	mojom::MediaRouteProviderId::CAST);
	}

	void MediaRouterMojoTest::RegisterWiredDisplayProvider() {
	RegisterMediaRouteProvider(&mock_wired_display_provider_,
	mojom::MediaRouteProviderId::WIRED_DISPLAY);
	}

	void MediaRouterMojoTest::SetUp() {
	media_router_ = CreateMediaRouter();
	RegisterCastProvider();
	media_router_->Initialize();
	base::RunLoop().RunUntilIdle();
	}

	void MediaRouterMojoTest::TearDown() {
	sinks_observer_.reset();
	routes_observer_.reset();
	media_router_->Shutdown();
	media_router_.reset();
	}

	void MediaRouterMojoTest::ProvideTestRoute(
	mojom::MediaRouteProviderId provider_id,
	const MediaRoute::Id& route_id) {
	if (!routes_observer_) {
	routes_observer_ = std::make_unique<MediaRoutesObserver>(router());
	}
	MediaRoute route = CreateMediaRoute();
	route.set_media_route_id(route_id);
	router()->OnRoutesUpdated(provider_id, {route});
	}

	void MediaRouterMojoTest::ProvideTestSink(
	mojom::MediaRouteProviderId provider_id,
	const MediaSink::Id& sink_id) {
	if (!sinks_observer_) {
	sinks_observer_ = std::make_unique<NiceMock<MockMediaSinksObserver>>(
	router(), MediaSource(kSource), url::Origin::Create(GURL(kOrigin)));
	router()->RegisterMediaSinksObserver(sinks_observer_.get());
	}

	MediaSinkInternal test_sink;
	test_sink.sink().set_sink_id(sink_id);
	test_sink.sink().set_provider_id(provider_id);
	router()->OnSinksReceived(provider_id, kSource, {test_sink}, {});
	}

	void MediaRouterMojoTest::TestCreateRoute() {
	MediaSource media_source(kSource);
	MediaRoute expected_route(kRouteId, media_source, kSinkId, kDescription,
	true);
	expected_route.set_presentation_id(kPresentationId);
	expected_route.set_controller_type(RouteControllerType::kGeneric);

	ProvideTestSink(mojom::MediaRouteProviderId::CAST, kSinkId);

	// 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_cast_provider_,
	CreateRouteInternal(kSource, kSinkId, _,
	url::Origin::Create(GURL(kOrigin)),
	kInvalidFrameTreeNodeId, _, _))
	.WillOnce(
	WithArg<6>([](mojom::MediaRouteProvider::CreateRouteCallback& cb) {
	std::move(cb).Run(CreateMediaRoute(), nullptr, std::string(),
	mojom::RouteRequestResultCode::OK);
	}));

	RouteResponseCallbackHandler handler;
	EXPECT_CALL(handler, DoInvoke(Pointee(expected_route), Not(""), "",
	mojom::RouteRequestResultCode::OK, _));
	router()->CreateRoute(kSource, kSinkId, url::Origin::Create(GURL(kOrigin)),
	nullptr,
	base::BindOnce(&RouteResponseCallbackHandler::Invoke,
	base::Unretained(&handler)),
	base::Milliseconds(kTimeoutMillis));
	base::RunLoop().RunUntilIdle();
	}

	void MediaRouterMojoTest::TestJoinRoute(const std::string& presentation_id) {
	MediaSource media_source(kSource);
	MediaRoute expected_route(kRouteId, media_source, kSinkId, kDescription,
	true);
	expected_route.set_presentation_id(kPresentationId);
	expected_route.set_controller_type(RouteControllerType::kGeneric);

	MediaRoute route = CreateMediaRoute();
	// Make sure the MR has received an update with the route, so it knows there
	// is a route to join.
	std::vector<MediaRoute> routes;
	routes.push_back(route);
	router()->OnRoutesUpdated(mojom::MediaRouteProviderId::CAST, routes);
	EXPECT_TRUE(router()->HasJoinableRoute());

	// 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_cast_provider_,
	JoinRouteInternal(kSource, presentation_id,
	url::Origin::Create(GURL(kOrigin)),
	kInvalidFrameTreeNodeId,
	base::Milliseconds(kTimeoutMillis), _))
	.WillOnce(WithArg<5>(
	[&route](mojom::MediaRouteProvider::JoinRouteCallback& cb) {
	std::move(cb).Run(route, nullptr, std::string(),
	mojom::RouteRequestResultCode::OK);
	}));

	RouteResponseCallbackHandler handler;
	EXPECT_CALL(handler, DoInvoke(Pointee(expected_route), Not(""), "",
	mojom::RouteRequestResultCode::OK, _));
	router()->JoinRoute(kSource, presentation_id,
	url::Origin::Create(GURL(kOrigin)), nullptr,
	base::BindOnce(&RouteResponseCallbackHandler::Invoke,
	base::Unretained(&handler)),
	base::Milliseconds(kTimeoutMillis));
	base::RunLoop().RunUntilIdle();
	}

	void MediaRouterMojoTest::TestTerminateRoute() {
	ProvideTestRoute(mojom::MediaRouteProviderId::CAST, kRouteId);
	EXPECT_CALL(mock_cast_provider_, TerminateRouteInternal(kRouteId, _))
	.WillOnce([](const std::string& route_id,
	mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
	std::move(cb).Run(std::nullopt, mojom::RouteRequestResultCode::OK);
	});
	router()->TerminateRoute(kRouteId);
	base::RunLoop().RunUntilIdle();
	}

	void MediaRouterMojoTest::TestSendRouteMessage() {
	ProvideTestRoute(mojom::MediaRouteProviderId::CAST, kRouteId);
	EXPECT_CALL(mock_cast_provider_, SendRouteMessage(kRouteId, kMessage));
	router()->SendRouteMessage(kRouteId, kMessage);
	base::RunLoop().RunUntilIdle();
	}

	void MediaRouterMojoTest::TestSendRouteBinaryMessage() {
	ProvideTestRoute(mojom::MediaRouteProviderId::CAST, kRouteId);
	auto expected_binary_data = std::make_unique<std::vector<uint8_t>>(
	std::begin(kBinaryMessage), std::end(kBinaryMessage));
	EXPECT_CALL(mock_cast_provider_, SendRouteBinaryMessage(kRouteId, _))
	.WillOnce([](const MediaRoute::Id& route_id,
	const std::vector<uint8_t>& data) {
	UNSAFE_TODO(EXPECT_EQ(
	0, memcmp(kBinaryMessage, &(data[0]), std::size(kBinaryMessage))));
	});

	router()->SendRouteBinaryMessage(kRouteId, std::move(expected_binary_data));
	base::RunLoop().RunUntilIdle();
	}

	void MediaRouterMojoTest::TestDetachRoute() {
	ProvideTestRoute(mojom::MediaRouteProviderId::CAST, kRouteId);
	EXPECT_CALL(mock_cast_provider_, DetachRoute(kRouteId));
	router()->DetachRoute(kRouteId);
	base::RunLoop().RunUntilIdle();
	}

	void MediaRouterMojoTest::RegisterMediaRouteProvider(
	mojom::MediaRouteProvider* provider,
	mojom::MediaRouteProviderId provider_id) {
	mojo::PendingRemote<mojom::MediaRouteProvider> mojo_provider;
	provider_receivers_.Add(provider,
	mojo_provider.InitWithNewPipeAndPassReceiver());
	media_router_->RegisterMediaRouteProvider(provider_id,
	std::move(mojo_provider));
	}

	RouteResponseCallbackHandler::RouteResponseCallbackHandler() = default;
	RouteResponseCallbackHandler::~RouteResponseCallbackHandler() = default;

	void RouteResponseCallbackHandler::Invoke(
	mojom::RoutePresentationConnectionPtr connection,
	const RouteRequestResult& result) {
	DoInvoke(result.route(), result.presentation_id(), result.error(),
	result.result_code(), connection);
	}

	} // namespace media_router