OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include <vector> |
| 6 |
| 7 #include "base/bind.h" |
| 8 #include "chrome/browser/media/router/offscreen_presentation_manager.h" |
| 9 #include "chrome/browser/media/router/test_helper.h" |
| 10 #include "testing/gmock/include/gmock/gmock.h" |
| 11 #include "testing/gtest/include/gtest/gtest.h" |
| 12 #include "url/gurl.h" |
| 13 |
| 14 using testing::_; |
| 15 |
| 16 namespace media_router { |
| 17 |
| 18 namespace { |
| 19 const char kPresentationId[] = "presentationId"; |
| 20 const char kPresentationId2[] = "presentationId2"; |
| 21 const char kPresentationUrl[] = "presentationUrl"; |
| 22 } // namespace |
| 23 |
| 24 class MockReceiverConnectionAvailableCallback { |
| 25 public: |
| 26 void OnReceiverConnectionAvailable( |
| 27 const content::PresentationSessionInfo& session_info, |
| 28 content::PresentationConnectionPtr&& receiver_callback) { |
| 29 OnReceiverConnectionAvailableRaw(session_info, receiver_callback.get()); |
| 30 } |
| 31 |
| 32 MOCK_METHOD2(OnReceiverConnectionAvailableRaw, |
| 33 void(const content::PresentationSessionInfo&, |
| 34 blink::mojom::PresentationConnection*)); |
| 35 }; |
| 36 |
| 37 class OffscreenPresentationManagerTest : public ::testing::Test { |
| 38 public: |
| 39 OffscreenPresentationManager* manager() { return &manager_; } |
| 40 |
| 41 void VerifyPresentationsSize(size_t expected) { |
| 42 EXPECT_EQ(expected, manager_.offscreen_presentations_.size()); |
| 43 } |
| 44 |
| 45 void VerifyControllerSize(size_t expected, |
| 46 const std::string& presentationId) { |
| 47 EXPECT_TRUE( |
| 48 base::ContainsKey(manager_.offscreen_presentations_, presentationId)); |
| 49 EXPECT_EQ(expected, manager_.offscreen_presentations_[presentationId] |
| 50 ->pending_controllers_.size()); |
| 51 } |
| 52 |
| 53 void RegisterController(const std::string& presentation_id, |
| 54 content::PresentationConnectionPtr controller) { |
| 55 manager()->RegisterOffscreenPresentationController( |
| 56 presentation_id, GURL(kPresentationUrl), RenderFrameHostId(1, 1), |
| 57 std::move(controller)); |
| 58 } |
| 59 |
| 60 void RegisterController(const RenderFrameHostId& render_frame_id, |
| 61 content::PresentationConnectionPtr controller) { |
| 62 manager()->RegisterOffscreenPresentationController( |
| 63 kPresentationId, GURL(kPresentationUrl), render_frame_id, |
| 64 std::move(controller)); |
| 65 } |
| 66 |
| 67 void RegisterController(content::PresentationConnectionPtr controller) { |
| 68 manager()->RegisterOffscreenPresentationController( |
| 69 kPresentationId, GURL(kPresentationUrl), RenderFrameHostId(1, 1), |
| 70 std::move(controller)); |
| 71 } |
| 72 |
| 73 void RegisterReceiver( |
| 74 MockReceiverConnectionAvailableCallback& receiver_callback) { |
| 75 RegisterReceiver(kPresentationId, receiver_callback); |
| 76 } |
| 77 |
| 78 void RegisterReceiver( |
| 79 const std::string& presentation_id, |
| 80 MockReceiverConnectionAvailableCallback& receiver_callback) { |
| 81 manager()->OnOffscreenPresentationReceiverCreated( |
| 82 presentation_id, GURL(kPresentationUrl), |
| 83 base::Bind(&MockReceiverConnectionAvailableCallback:: |
| 84 OnReceiverConnectionAvailable, |
| 85 base::Unretained(&receiver_callback))); |
| 86 } |
| 87 |
| 88 void UnregisterController(const RenderFrameHostId& render_frame_id) { |
| 89 manager()->UnregisterOffscreenPresentationController(kPresentationId, |
| 90 render_frame_id); |
| 91 } |
| 92 |
| 93 void UnregisterController() { |
| 94 manager()->UnregisterOffscreenPresentationController( |
| 95 kPresentationId, RenderFrameHostId(1, 1)); |
| 96 } |
| 97 |
| 98 void UnregisterReceiver() { |
| 99 manager()->OnOffscreenPresentationReceiverTerminated(kPresentationId); |
| 100 } |
| 101 |
| 102 private: |
| 103 OffscreenPresentationManager manager_; |
| 104 }; |
| 105 |
| 106 TEST_F(OffscreenPresentationManagerTest, RegisterUnregisterController) { |
| 107 content::PresentationConnectionPtr controller; |
| 108 RegisterController(std::move(controller)); |
| 109 VerifyPresentationsSize(1); |
| 110 UnregisterController(); |
| 111 VerifyPresentationsSize(0); |
| 112 } |
| 113 |
| 114 TEST_F(OffscreenPresentationManagerTest, RegisterUnregisterReceiver) { |
| 115 MockReceiverConnectionAvailableCallback receiver_callback; |
| 116 RegisterReceiver(receiver_callback); |
| 117 VerifyPresentationsSize(1); |
| 118 UnregisterReceiver(); |
| 119 VerifyPresentationsSize(0); |
| 120 } |
| 121 |
| 122 TEST_F(OffscreenPresentationManagerTest, UnregisterNonexistentController) { |
| 123 UnregisterController(); |
| 124 VerifyPresentationsSize(0); |
| 125 } |
| 126 |
| 127 TEST_F(OffscreenPresentationManagerTest, UnregisterNonexistentReceiver) { |
| 128 UnregisterReceiver(); |
| 129 VerifyPresentationsSize(0); |
| 130 } |
| 131 |
| 132 TEST_F(OffscreenPresentationManagerTest, |
| 133 RegisterMultipleControllersSamePresentation) { |
| 134 content::PresentationConnectionPtr controller1; |
| 135 RegisterController(RenderFrameHostId(1, 1), std::move(controller1)); |
| 136 content::PresentationConnectionPtr controller2; |
| 137 RegisterController(RenderFrameHostId(1, 2), std::move(controller2)); |
| 138 VerifyPresentationsSize(1); |
| 139 } |
| 140 |
| 141 TEST_F(OffscreenPresentationManagerTest, |
| 142 RegisterMultipleControllersDifferentPresentations) { |
| 143 content::PresentationConnectionPtr controller1; |
| 144 RegisterController(kPresentationId, std::move(controller1)); |
| 145 content::PresentationConnectionPtr controller2; |
| 146 RegisterController(kPresentationId2, std::move(controller2)); |
| 147 VerifyPresentationsSize(2); |
| 148 } |
| 149 |
| 150 TEST_F(OffscreenPresentationManagerTest, |
| 151 RegisterControllerThenReceiverInvokesCallback) { |
| 152 content::PresentationConnectionPtr controller; |
| 153 MockReceiverConnectionAvailableCallback receiver_callback; |
| 154 |
| 155 VerifyPresentationsSize(0); |
| 156 |
| 157 RegisterController(std::move(controller)); |
| 158 EXPECT_CALL(receiver_callback, OnReceiverConnectionAvailableRaw(_, _)); |
| 159 RegisterReceiver(receiver_callback); |
| 160 } |
| 161 |
| 162 TEST_F(OffscreenPresentationManagerTest, |
| 163 UnregisterReceiverFromConnectedPresentation) { |
| 164 content::PresentationConnectionPtr controller; |
| 165 MockReceiverConnectionAvailableCallback receiver_callback; |
| 166 |
| 167 VerifyPresentationsSize(0); |
| 168 |
| 169 RegisterController(std::move(controller)); |
| 170 EXPECT_CALL(receiver_callback, OnReceiverConnectionAvailableRaw(_, _)); |
| 171 RegisterReceiver(receiver_callback); |
| 172 UnregisterReceiver(); |
| 173 |
| 174 VerifyPresentationsSize(0); |
| 175 } |
| 176 |
| 177 TEST_F(OffscreenPresentationManagerTest, |
| 178 UnregisterControllerFromConnectedPresentation) { |
| 179 content::PresentationConnectionPtr controller; |
| 180 MockReceiverConnectionAvailableCallback receiver_callback; |
| 181 |
| 182 VerifyPresentationsSize(0); |
| 183 |
| 184 RegisterController(std::move(controller)); |
| 185 EXPECT_CALL(receiver_callback, OnReceiverConnectionAvailableRaw(_, _)); |
| 186 RegisterReceiver(receiver_callback); |
| 187 UnregisterController(); |
| 188 |
| 189 VerifyPresentationsSize(1); |
| 190 } |
| 191 |
| 192 TEST_F(OffscreenPresentationManagerTest, |
| 193 UnregisterReceiverThenControllerFromConnectedPresentation) { |
| 194 content::PresentationConnectionPtr controller; |
| 195 MockReceiverConnectionAvailableCallback receiver_callback; |
| 196 |
| 197 VerifyPresentationsSize(0); |
| 198 |
| 199 RegisterController(std::move(controller)); |
| 200 EXPECT_CALL(receiver_callback, OnReceiverConnectionAvailableRaw(_, _)); |
| 201 RegisterReceiver(receiver_callback); |
| 202 UnregisterReceiver(); |
| 203 UnregisterController(); |
| 204 |
| 205 VerifyPresentationsSize(0); |
| 206 } |
| 207 |
| 208 TEST_F(OffscreenPresentationManagerTest, |
| 209 UnregisterControllerThenReceiverFromConnectedPresentation) { |
| 210 content::PresentationConnectionPtr controller; |
| 211 MockReceiverConnectionAvailableCallback receiver_callback; |
| 212 |
| 213 VerifyPresentationsSize(0); |
| 214 |
| 215 RegisterController(std::move(controller)); |
| 216 EXPECT_CALL(receiver_callback, OnReceiverConnectionAvailableRaw(_, _)); |
| 217 RegisterReceiver(receiver_callback); |
| 218 UnregisterController(); |
| 219 UnregisterReceiver(); |
| 220 |
| 221 VerifyPresentationsSize(0); |
| 222 } |
| 223 |
| 224 TEST_F(OffscreenPresentationManagerTest, |
| 225 RegisterTwoControllersThenReceiverInvokesCallbackTwice) { |
| 226 content::PresentationConnectionPtr controller1; |
| 227 RegisterController(RenderFrameHostId(1, 1), std::move(controller1)); |
| 228 content::PresentationConnectionPtr controller2; |
| 229 RegisterController(RenderFrameHostId(1, 2), std::move(controller2)); |
| 230 |
| 231 MockReceiverConnectionAvailableCallback receiver_callback; |
| 232 EXPECT_CALL(receiver_callback, OnReceiverConnectionAvailableRaw(_, _)) |
| 233 .Times(2); |
| 234 RegisterReceiver(receiver_callback); |
| 235 } |
| 236 |
| 237 TEST_F(OffscreenPresentationManagerTest, |
| 238 RegisterControllerReceiverConontrollerInvokesCallbackTwice) { |
| 239 content::PresentationConnectionPtr controller1; |
| 240 RegisterController(RenderFrameHostId(1, 1), std::move(controller1)); |
| 241 |
| 242 MockReceiverConnectionAvailableCallback receiver_callback; |
| 243 EXPECT_CALL(receiver_callback, OnReceiverConnectionAvailableRaw(_, _)) |
| 244 .Times(2); |
| 245 RegisterReceiver(receiver_callback); |
| 246 |
| 247 content::PresentationConnectionPtr controller2; |
| 248 RegisterController(RenderFrameHostId(1, 2), std::move(controller2)); |
| 249 } |
| 250 |
| 251 TEST_F(OffscreenPresentationManagerTest, |
| 252 UnregisterFirstControllerFromeConnectedPresentation) { |
| 253 content::PresentationConnectionPtr controller1; |
| 254 RegisterController(RenderFrameHostId(1, 1), std::move(controller1)); |
| 255 content::PresentationConnectionPtr controller2; |
| 256 RegisterController(RenderFrameHostId(1, 2), std::move(controller2)); |
| 257 |
| 258 MockReceiverConnectionAvailableCallback receiver_callback; |
| 259 EXPECT_CALL(receiver_callback, OnReceiverConnectionAvailableRaw(_, _)) |
| 260 .Times(2); |
| 261 RegisterReceiver(receiver_callback); |
| 262 UnregisterController(RenderFrameHostId(1, 1)); |
| 263 UnregisterController(RenderFrameHostId(1, 1)); |
| 264 |
| 265 VerifyPresentationsSize(1); |
| 266 } |
| 267 |
| 268 TEST_F(OffscreenPresentationManagerTest, TwoPresentations) { |
| 269 content::PresentationConnectionPtr controller1; |
| 270 RegisterController(kPresentationId, std::move(controller1)); |
| 271 |
| 272 MockReceiverConnectionAvailableCallback receiver_callback1; |
| 273 EXPECT_CALL(receiver_callback1, OnReceiverConnectionAvailableRaw(_, _)) |
| 274 .Times(1); |
| 275 RegisterReceiver(kPresentationId, receiver_callback1); |
| 276 |
| 277 content::PresentationConnectionPtr controller2; |
| 278 RegisterController(kPresentationId2, std::move(controller2)); |
| 279 |
| 280 MockReceiverConnectionAvailableCallback receiver_callback2; |
| 281 EXPECT_CALL(receiver_callback2, OnReceiverConnectionAvailableRaw(_, _)) |
| 282 .Times(1); |
| 283 RegisterReceiver(kPresentationId2, receiver_callback2); |
| 284 |
| 285 VerifyPresentationsSize(2); |
| 286 |
| 287 UnregisterReceiver(); |
| 288 VerifyPresentationsSize(1); |
| 289 } |
| 290 |
| 291 } // namespace media_router |
OLD | NEW |