| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 #if !defined(__has_feature) || !__has_feature(objc_arc) | |
| 6 #error "This file requires ARC support." | |
| 7 #endif | |
| 8 | |
| 9 #import "remoting/ios/bridge/client_proxy.h" | |
| 10 | |
| 11 #import "base/compiler_specific.h" | |
| 12 #import "testing/gtest_mac.h" | |
| 13 | |
| 14 #import "remoting/ios/data_store.h" | |
| 15 #import "remoting/ios/bridge/client_proxy_delegate_wrapper.h" | |
| 16 | |
| 17 @interface ClientProxyDelegateTester : NSObject<ClientProxyDelegate> | |
| 18 @property(nonatomic, assign) BOOL isConnected; | |
| 19 @property(nonatomic, copy) NSString* statusMessage; | |
| 20 @property(nonatomic, copy) NSString* errorMessage; | |
| 21 @property(nonatomic, assign) BOOL isPairingSupported; | |
| 22 @property(nonatomic, assign) webrtc::DesktopSize size; | |
| 23 @property(nonatomic, assign) NSInteger stride; | |
| 24 @property(nonatomic, assign) uint8_t* data; | |
| 25 @property(nonatomic, assign) std::vector<webrtc::DesktopRect> regions; | |
| 26 @property(nonatomic, assign) webrtc::DesktopVector hotspot; | |
| 27 @end | |
| 28 | |
| 29 @implementation ClientProxyDelegateTester | |
| 30 | |
| 31 @synthesize isConnected = _isConnected; | |
| 32 @synthesize statusMessage = _statusMessage; | |
| 33 @synthesize errorMessage = _errorMessage; | |
| 34 @synthesize isPairingSupported = _isPairingSupported; | |
| 35 @synthesize size = _size; | |
| 36 @synthesize stride = _stride; | |
| 37 @synthesize data = _data; | |
| 38 @synthesize regions = _regions; | |
| 39 @synthesize hotspot = _hotspot; | |
| 40 | |
| 41 - (void)connected { | |
| 42 _isConnected = true; | |
| 43 } | |
| 44 | |
| 45 - (void)connectionStatus:(NSString*)statusMessage { | |
| 46 _statusMessage = statusMessage; | |
| 47 } | |
| 48 | |
| 49 - (void)connectionFailed:(NSString*)errorMessage { | |
| 50 _errorMessage = errorMessage; | |
| 51 } | |
| 52 | |
| 53 - (void)requestHostPin:(BOOL)pairingSupported { | |
| 54 _isPairingSupported = pairingSupported; | |
| 55 } | |
| 56 | |
| 57 - (void)applyFrame:(const webrtc::DesktopSize&)size | |
| 58 stride:(NSInteger)stride | |
| 59 data:(uint8_t*)data | |
| 60 regions:(const std::vector<webrtc::DesktopRect>&)regions { | |
| 61 _size = size; | |
| 62 _stride = stride; | |
| 63 _data = data; | |
| 64 _regions.assign(regions.begin(), regions.end()); | |
| 65 } | |
| 66 | |
| 67 - (void)applyCursor:(const webrtc::DesktopSize&)size | |
| 68 hotspot:(const webrtc::DesktopVector&)hotspot | |
| 69 cursorData:(uint8_t*)data { | |
| 70 _size = size; | |
| 71 _hotspot = hotspot; | |
| 72 _data = data; | |
| 73 } | |
| 74 | |
| 75 @end | |
| 76 | |
| 77 namespace remoting { | |
| 78 | |
| 79 namespace { | |
| 80 | |
| 81 NSString* kStatusINITIALIZING = @"Initializing connection"; | |
| 82 NSString* kStatusCONNECTING = @"Connecting"; | |
| 83 NSString* kStatusAUTHENTICATED = @"Authenticated"; | |
| 84 NSString* kStatusCONNECTED = @"Connected"; | |
| 85 NSString* kStatusFAILED = @"Connection Failed"; | |
| 86 NSString* kStatusCLOSED = @"Connection closed"; | |
| 87 NSString* kStatusDEFAULT = @"Unknown connection state"; | |
| 88 | |
| 89 NSString* kErrorPEER_IS_OFFLINE = @"Requested host is offline."; | |
| 90 NSString* kErrorSESSION_REJECTED = @"Session was rejected by the host."; | |
| 91 NSString* kErrorINCOMPATIBLE_PROTOCOL = @"Incompatible Protocol."; | |
| 92 NSString* kErrorAUTHENTICATION_FAILED = @"Authentication Failed."; | |
| 93 NSString* kErrorCHANNEL_CONNECTION_ERROR = @"Channel Connection Error"; | |
| 94 NSString* kErrorSIGNALING_ERROR = @"Signaling Error"; | |
| 95 NSString* kErrorSIGNALING_TIMEOUT = @"Signaling Timeout"; | |
| 96 NSString* kErrorHOST_OVERLOAD = @"Host Overload"; | |
| 97 NSString* kErrorUNKNOWN_ERROR = | |
| 98 @"An unknown error has occurred, preventing the session from opening."; | |
| 99 NSString* kErrorDEFAULT = @"An unknown error code has occurred."; | |
| 100 | |
| 101 const webrtc::DesktopSize kFrameSize(100, 100); | |
| 102 | |
| 103 // Note these are disjoint regions. Testing intersecting regions is beyond the | |
| 104 // scope of this test class. | |
| 105 const webrtc::DesktopRect kFrameSubRect1 = | |
| 106 webrtc::DesktopRect::MakeXYWH(0, 0, 10, 10); | |
| 107 const webrtc::DesktopRect kFrameSubRect2 = | |
| 108 webrtc::DesktopRect::MakeXYWH(11, 11, 10, 10); | |
| 109 const webrtc::DesktopRect kFrameSubRect3 = | |
| 110 webrtc::DesktopRect::MakeXYWH(22, 22, 10, 10); | |
| 111 | |
| 112 const int kCursorHeight = 10; | |
| 113 const int kCursorWidth = 20; | |
| 114 const int kCursorHotSpotX = 4; | |
| 115 const int kCursorHotSpotY = 8; | |
| 116 // |kCursorDataLength| is assumed to be evenly divisible by 4 | |
| 117 const int kCursorDataLength = kCursorHeight * kCursorWidth; | |
| 118 const uint32_t kCursorDataPattern = 0xF0E1D2C3; | |
| 119 | |
| 120 const std::string kHostName = "ClientProxyHostNameTest"; | |
| 121 const std::string kPairingId = "ClientProxyPairingIdTest"; | |
| 122 const std::string kPairingSecret = "ClientProxyPairingSecretTest"; | |
| 123 | |
| 124 } // namespace | |
| 125 | |
| 126 class ClientProxyTest : public ::testing::Test { | |
| 127 protected: | |
| 128 virtual void SetUp() OVERRIDE { | |
| 129 delegateTester_ = [[ClientProxyDelegateTester alloc] init]; | |
| 130 clientProxy_.reset(new ClientProxy( | |
| 131 [ClientProxyDelegateWrapper wrapDelegate:delegateTester_])); | |
| 132 } | |
| 133 | |
| 134 void ResetIsConnected() { delegateTester_.isConnected = false; } | |
| 135 | |
| 136 void TestConnnectionStatus(protocol::ConnectionToHost::State state, | |
| 137 NSString* expectedStatusMsg) { | |
| 138 ResetIsConnected(); | |
| 139 clientProxy_->ReportConnectionStatus(state, protocol::ErrorCode::OK); | |
| 140 EXPECT_NSEQ(expectedStatusMsg, delegateTester_.statusMessage); | |
| 141 | |
| 142 if (state == protocol::ConnectionToHost::State::CONNECTED) { | |
| 143 EXPECT_TRUE(delegateTester_.isConnected); | |
| 144 } else { | |
| 145 EXPECT_FALSE(delegateTester_.isConnected); | |
| 146 } | |
| 147 | |
| 148 TestErrorMessages(state, expectedStatusMsg); | |
| 149 } | |
| 150 | |
| 151 void TestForError(protocol::ConnectionToHost::State state, | |
| 152 protocol::ErrorCode errorCode, | |
| 153 NSString* expectedStatusMsg, | |
| 154 NSString* expectedErrorMsg) { | |
| 155 ResetIsConnected(); | |
| 156 clientProxy_->ReportConnectionStatus(state, errorCode); | |
| 157 EXPECT_FALSE(delegateTester_.isConnected); | |
| 158 EXPECT_NSEQ(expectedStatusMsg, delegateTester_.statusMessage); | |
| 159 EXPECT_NSEQ(expectedErrorMsg, delegateTester_.errorMessage); | |
| 160 } | |
| 161 | |
| 162 void TestErrorMessages(protocol::ConnectionToHost::State state, | |
| 163 NSString* expectedStatusMsg) { | |
| 164 TestForError(state, | |
| 165 protocol::ErrorCode::AUTHENTICATION_FAILED, | |
| 166 expectedStatusMsg, | |
| 167 kErrorAUTHENTICATION_FAILED); | |
| 168 TestForError(state, | |
| 169 protocol::ErrorCode::CHANNEL_CONNECTION_ERROR, | |
| 170 expectedStatusMsg, | |
| 171 kErrorCHANNEL_CONNECTION_ERROR); | |
| 172 TestForError(state, | |
| 173 protocol::ErrorCode::HOST_OVERLOAD, | |
| 174 expectedStatusMsg, | |
| 175 kErrorHOST_OVERLOAD); | |
| 176 TestForError(state, | |
| 177 protocol::ErrorCode::INCOMPATIBLE_PROTOCOL, | |
| 178 expectedStatusMsg, | |
| 179 kErrorINCOMPATIBLE_PROTOCOL); | |
| 180 TestForError(state, | |
| 181 protocol::ErrorCode::PEER_IS_OFFLINE, | |
| 182 expectedStatusMsg, | |
| 183 kErrorPEER_IS_OFFLINE); | |
| 184 TestForError(state, | |
| 185 protocol::ErrorCode::SESSION_REJECTED, | |
| 186 expectedStatusMsg, | |
| 187 kErrorSESSION_REJECTED); | |
| 188 TestForError(state, | |
| 189 protocol::ErrorCode::SIGNALING_ERROR, | |
| 190 expectedStatusMsg, | |
| 191 kErrorSIGNALING_ERROR); | |
| 192 TestForError(state, | |
| 193 protocol::ErrorCode::SIGNALING_TIMEOUT, | |
| 194 expectedStatusMsg, | |
| 195 kErrorSIGNALING_TIMEOUT); | |
| 196 TestForError(state, | |
| 197 protocol::ErrorCode::UNKNOWN_ERROR, | |
| 198 expectedStatusMsg, | |
| 199 kErrorUNKNOWN_ERROR); | |
| 200 TestForError(state, | |
| 201 static_cast<protocol::ErrorCode>(999), | |
| 202 expectedStatusMsg, | |
| 203 kErrorDEFAULT); | |
| 204 } | |
| 205 | |
| 206 void ValidateHost(const std::string& hostName, | |
| 207 const std::string& pairingId, | |
| 208 const std::string& pairingSecret) { | |
| 209 DataStore* store = [DataStore sharedStore]; | |
| 210 NSString* hostNameAsNSString = | |
| 211 [NSString stringWithUTF8String:hostName.c_str()]; | |
| 212 const HostPreferences* host = [store getHostForId:hostNameAsNSString]; | |
| 213 if (host != nil) { | |
| 214 [store removeHost:host]; | |
| 215 } | |
| 216 | |
| 217 clientProxy_->CommitPairingCredentials(hostName, pairingId, pairingSecret); | |
| 218 | |
| 219 host = [store getHostForId:hostNameAsNSString]; | |
| 220 | |
| 221 ASSERT_TRUE(host != nil); | |
| 222 ASSERT_STREQ(hostName.c_str(), [host.hostId UTF8String]); | |
| 223 ASSERT_STREQ(pairingId.c_str(), [host.pairId UTF8String]); | |
| 224 ASSERT_STREQ(pairingSecret.c_str(), [host.pairSecret UTF8String]); | |
| 225 } | |
| 226 | |
| 227 scoped_ptr<ClientProxy> clientProxy_; | |
| 228 ClientProxyDelegateTester* delegateTester_; | |
| 229 ClientProxyDelegateWrapper* delegateWrapper_; | |
| 230 }; | |
| 231 | |
| 232 TEST_F(ClientProxyTest, ReportConnectionStatusINITIALIZING) { | |
| 233 TestConnnectionStatus(protocol::ConnectionToHost::State::INITIALIZING, | |
| 234 kStatusINITIALIZING); | |
| 235 } | |
| 236 | |
| 237 TEST_F(ClientProxyTest, ReportConnectionStatusCONNECTING) { | |
| 238 TestConnnectionStatus(protocol::ConnectionToHost::State::CONNECTING, | |
| 239 kStatusCONNECTING); | |
| 240 } | |
| 241 | |
| 242 TEST_F(ClientProxyTest, ReportConnectionStatusAUTHENTICATED) { | |
| 243 TestConnnectionStatus(protocol::ConnectionToHost::State::AUTHENTICATED, | |
| 244 kStatusAUTHENTICATED); | |
| 245 } | |
| 246 | |
| 247 TEST_F(ClientProxyTest, ReportConnectionStatusCONNECTED) { | |
| 248 TestConnnectionStatus(protocol::ConnectionToHost::State::CONNECTED, | |
| 249 kStatusCONNECTED); | |
| 250 } | |
| 251 | |
| 252 TEST_F(ClientProxyTest, ReportConnectionStatusFAILED) { | |
| 253 TestConnnectionStatus(protocol::ConnectionToHost::State::FAILED, | |
| 254 kStatusFAILED); | |
| 255 } | |
| 256 | |
| 257 TEST_F(ClientProxyTest, ReportConnectionStatusCLOSED) { | |
| 258 TestConnnectionStatus(protocol::ConnectionToHost::State::CLOSED, | |
| 259 kStatusCLOSED); | |
| 260 } | |
| 261 | |
| 262 TEST_F(ClientProxyTest, ReportConnectionStatusDEFAULT) { | |
| 263 TestConnnectionStatus(static_cast<protocol::ConnectionToHost::State>(999), | |
| 264 kStatusDEFAULT); | |
| 265 } | |
| 266 | |
| 267 TEST_F(ClientProxyTest, DisplayAuthenticationPrompt) { | |
| 268 clientProxy_->DisplayAuthenticationPrompt(true); | |
| 269 ASSERT_TRUE(delegateTester_.isPairingSupported); | |
| 270 clientProxy_->DisplayAuthenticationPrompt(false); | |
| 271 ASSERT_FALSE(delegateTester_.isPairingSupported); | |
| 272 } | |
| 273 | |
| 274 TEST_F(ClientProxyTest, CommitPairingCredentialsBasic) { | |
| 275 ValidateHost("", "", ""); | |
| 276 } | |
| 277 | |
| 278 TEST_F(ClientProxyTest, CommitPairingCredentialsExtended) { | |
| 279 ValidateHost(kHostName, kPairingId, kPairingSecret); | |
| 280 } | |
| 281 | |
| 282 TEST_F(ClientProxyTest, RedrawCanvasBasic) { | |
| 283 | |
| 284 webrtc::BasicDesktopFrame frame(webrtc::DesktopSize(1, 1)); | |
| 285 webrtc::DesktopRegion regions; | |
| 286 regions.AddRect(webrtc::DesktopRect::MakeLTRB(0, 0, 1, 1)); | |
| 287 | |
| 288 clientProxy_->RedrawCanvas(webrtc::DesktopSize(1, 1), &frame, regions); | |
| 289 | |
| 290 ASSERT_TRUE(webrtc::DesktopSize(1, 1).equals(delegateTester_.size)); | |
| 291 ASSERT_EQ(4, delegateTester_.stride); | |
| 292 ASSERT_TRUE(delegateTester_.data != NULL); | |
| 293 ASSERT_EQ(1, delegateTester_.regions.size()); | |
| 294 ASSERT_TRUE(delegateTester_.regions[0].equals( | |
| 295 webrtc::DesktopRect::MakeLTRB(0, 0, 1, 1))); | |
| 296 } | |
| 297 TEST_F(ClientProxyTest, RedrawCanvasExtended) { | |
| 298 | |
| 299 webrtc::BasicDesktopFrame frame(kFrameSize); | |
| 300 webrtc::DesktopRegion regions; | |
| 301 regions.AddRect(kFrameSubRect1); | |
| 302 regions.AddRect(kFrameSubRect2); | |
| 303 regions.AddRect(kFrameSubRect3); | |
| 304 | |
| 305 clientProxy_->RedrawCanvas(kFrameSize, &frame, regions); | |
| 306 | |
| 307 ASSERT_TRUE(kFrameSize.equals(delegateTester_.size)); | |
| 308 ASSERT_EQ(kFrameSize.width() * webrtc::DesktopFrame::kBytesPerPixel, | |
| 309 delegateTester_.stride); | |
| 310 ASSERT_TRUE(delegateTester_.data != NULL); | |
| 311 ASSERT_EQ(3, delegateTester_.regions.size()); | |
| 312 ASSERT_TRUE(delegateTester_.regions[0].equals(kFrameSubRect1)); | |
| 313 ASSERT_TRUE(delegateTester_.regions[1].equals(kFrameSubRect2)); | |
| 314 ASSERT_TRUE(delegateTester_.regions[2].equals(kFrameSubRect3)); | |
| 315 } | |
| 316 | |
| 317 TEST_F(ClientProxyTest, UpdateCursorBasic) { | |
| 318 protocol::CursorShapeInfo cursor_proto; | |
| 319 cursor_proto.set_width(1); | |
| 320 cursor_proto.set_height(1); | |
| 321 cursor_proto.set_hotspot_x(0); | |
| 322 cursor_proto.set_hotspot_y(0); | |
| 323 | |
| 324 char data[4]; | |
| 325 memset(data, 0xFF, 4); | |
| 326 | |
| 327 cursor_proto.set_data(data); | |
| 328 | |
| 329 clientProxy_->UpdateCursorShape(cursor_proto); | |
| 330 | |
| 331 ASSERT_EQ(1, delegateTester_.size.width()); | |
| 332 ASSERT_EQ(1, delegateTester_.size.height()); | |
| 333 ASSERT_EQ(0, delegateTester_.hotspot.x()); | |
| 334 ASSERT_EQ(0, delegateTester_.hotspot.y()); | |
| 335 ASSERT_TRUE(delegateTester_.data != NULL); | |
| 336 for (int i = 0; i < 4; i++) { | |
| 337 ASSERT_EQ(0xFF, delegateTester_.data[i]); | |
| 338 } | |
| 339 } | |
| 340 | |
| 341 TEST_F(ClientProxyTest, UpdateCursorExtended) { | |
| 342 protocol::CursorShapeInfo cursor_proto; | |
| 343 cursor_proto.set_width(kCursorWidth); | |
| 344 cursor_proto.set_height(kCursorHeight); | |
| 345 cursor_proto.set_hotspot_x(kCursorHotSpotX); | |
| 346 cursor_proto.set_hotspot_y(kCursorHotSpotY); | |
| 347 | |
| 348 char data[kCursorDataLength]; | |
| 349 memset_pattern4(data, &kCursorDataPattern, kCursorDataLength); | |
| 350 | |
| 351 cursor_proto.set_data(data); | |
| 352 | |
| 353 clientProxy_->UpdateCursorShape(cursor_proto); | |
| 354 | |
| 355 ASSERT_EQ(kCursorWidth, delegateTester_.size.width()); | |
| 356 ASSERT_EQ(kCursorHeight, delegateTester_.size.height()); | |
| 357 ASSERT_EQ(kCursorHotSpotX, delegateTester_.hotspot.x()); | |
| 358 ASSERT_EQ(kCursorHotSpotY, delegateTester_.hotspot.y()); | |
| 359 ASSERT_TRUE(delegateTester_.data != NULL); | |
| 360 for (int i = 0; i < kCursorDataLength / 4; i++) { | |
| 361 ASSERT_TRUE(memcmp(&delegateTester_.data[i * 4], &kCursorDataPattern, 4) == | |
| 362 0); | |
| 363 } | |
| 364 } | |
| 365 | |
| 366 } // namespace remoting | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 475333004:
Remove old Chromoting iOS client (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master