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 #include <algorithm> 6 7 #include "base/strings/utf_string_conversions.h" 8 #include "chrome/browser/devtools/device/devtools_android_bridge.h" 9 #include "chrome/browser/devtools/device/usb/android_usb_device.h" 10 #include "chrome/browser/devtools/device/usb/usb_device_provider.h" 11 #include "chrome/browser/ui/browser.h" 12 #include "chrome/test/base/in_process_browser_test.h" 13 #include "content/public/browser/browser_thread.h" 14 #include "content/public/test/test_utils.h" 15 #include "device/usb/usb_descriptors.h" 16 #include "device/usb/usb_device.h" 17 #include "device/usb/usb_device_handle.h" 18 #include "device/usb/usb_service.h" 19 #include "testing/gtest/include/gtest/gtest.h" 20 21 using content::BrowserThread; 22 using device::UsbConfigDescriptor; 23 using device::UsbDevice; 24 using device::UsbDeviceHandle; 25 using device::UsbEndpointDescriptor; 26 using device::UsbEndpointDirection; 27 using device::UsbInterfaceDescriptor; 28 using device::UsbService; 29 using device::UsbSynchronizationType; 30 using device::UsbTransferCallback; 31 using device::UsbTransferType; 32 using device::UsbUsageType; 33 34 namespace { 35 36 struct AndroidTraits { 37 static const int kClass = 0xff; 38 static const int kSubclass = 0x42; 39 static const int kProtocol = 0x1; 40 }; 41 42 struct NonAndroidTraits { 43 static const int kClass = 0xf0; 44 static const int kSubclass = 0x42; 45 static const int kProtocol = 0x2; 46 }; 47 48 const uint32 kMaxPayload = 4096; 49 const uint32 kVersion = 0x01000000; 50 51 const char kOpenedUnixSocketsCommand[] = "shell:cat /proc/net/unix"; 52 const char kDeviceModelCommand[] = "shell:getprop ro.product.model"; 53 const char kDumpsysCommand[] = "shell:dumpsys window policy"; 54 const char kListProcessesCommand[] = "shell:ps"; 55 const char kInstalledChromePackagesCommand[] = "shell:pm list packages"; 56 const char kDeviceManufacturer[] = "Test Manufacturer"; 57 const char kDeviceModel[] = "Nexus 5"; 58 const char kDeviceSerial[] = "Sample serial"; 59 60 const char kSampleOpenedUnixSockets[] = 61 "Num RefCount Protocol Flags Type St Inode Path\n" 62 "00000000: 00000004 00000000" 63 " 00000000 0002 01 3328 /dev/socket/wpa_wlan0\n" 64 "00000000: 00000002 00000000" 65 " 00010000 0001 01 5394 /dev/socket/vold\n"; 66 67 const char kSampleListProcesses[] = 68 "USER PID PPID VSIZE RSS WCHAN PC NAME\n" 69 "root 1 0 688 508 ffffffff 00000000 S /init\r\n" 70 "u0_a75 2425 123 933736 193024 ffffffff 00000000 S com.sample.feed\r\n" 71 "nfc 741 123 706448 26316 ffffffff 00000000 S com.android.nfc\r\n" 72 "u0_a76 1001 124 111111 222222 ffffffff 00000000 S com.android.chrome\r\n" 73 "u0_a78 1003 126 111111 222222 ffffffff 00000000 S com.noprocess.app\r\n"; 74 75 const char kSampleListPackages[] = 76 "package:com.sample.feed\r\n" 77 "package:com.android.nfc\r\n" 78 "package:com.android.chrome\r\n" 79 "package:com.chrome.beta\r\n" 80 "package:com.google.android.apps.chrome\r\n"; 81 82 const char kSampleDumpsys[] = 83 "WINDOW MANAGER POLICY STATE (dumpsys window policy)\r\n" 84 " mSafeMode=false mSystemReady=true mSystemBooted=true\r\n" 85 " mStable=(0,50)-(720,1184)\r\n" // Only mStable parameter is parsed 86 " mForceStatusBar=false mForceStatusBarFromKeyguard=false\r\n"; 87 88 const char* GetMockShellResponse(std::string command) { 89 if (command == kDeviceModelCommand) { 90 return kDeviceModel; 91 } else if (command == kOpenedUnixSocketsCommand) { 92 return kSampleOpenedUnixSockets; 93 } else if (command == kDumpsysCommand) { 94 return kSampleDumpsys; 95 } else if (command == kListProcessesCommand) { 96 return kSampleListProcesses; 97 } else if (command == kInstalledChromePackagesCommand) { 98 return kSampleListPackages; 99 } 100 101 DCHECK(false) << "Should not be reached"; 102 103 return ""; 104 } 105 106 template <class T> 107 class MockUsbDevice; 108 109 template <class T> 110 class MockUsbDeviceHandle : public UsbDeviceHandle { 111 public: 112 explicit MockUsbDeviceHandle(MockUsbDevice<T>* device) 113 : device_(device), 114 remaining_body_length_(0), 115 next_local_socket_(0) {} 116 117 virtual scoped_refptr<UsbDevice> GetDevice() const OVERRIDE { 118 return device_; 119 } 120 121 virtual void Close() OVERRIDE { device_ = NULL; } 122 123 bool ClaimInterface(int interface_number) { 124 if (device_->claimed_interfaces_.find(interface_number) != 125 device_->claimed_interfaces_.end()) 126 return false; 127 128 device_->claimed_interfaces_.insert(interface_number); 129 return true; 130 } 131 132 bool ReleaseInterface(int interface_number) { 133 if (device_->claimed_interfaces_.find(interface_number) == 134 device_->claimed_interfaces_.end()) 135 return false; 136 137 device_->claimed_interfaces_.erase(interface_number); 138 return true; 139 } 140 141 virtual bool SetInterfaceAlternateSetting(int interface_number, 142 int alternate_setting) OVERRIDE { 143 return true; 144 } 145 146 virtual bool ResetDevice() OVERRIDE { return true; } 147 virtual bool GetStringDescriptor(uint8_t string_id, base::string16* content) { 148 return false; 149 } 150 151 // Async IO. Can be called on any thread. 152 virtual void ControlTransfer(UsbEndpointDirection direction, 153 TransferRequestType request_type, 154 TransferRecipient recipient, 155 uint8 request, 156 uint16 value, 157 uint16 index, 158 net::IOBuffer* buffer, 159 size_t length, 160 unsigned int timeout, 161 const UsbTransferCallback& callback) OVERRIDE {} 162 163 virtual void BulkTransfer(UsbEndpointDirection direction, 164 uint8 endpoint, 165 net::IOBuffer* buffer, 166 size_t length, 167 unsigned int timeout, 168 const UsbTransferCallback& callback) OVERRIDE { 169 if (direction == device::USB_DIRECTION_OUTBOUND) { 170 if (remaining_body_length_ == 0) { 171 std::vector<uint32> header(6); 172 memcpy(&header[0], buffer->data(), length); 173 current_message_ = new AdbMessage(header[0], header[1], header[2], ""); 174 remaining_body_length_ = header[3]; 175 uint32 magic = header[5]; 176 if ((current_message_->command ^ 0xffffffff) != magic) { 177 DCHECK(false) << "Header checksum error"; 178 return; 179 } 180 } else { 181 DCHECK(current_message_.get()); 182 current_message_->body += std::string(buffer->data(), length); 183 remaining_body_length_ -= length; 184 } 185 186 if (remaining_body_length_ == 0) { 187 ProcessIncoming(); 188 } 189 190 base::MessageLoop::current()->PostTask( 191 FROM_HERE, 192 base::Bind(callback, 193 device::USB_TRANSFER_COMPLETED, 194 scoped_refptr<net::IOBuffer>(), 195 0)); 196 197 } else if (direction == device::USB_DIRECTION_INBOUND) { 198 queries_.push(Query(callback, make_scoped_refptr(buffer), length)); 199 ProcessQueries(); 200 } 201 } 202 203 template <class D> 204 void append(D data) { 205 std::copy(reinterpret_cast<char*>(&data), 206 (reinterpret_cast<char*>(&data)) + sizeof(D), 207 std::back_inserter(output_buffer_)); 208 } 209 210 // Copied from AndroidUsbDevice::Checksum 211 uint32 Checksum(const std::string& data) { 212 unsigned char* x = (unsigned char*)data.data(); 213 int count = data.length(); 214 uint32 sum = 0; 215 while (count-- > 0) 216 sum += *x++; 217 return sum; 218 } 219 220 void ProcessIncoming() { 221 DCHECK(current_message_.get()); 222 switch (current_message_->command) { 223 case AdbMessage::kCommandCNXN: 224 WriteResponse(new AdbMessage(AdbMessage::kCommandCNXN, 225 kVersion, 226 kMaxPayload, 227 "device::ro.product.name=SampleProduct;ro." 228 "product.model=SampleModel;ro.product." 229 "device=SampleDevice;")); 230 break; 231 case AdbMessage::kCommandOPEN: 232 DCHECK(current_message_->arg1 == 0); 233 DCHECK(current_message_->arg0 != 0); 234 if (current_message_->body.find("shell:") != std::string::npos) { 235 WriteResponse(new AdbMessage(AdbMessage::kCommandOKAY, 236 ++next_local_socket_, 237 current_message_->arg0, 238 "")); 239 WriteResponse( 240 new AdbMessage(AdbMessage::kCommandWRTE, 241 next_local_socket_, 242 current_message_->arg0, 243 GetMockShellResponse(current_message_->body.substr( 244 0, current_message_->body.size() - 1)))); 245 WriteResponse(new AdbMessage( 246 AdbMessage::kCommandCLSE, 0, current_message_->arg0, "")); 247 } 248 default: 249 return; 250 } 251 ProcessQueries(); 252 } 253 254 void WriteResponse(scoped_refptr<AdbMessage> response) { 255 append(response->command); 256 append(response->arg0); 257 append(response->arg1); 258 bool add_zero = response->body.length() && 259 (response->command != AdbMessage::kCommandWRTE); 260 append(static_cast<uint32>(response->body.length() + (add_zero ? 1 : 0))); 261 append(Checksum(response->body)); 262 append(response->command ^ 0xffffffff); 263 std::copy(response->body.begin(), 264 response->body.end(), 265 std::back_inserter(output_buffer_)); 266 if (add_zero) { 267 output_buffer_.push_back(0); 268 } 269 ProcessQueries(); 270 } 271 272 void ProcessQueries() { 273 if (!queries_.size()) 274 return; 275 Query query = queries_.front(); 276 277 if (query.size > output_buffer_.size()) 278 return; 279 280 queries_.pop(); 281 std::copy(output_buffer_.begin(), 282 output_buffer_.begin() + query.size, 283 query.buffer->data()); 284 output_buffer_.erase(output_buffer_.begin(), 285 output_buffer_.begin() + query.size); 286 base::MessageLoop::current()->PostTask( 287 FROM_HERE, 288 base::Bind(query.callback, 289 device::USB_TRANSFER_COMPLETED, 290 query.buffer, 291 query.size)); 292 } 293 294 virtual void InterruptTransfer(UsbEndpointDirection direction, 295 uint8 endpoint, 296 net::IOBuffer* buffer, 297 size_t length, 298 unsigned int timeout, 299 const UsbTransferCallback& callback) OVERRIDE { 300 } 301 302 virtual void IsochronousTransfer( 303 UsbEndpointDirection direction, 304 uint8 endpoint, 305 net::IOBuffer* buffer, 306 size_t length, 307 unsigned int packets, 308 unsigned int packet_length, 309 unsigned int timeout, 310 const UsbTransferCallback& callback) OVERRIDE {} 311 312 protected: 313 virtual ~MockUsbDeviceHandle() {} 314 315 struct Query { 316 UsbTransferCallback callback; 317 scoped_refptr<net::IOBuffer> buffer; 318 size_t size; 319 320 Query(UsbTransferCallback callback, 321 scoped_refptr<net::IOBuffer> buffer, 322 int size) 323 : callback(callback), buffer(buffer), size(size) {}; 324 }; 325 326 scoped_refptr<MockUsbDevice<T> > device_; 327 uint32 remaining_body_length_; 328 scoped_refptr<AdbMessage> current_message_; 329 std::vector<char> output_buffer_; 330 std::queue<Query> queries_; 331 int next_local_socket_; 332 }; 333 334 template <class T> 335 class MockUsbDevice : public UsbDevice { 336 public: 337 MockUsbDevice() : UsbDevice(0, 0, 0) { 338 UsbEndpointDescriptor bulk_in; 339 bulk_in.address = 0x81; 340 bulk_in.direction = device::USB_DIRECTION_INBOUND; 341 bulk_in.maximum_packet_size = 512; 342 bulk_in.transfer_type = device::USB_TRANSFER_BULK; 343 344 UsbEndpointDescriptor bulk_out; 345 bulk_out.address = 0x01; 346 bulk_out.direction = device::USB_DIRECTION_OUTBOUND; 347 bulk_out.maximum_packet_size = 512; 348 bulk_out.transfer_type = device::USB_TRANSFER_BULK; 349 350 UsbInterfaceDescriptor interface_desc; 351 interface_desc.interface_number = 0; 352 interface_desc.alternate_setting = 0; 353 interface_desc.interface_class = T::kClass; 354 interface_desc.interface_subclass = T::kSubclass; 355 interface_desc.interface_protocol = T::kProtocol; 356 interface_desc.endpoints.push_back(bulk_in); 357 interface_desc.endpoints.push_back(bulk_out); 358 359 config_desc_.interfaces.push_back(interface_desc); 360 } 361 362 virtual scoped_refptr<UsbDeviceHandle> Open() OVERRIDE { 363 return new MockUsbDeviceHandle<T>(this); 364 } 365 366 virtual const UsbConfigDescriptor& GetConfiguration() OVERRIDE { 367 return config_desc_; 368 } 369 370 virtual bool GetManufacturer(base::string16* manufacturer) OVERRIDE { 371 *manufacturer = base::UTF8ToUTF16(kDeviceManufacturer); 372 return true; 373 } 374 375 virtual bool GetProduct(base::string16* product) OVERRIDE { 376 *product = base::UTF8ToUTF16(kDeviceModel); 377 return true; 378 } 379 380 virtual bool GetSerialNumber(base::string16* serial) OVERRIDE { 381 *serial = base::UTF8ToUTF16(kDeviceSerial); 382 return true; 383 } 384 385 virtual bool Close(scoped_refptr<UsbDeviceHandle> handle) OVERRIDE { 386 return true; 387 } 388 389 #if defined(OS_CHROMEOS) 390 // On ChromeOS, if an interface of a claimed device is not claimed, the 391 // permission broker can change the owner of the device so that the unclaimed 392 // interfaces can be used. If this argument is missing, permission broker will 393 // not be used and this method fails if the device is claimed. 394 virtual void RequestUsbAccess( 395 int interface_id, 396 const base::Callback<void(bool success)>& callback) OVERRIDE { 397 callback.Run(true); 398 } 399 #endif // OS_CHROMEOS 400 401 std::set<int> claimed_interfaces_; 402 403 protected: 404 virtual ~MockUsbDevice() {} 405 406 private: 407 UsbConfigDescriptor config_desc_; 408 }; 409 410 class MockUsbService : public UsbService { 411 public: 412 MockUsbService() { 413 devices_.push_back(new MockUsbDevice<AndroidTraits>()); 414 } 415 416 virtual ~MockUsbService() {} 417 418 virtual scoped_refptr<UsbDevice> GetDeviceById(uint32 unique_id) OVERRIDE { 419 NOTIMPLEMENTED(); 420 return NULL; 421 } 422 423 virtual void GetDevices( 424 std::vector<scoped_refptr<UsbDevice> >* devices) OVERRIDE { 425 STLClearObject(devices); 426 std::copy(devices_.begin(), devices_.end(), back_inserter(*devices)); 427 } 428 429 std::vector<scoped_refptr<UsbDevice> > devices_; 430 }; 431 432 class MockUsbServiceForCheckingTraits : public UsbService { 433 public: 434 MockUsbServiceForCheckingTraits() : step_(0) {} 435 436 virtual ~MockUsbServiceForCheckingTraits() {} 437 438 virtual scoped_refptr<UsbDevice> GetDeviceById(uint32 unique_id) OVERRIDE { 439 NOTIMPLEMENTED(); 440 return NULL; 441 } 442 443 virtual void GetDevices( 444 std::vector<scoped_refptr<UsbDevice> >* devices) OVERRIDE { 445 STLClearObject(devices); 446 // This switch should be kept in sync with 447 // AndroidUsbBrowserTest::DeviceCountChanged. 448 switch (step_) { 449 case 0: 450 // No devices. 451 break; 452 case 1: 453 // Android device. 454 devices->push_back(new MockUsbDevice<AndroidTraits>()); 455 break; 456 case 2: 457 // Android and non-android device. 458 devices->push_back(new MockUsbDevice<AndroidTraits>()); 459 devices->push_back(new MockUsbDevice<NonAndroidTraits>()); 460 break; 461 case 3: 462 // Non-android device. 463 devices->push_back(new MockUsbDevice<NonAndroidTraits>()); 464 break; 465 } 466 step_++; 467 } 468 469 private: 470 int step_; 471 }; 472 473 class DevToolsAndroidBridgeWarmUp 474 : public DevToolsAndroidBridge::DeviceCountListener { 475 public: 476 DevToolsAndroidBridgeWarmUp(base::Closure closure, 477 scoped_refptr<DevToolsAndroidBridge> adb_bridge) 478 : closure_(closure), adb_bridge_(adb_bridge) {} 479 480 virtual void DeviceCountChanged(int count) OVERRIDE { 481 adb_bridge_->RemoveDeviceCountListener(this); 482 closure_.Run(); 483 } 484 485 base::Closure closure_; 486 scoped_refptr<DevToolsAndroidBridge> adb_bridge_; 487 }; 488 489 class AndroidUsbDiscoveryTest : public InProcessBrowserTest { 490 protected: 491 AndroidUsbDiscoveryTest() 492 : scheduler_invoked_(0) { 493 } 494 virtual void SetUpOnMainThread() OVERRIDE { 495 scoped_refptr<content::MessageLoopRunner> runner = 496 new content::MessageLoopRunner; 497 498 BrowserThread::PostTaskAndReply( 499 BrowserThread::FILE, 500 FROM_HERE, 501 base::Bind(&AndroidUsbDiscoveryTest::SetUpService, this), 502 runner->QuitClosure()); 503 runner->Run(); 504 505 adb_bridge_ = 506 DevToolsAndroidBridge::Factory::GetForProfile(browser()->profile()); 507 DCHECK(adb_bridge_.get()); 508 adb_bridge_->set_task_scheduler_for_test(base::Bind( 509 &AndroidUsbDiscoveryTest::ScheduleDeviceCountRequest, this)); 510 511 scoped_refptr<UsbDeviceProvider> provider = 512 new UsbDeviceProvider(browser()->profile()); 513 514 AndroidDeviceManager::DeviceProviders providers; 515 providers.push_back(provider); 516 adb_bridge_->set_device_providers_for_test(providers); 517 runner_ = new content::MessageLoopRunner; 518 } 519 520 void ScheduleDeviceCountRequest(const base::Closure& request) { 521 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 522 scheduler_invoked_++; 523 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, request); 524 } 525 526 virtual void SetUpService() { 527 UsbService::SetInstanceForTest(new MockUsbService()); 528 } 529 530 virtual void TearDownOnMainThread() OVERRIDE { 531 scoped_refptr<content::MessageLoopRunner> runner = 532 new content::MessageLoopRunner; 533 UsbService* service = NULL; 534 BrowserThread::PostTaskAndReply( 535 BrowserThread::FILE, 536 FROM_HERE, 537 base::Bind(&UsbService::SetInstanceForTest, service), 538 runner->QuitClosure()); 539 runner->Run(); 540 } 541 542 scoped_refptr<content::MessageLoopRunner> runner_; 543 scoped_refptr<DevToolsAndroidBridge> adb_bridge_; 544 int scheduler_invoked_; 545 }; 546 547 class AndroidUsbCountTest : public AndroidUsbDiscoveryTest { 548 protected: 549 virtual void SetUpOnMainThread() OVERRIDE { 550 AndroidUsbDiscoveryTest::SetUpOnMainThread(); 551 DevToolsAndroidBridgeWarmUp warmup(runner_->QuitClosure(), adb_bridge_); 552 adb_bridge_->AddDeviceCountListener(&warmup); 553 runner_->Run(); 554 runner_ = new content::MessageLoopRunner; 555 } 556 }; 557 558 class AndroidUsbTraitsTest : public AndroidUsbDiscoveryTest { 559 protected: 560 virtual void SetUpService() OVERRIDE { 561 UsbService::SetInstanceForTest(new MockUsbServiceForCheckingTraits()); 562 } 563 }; 564 565 class MockListListener : public DevToolsAndroidBridge::DeviceListListener { 566 public: 567 MockListListener(scoped_refptr<DevToolsAndroidBridge> adb_bridge, 568 const base::Closure& callback) 569 : adb_bridge_(adb_bridge), 570 callback_(callback) { 571 } 572 573 virtual void DeviceListChanged( 574 const DevToolsAndroidBridge::RemoteDevices& devices) OVERRIDE { 575 if (devices.size() > 0) { 576 if (devices[0]->is_connected()) { 577 ASSERT_EQ(kDeviceModel, devices[0]->model()); 578 ASSERT_EQ(kDeviceSerial, devices[0]->serial()); 579 adb_bridge_->RemoveDeviceListListener(this); 580 callback_.Run(); 581 } 582 } 583 } 584 585 scoped_refptr<DevToolsAndroidBridge> adb_bridge_; 586 base::Closure callback_; 587 }; 588 589 class MockCountListener : public DevToolsAndroidBridge::DeviceCountListener { 590 public: 591 explicit MockCountListener(scoped_refptr<DevToolsAndroidBridge> adb_bridge) 592 : adb_bridge_(adb_bridge), 593 reposts_left_(10), 594 invoked_(0) { 595 } 596 597 virtual void DeviceCountChanged(int count) OVERRIDE { 598 ++invoked_; 599 adb_bridge_->RemoveDeviceCountListener(this); 600 Shutdown(); 601 } 602 603 void Shutdown() { 604 ShutdownOnUIThread(); 605 }; 606 607 void ShutdownOnUIThread() { 608 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 609 if (reposts_left_-- == 0) { 610 base::MessageLoop::current()->Quit(); 611 } else { 612 BrowserThread::PostTask( 613 BrowserThread::FILE, 614 FROM_HERE, 615 base::Bind(&MockCountListener::ShutdownOnFileThread, 616 base::Unretained(this))); 617 } 618 } 619 620 void ShutdownOnFileThread() { 621 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 622 BrowserThread::PostTask(BrowserThread::UI, 623 FROM_HERE, 624 base::Bind(&MockCountListener::ShutdownOnUIThread, 625 base::Unretained(this))); 626 } 627 628 scoped_refptr<DevToolsAndroidBridge> adb_bridge_; 629 int reposts_left_; 630 int invoked_; 631 }; 632 633 class MockCountListenerWithReAdd : public MockCountListener { 634 public: 635 explicit MockCountListenerWithReAdd( 636 scoped_refptr<DevToolsAndroidBridge> adb_bridge) 637 : MockCountListener(adb_bridge), 638 readd_count_(2) { 639 } 640 641 virtual void DeviceCountChanged(int count) OVERRIDE { 642 ++invoked_; 643 adb_bridge_->RemoveDeviceCountListener(this); 644 if (readd_count_ > 0) { 645 readd_count_--; 646 adb_bridge_->AddDeviceCountListener(this); 647 adb_bridge_->RemoveDeviceCountListener(this); 648 adb_bridge_->AddDeviceCountListener(this); 649 } else { 650 Shutdown(); 651 } 652 } 653 654 int readd_count_; 655 }; 656 657 class MockCountListenerWithReAddWhileQueued : public MockCountListener { 658 public: 659 MockCountListenerWithReAddWhileQueued( 660 scoped_refptr<DevToolsAndroidBridge> adb_bridge) 661 : MockCountListener(adb_bridge), 662 readded_(false) { 663 } 664 665 virtual void DeviceCountChanged(int count) OVERRIDE { 666 ++invoked_; 667 if (!readded_) { 668 readded_ = true; 669 base::MessageLoop::current()->PostTask( 670 FROM_HERE, 671 base::Bind(&MockCountListenerWithReAddWhileQueued::ReAdd, 672 base::Unretained(this))); 673 } else { 674 adb_bridge_->RemoveDeviceCountListener(this); 675 Shutdown(); 676 } 677 } 678 679 void ReAdd() { 680 adb_bridge_->RemoveDeviceCountListener(this); 681 adb_bridge_->AddDeviceCountListener(this); 682 } 683 684 bool readded_; 685 }; 686 687 class MockCountListenerForCheckingTraits : public MockCountListener { 688 public: 689 MockCountListenerForCheckingTraits( 690 scoped_refptr<DevToolsAndroidBridge> adb_bridge) 691 : MockCountListener(adb_bridge), 692 step_(0) { 693 } 694 virtual void DeviceCountChanged(int count) OVERRIDE { 695 switch (step_) { 696 case 0: 697 // Check for 0 devices when no devices present. 698 EXPECT_EQ(0, count); 699 break; 700 case 1: 701 // Check for 1 device when only android device present. 702 EXPECT_EQ(1, count); 703 break; 704 case 2: 705 // Check for 1 device when android and non-android devices present. 706 EXPECT_EQ(1, count); 707 break; 708 case 3: 709 // Check for 0 devices when only non-android devices present. 710 EXPECT_EQ(0, count); 711 adb_bridge_->RemoveDeviceCountListener(this); 712 Shutdown(); 713 break; 714 default: 715 EXPECT_TRUE(false) << "Unknown step " << step_; 716 } 717 step_++; 718 } 719 720 int step_; 721 }; 722 723 } // namespace 724 725 IN_PROC_BROWSER_TEST_F(AndroidUsbDiscoveryTest, TestDeviceDiscovery) { 726 MockListListener listener(adb_bridge_, runner_->QuitClosure()); 727 adb_bridge_->AddDeviceListListener(&listener); 728 runner_->Run(); 729 } 730 731 IN_PROC_BROWSER_TEST_F(AndroidUsbCountTest, 732 TestNoMultipleCallsRemoveInCallback) { 733 MockCountListener listener(adb_bridge_); 734 adb_bridge_->AddDeviceCountListener(&listener); 735 runner_->Run(); 736 EXPECT_EQ(1, listener.invoked_); 737 EXPECT_EQ(listener.invoked_ - 1, scheduler_invoked_); 738 } 739 740 IN_PROC_BROWSER_TEST_F(AndroidUsbCountTest, 741 TestNoMultipleCallsRemoveAddInCallback) { 742 MockCountListenerWithReAdd listener(adb_bridge_); 743 adb_bridge_->AddDeviceCountListener(&listener); 744 runner_->Run(); 745 EXPECT_EQ(3, listener.invoked_); 746 EXPECT_EQ(listener.invoked_ - 1, scheduler_invoked_); 747 } 748 749 IN_PROC_BROWSER_TEST_F(AndroidUsbCountTest, 750 TestNoMultipleCallsRemoveAddOnStart) { 751 MockCountListener listener(adb_bridge_); 752 adb_bridge_->AddDeviceCountListener(&listener); 753 adb_bridge_->RemoveDeviceCountListener(&listener); 754 adb_bridge_->AddDeviceCountListener(&listener); 755 runner_->Run(); 756 EXPECT_EQ(1, listener.invoked_); 757 EXPECT_EQ(listener.invoked_ - 1, scheduler_invoked_); 758 } 759 760 IN_PROC_BROWSER_TEST_F(AndroidUsbCountTest, 761 TestNoMultipleCallsRemoveAddWhileQueued) { 762 MockCountListenerWithReAddWhileQueued listener(adb_bridge_); 763 adb_bridge_->AddDeviceCountListener(&listener); 764 runner_->Run(); 765 EXPECT_EQ(2, listener.invoked_); 766 EXPECT_EQ(listener.invoked_ - 1, scheduler_invoked_); 767 } 768 769 IN_PROC_BROWSER_TEST_F(AndroidUsbTraitsTest, TestDeviceCounting) { 770 MockCountListenerForCheckingTraits listener(adb_bridge_); 771 adb_bridge_->AddDeviceCountListener(&listener); 772 runner_->Run(); 773 } 774
