OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/media/router/browser_presentation_connection_proxy.h" | 5 #include "chrome/browser/media/router/browser_presentation_connection_proxy.h" |
6 | 6 |
7 #include "base/run_loop.h" | 7 #include "base/run_loop.h" |
8 #include "base/test/mock_callback.h" | 8 #include "base/test/mock_callback.h" |
9 #include "chrome/browser/media/router/mock_media_router.h" | 9 #include "chrome/browser/media/router/mock_media_router.h" |
| 10 #include "chrome/browser/media/router/test_helper.h" |
10 #include "chrome/common/media_router/media_source.h" | 11 #include "chrome/common/media_router/media_source.h" |
11 #include "chrome/common/media_router/media_source_helper.h" | 12 #include "chrome/common/media_router/media_source_helper.h" |
| 13 #include "chrome/common/media_router/route_message.h" |
12 #include "content/public/common/presentation_connection_message.h" | 14 #include "content/public/common/presentation_connection_message.h" |
13 #include "content/public/test/test_browser_thread_bundle.h" | 15 #include "content/public/test/test_browser_thread_bundle.h" |
14 #include "testing/gmock/include/gmock/gmock.h" | 16 #include "testing/gmock/include/gmock/gmock.h" |
15 | 17 |
16 using ::testing::_; | 18 using ::testing::_; |
| 19 using ::testing::Invoke; |
17 | 20 |
18 namespace media_router { | 21 namespace media_router { |
19 | 22 |
| 23 using OnMessageCallback = BrowserPresentationConnectionProxy::OnMessageCallback; |
| 24 |
| 25 namespace { |
| 26 |
| 27 void ExpectMessageAndRunCallback( |
| 28 const content::PresentationConnectionMessage& expected_message, |
| 29 const content::PresentationConnectionMessage& message, |
| 30 OnMessageCallback& callback) { |
| 31 EXPECT_EQ(expected_message, message); |
| 32 std::move(callback).Run(true); |
| 33 } |
| 34 |
| 35 } // namespace |
| 36 |
20 constexpr char kMediaRouteId[] = "MockRouteId"; | 37 constexpr char kMediaRouteId[] = "MockRouteId"; |
21 | 38 |
22 class MockPresentationConnectionProxy | |
23 : public NON_EXPORTED_BASE(blink::mojom::PresentationConnection) { | |
24 public: | |
25 // PresentationConnectionMessage is move-only. | |
26 // TODO(crbug.com/729950): Use MOCK_METHOD directly once GMock gets the | |
27 // move-only type support. | |
28 void OnMessage(content::PresentationConnectionMessage message, | |
29 OnMessageCallback cb) { | |
30 OnMessageInternal(message, cb); | |
31 } | |
32 MOCK_METHOD2(OnMessageInternal, | |
33 void(const content::PresentationConnectionMessage&, | |
34 OnMessageCallback&)); | |
35 MOCK_METHOD1(DidChangeState, | |
36 void(content::PresentationConnectionState state)); | |
37 MOCK_METHOD0(OnClose, void()); | |
38 }; | |
39 | |
40 class BrowserPresentationConnectionProxyTest : public ::testing::Test { | 39 class BrowserPresentationConnectionProxyTest : public ::testing::Test { |
41 public: | 40 public: |
42 BrowserPresentationConnectionProxyTest() = default; | 41 BrowserPresentationConnectionProxyTest() = default; |
43 | 42 |
44 void SetUp() override { | 43 void SetUp() override { |
45 mock_controller_connection_proxy_ = | 44 mock_controller_connection_proxy_ = |
46 base::MakeUnique<MockPresentationConnectionProxy>(); | 45 base::MakeUnique<MockPresentationConnectionProxy>(); |
47 blink::mojom::PresentationConnectionPtr controller_connection_ptr; | 46 blink::mojom::PresentationConnectionPtr controller_connection_ptr; |
48 mojo::Binding<blink::mojom::PresentationConnection> binding( | 47 binding_.reset(new mojo::Binding<blink::mojom::PresentationConnection>( |
49 mock_controller_connection_proxy_.get(), | 48 mock_controller_connection_proxy_.get(), |
50 mojo::MakeRequest(&controller_connection_ptr)); | 49 mojo::MakeRequest(&controller_connection_ptr))); |
| 50 EXPECT_CALL(mock_router_, RegisterRouteMessageObserver(_)); |
51 EXPECT_CALL( | 51 EXPECT_CALL( |
52 *mock_controller_connection_proxy_, | 52 *mock_controller_connection_proxy_, |
53 DidChangeState(content::PRESENTATION_CONNECTION_STATE_CONNECTED)); | 53 DidChangeState(content::PRESENTATION_CONNECTION_STATE_CONNECTED)); |
54 | 54 |
55 blink::mojom::PresentationConnectionPtr receiver_connection_ptr; | 55 blink::mojom::PresentationConnectionPtr receiver_connection_ptr; |
56 | 56 |
57 base::RunLoop run_loop; | 57 base::RunLoop run_loop; |
58 browser_connection_proxy_ = | 58 browser_connection_proxy_ = |
59 base::MakeUnique<BrowserPresentationConnectionProxy>( | 59 base::MakeUnique<BrowserPresentationConnectionProxy>( |
60 &mock_router_, "MockRouteId", | 60 &mock_router_, "MockRouteId", |
61 mojo::MakeRequest(&receiver_connection_ptr), | 61 mojo::MakeRequest(&receiver_connection_ptr), |
62 std::move(controller_connection_ptr)); | 62 std::move(controller_connection_ptr)); |
63 run_loop.RunUntilIdle(); | 63 run_loop.RunUntilIdle(); |
64 } | 64 } |
65 | 65 |
66 void TearDown() override { | 66 void TearDown() override { |
| 67 EXPECT_CALL(mock_router_, UnregisterRouteMessageObserver(_)); |
67 browser_connection_proxy_.reset(); | 68 browser_connection_proxy_.reset(); |
| 69 binding_.reset(); |
68 mock_controller_connection_proxy_.reset(); | 70 mock_controller_connection_proxy_.reset(); |
69 } | 71 } |
70 | 72 |
| 73 MockPresentationConnectionProxy* controller_connection_proxy() { |
| 74 return mock_controller_connection_proxy_.get(); |
| 75 } |
| 76 |
71 BrowserPresentationConnectionProxy* browser_connection_proxy() { | 77 BrowserPresentationConnectionProxy* browser_connection_proxy() { |
72 return browser_connection_proxy_.get(); | 78 return browser_connection_proxy_.get(); |
73 } | 79 } |
74 | 80 |
75 MockMediaRouter* mock_router() { return &mock_router_; } | 81 MockMediaRouter* mock_router() { return &mock_router_; } |
76 | 82 |
77 private: | 83 private: |
78 std::unique_ptr<MockPresentationConnectionProxy> | 84 std::unique_ptr<MockPresentationConnectionProxy> |
79 mock_controller_connection_proxy_; | 85 mock_controller_connection_proxy_; |
| 86 std::unique_ptr<mojo::Binding<blink::mojom::PresentationConnection>> binding_; |
80 std::unique_ptr<BrowserPresentationConnectionProxy> browser_connection_proxy_; | 87 std::unique_ptr<BrowserPresentationConnectionProxy> browser_connection_proxy_; |
81 MockMediaRouter mock_router_; | 88 MockMediaRouter mock_router_; |
82 content::TestBrowserThreadBundle thread_bundle_; | 89 content::TestBrowserThreadBundle thread_bundle_; |
83 }; | 90 }; |
84 | 91 |
85 TEST_F(BrowserPresentationConnectionProxyTest, TestOnMessageTextMessage) { | 92 TEST_F(BrowserPresentationConnectionProxyTest, TestOnMessageTextMessage) { |
86 std::string message = "test message"; | 93 std::string message = "test message"; |
87 content::PresentationConnectionMessage connection_message(message); | 94 content::PresentationConnectionMessage connection_message(message); |
88 | 95 |
89 base::MockCallback<base::Callback<void(bool)>> mock_on_message_callback; | 96 base::MockCallback<base::Callback<void(bool)>> mock_on_message_callback; |
90 EXPECT_CALL(*mock_router(), | 97 EXPECT_CALL(*mock_router(), |
91 SendRouteMessageInternal(kMediaRouteId, message, _)); | 98 SendRouteMessageInternal(kMediaRouteId, message, _)); |
92 | 99 |
93 browser_connection_proxy()->OnMessage(std::move(connection_message), | 100 browser_connection_proxy()->OnMessage(std::move(connection_message), |
94 mock_on_message_callback.Get()); | 101 mock_on_message_callback.Get()); |
95 } | 102 } |
96 | 103 |
97 TEST_F(BrowserPresentationConnectionProxyTest, TestOnMessageBinaryMessage) { | 104 TEST_F(BrowserPresentationConnectionProxyTest, TestOnMessageBinaryMessage) { |
98 std::vector<uint8_t> expected_data; | 105 std::vector<uint8_t> expected_data; |
99 expected_data.push_back(42); | 106 expected_data.push_back(42); |
100 expected_data.push_back(36); | 107 expected_data.push_back(36); |
101 | 108 |
102 content::PresentationConnectionMessage connection_message(expected_data); | 109 content::PresentationConnectionMessage connection_message(expected_data); |
103 | 110 |
104 base::MockCallback<base::Callback<void(bool)>> mock_on_message_callback; | 111 base::MockCallback<base::Callback<void(bool)>> mock_on_message_callback; |
105 EXPECT_CALL(*mock_router(), SendRouteBinaryMessageInternal(_, _, _)) | 112 EXPECT_CALL(*mock_router(), SendRouteBinaryMessageInternal(_, _, _)) |
106 .WillOnce(::testing::Invoke( | 113 .WillOnce(Invoke( |
107 [&expected_data]( | 114 [&expected_data]( |
108 const MediaRoute::Id& route_id, std::vector<uint8_t>* data, | 115 const MediaRoute::Id& route_id, std::vector<uint8_t>* data, |
109 const BrowserPresentationConnectionProxy::OnMessageCallback& | 116 const BrowserPresentationConnectionProxy::OnMessageCallback& |
110 callback) { EXPECT_EQ(*data, expected_data); })); | 117 callback) { EXPECT_EQ(*data, expected_data); })); |
111 | 118 |
112 browser_connection_proxy()->OnMessage(std::move(connection_message), | 119 browser_connection_proxy()->OnMessage(std::move(connection_message), |
113 mock_on_message_callback.Get()); | 120 mock_on_message_callback.Get()); |
114 } | 121 } |
115 | 122 |
| 123 TEST_F(BrowserPresentationConnectionProxyTest, OnMessagesReceived) { |
| 124 RouteMessage message_1; |
| 125 message_1.type = RouteMessage::Type::TEXT; |
| 126 message_1.text = std::string("foo"); |
| 127 RouteMessage message_2; |
| 128 message_2.type = RouteMessage::Type::BINARY; |
| 129 message_2.binary = std::vector<uint8_t>({1, 2, 3}); |
| 130 std::vector<RouteMessage> messages = {message_1, message_2}; |
| 131 |
| 132 content::PresentationConnectionMessage expected_message1("foo"); |
| 133 content::PresentationConnectionMessage expected_message2( |
| 134 std::vector<uint8_t>({1, 2, 3})); |
| 135 EXPECT_CALL(*controller_connection_proxy(), OnMessageInternal(_, _)) |
| 136 .WillOnce( |
| 137 Invoke([&expected_message1]( |
| 138 const content::PresentationConnectionMessage& message, |
| 139 OnMessageCallback& callback) { |
| 140 ExpectMessageAndRunCallback(expected_message1, message, callback); |
| 141 })) |
| 142 .WillOnce( |
| 143 Invoke([&expected_message2]( |
| 144 const content::PresentationConnectionMessage& message, |
| 145 OnMessageCallback& callback) { |
| 146 ExpectMessageAndRunCallback(expected_message2, message, callback); |
| 147 })); |
| 148 browser_connection_proxy()->OnMessagesReceived(messages); |
| 149 base::RunLoop().RunUntilIdle(); |
| 150 } |
| 151 |
116 } // namespace media_router | 152 } // namespace media_router |
OLD | NEW |