Use USB hotplug events from libusb when possible.

device/test/usb_test_gadget_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "device/test/usb_test_gadget.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_device_handle.h"
 #include "device/usb/usb_service.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
 
 using ::base::PlatformThread;
 using ::base::TimeDelta;
 
 namespace device {
 
 namespace {
 
 static const char kCommandLineSwitch[] = "enable-gadget-tests";
 static const int kClaimRetries = 100;  // 5 seconds
 static const int kDisconnectRetries = 100;  // 5 seconds
 static const int kRetryPeriod = 50;  // 0.05 seconds
 static const int kReconnectRetries = 100;  // 5 seconds
 static const int kUpdateRetries = 100;  // 5 seconds
 
+// Wait for the given time delta while still running the main loop. This is
+// necessary so that device add/remove events are processed by the UsbService.
+void SleepWithRunLoop(base::TimeDelta delta) {
+  base::RunLoop run_loop;
+  base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
+                                                run_loop.QuitClosure(), delta);
+  run_loop.Run();
+}
+
 struct UsbTestGadgetConfiguration {
   UsbTestGadget::Type type;
   const char* http_resource;
   uint16 product_id;
 };
 
 static const struct UsbTestGadgetConfiguration kConfigurations[] = {
     {UsbTestGadget::DEFAULT, "/unconfigure", 0x58F0},
     {UsbTestGadget::KEYBOARD, "/keyboard/configure", 0x58F1},
     {UsbTestGadget::MOUSE, "/mouse/configure", 0x58F2},
@@ skipping 68 matching lines @@
 
 scoped_ptr<UsbTestGadget> UsbTestGadget::Claim() {
   scoped_ptr<UsbTestGadgetImpl> gadget(new UsbTestGadgetImpl);
 
   int retries = kClaimRetries;
   while (!gadget->FindUnclaimed()) {
     if (--retries == 0) {
       LOG(ERROR) << "Failed to find an unclaimed device.";
       return scoped_ptr<UsbTestGadget>();
     }
-    PlatformThread::Sleep(TimeDelta::FromMilliseconds(kRetryPeriod));
+    SleepWithRunLoop(TimeDelta::FromMilliseconds(kRetryPeriod));
   }
   VLOG(1) << "It took " << (kClaimRetries - retries)
           << " retries to find an unclaimed device.";
 
   return gadget.Pass();
 }
 
 UsbTestGadgetImpl::UsbTestGadgetImpl() {
   net::URLRequestContextBuilder context_builder;
   context_builder.set_proxy_service(net::ProxyService::CreateDirect());
@@ skipping 152 matching lines @@
     return false;
   }
 
   int retries = kUpdateRetries;
   std::string new_version;
   while (!GetVersion(&new_version) || new_version != version) {
     if (--retries == 0) {
       LOG(ERROR) << "Device not responding with new version.";
       return false;
     }
-    PlatformThread::Sleep(TimeDelta::FromMilliseconds(kRetryPeriod));
+    SleepWithRunLoop(TimeDelta::FromMilliseconds(kRetryPeriod));
   }
   VLOG(1) << "It took " << (kUpdateRetries - retries)
           << " retries to see the new version.";
 
   // Release the old reference to the device and try to open a new one.
   device_ = NULL;
   retries = kReconnectRetries;
   while (!FindClaimed()) {
     if (--retries == 0) {
       LOG(ERROR) << "Failed to find updated device.";
       return false;
     }
-    PlatformThread::Sleep(TimeDelta::FromMilliseconds(kRetryPeriod));
+    SleepWithRunLoop(TimeDelta::FromMilliseconds(kRetryPeriod));
   }
   VLOG(1) << "It took " << (kReconnectRetries - retries)
           << " retries to find the updated device.";
 
   return true;
 }
 
 bool UsbTestGadgetImpl::FindClaimed() {
   CHECK(!device_.get());
 
@@ skipping 115 matching lines @@
   int retries = kReconnectRetries;
   while (true) {
     device_ = NULL;
     if (FindClaimed() && device_->product_id() == config->product_id) {
       break;
     }
     if (--retries == 0) {
       LOG(ERROR) << "Failed to find updated device.";
       return false;
     }
-    PlatformThread::Sleep(TimeDelta::FromMilliseconds(kRetryPeriod));
+    SleepWithRunLoop(TimeDelta::FromMilliseconds(kRetryPeriod));
   }
   VLOG(1) << "It took " << (kReconnectRetries - retries)
           << " retries to find the updated device.";
 
   return true;
 }
 
 bool UsbTestGadgetImpl::Disconnect() {
   const GURL url("http://" + device_address_ + "/disconnect");
   const int response_code = SimplePOSTRequest(url, "");
 
   if (response_code != 200) {
     LOG(ERROR) << "Unexpected HTTP " << response_code << " from /disconnect.";
     return false;
   }
 
   // Release the old reference to the device and wait until it can't be found.
   int retries = kDisconnectRetries;
   while (true) {
     device_ = NULL;
     if (!FindClaimed()) {
       break;
     }
     if (--retries == 0) {
       LOG(ERROR) << "Device did not disconnect.";
       return false;
     }
-    PlatformThread::Sleep(TimeDelta::FromMilliseconds(kRetryPeriod));
+    SleepWithRunLoop(TimeDelta::FromMilliseconds(kRetryPeriod));
   }
   VLOG(1) << "It took " << (kDisconnectRetries - retries)
           << " retries for the device to disconnect.";
 
   return true;
 }
 
 bool UsbTestGadgetImpl::Reconnect() {
   const GURL url("http://" + device_address_ + "/reconnect");
   const int response_code = SimplePOSTRequest(url, "");
 
   if (response_code != 200) {
     LOG(ERROR) << "Unexpected HTTP " << response_code << " from /reconnect.";
     return false;
   }
 
   int retries = kDisconnectRetries;
   while (true) {
     if (FindClaimed()) {
       break;
     }
     if (--retries == 0) {
       LOG(ERROR) << "Device did not reconnect.";
       return false;
     }
-    PlatformThread::Sleep(TimeDelta::FromMilliseconds(kRetryPeriod));
+    SleepWithRunLoop(TimeDelta::FromMilliseconds(kRetryPeriod));
   }
   VLOG(1) << "It took " << (kDisconnectRetries - retries)
           << " retries for the device to reconnect.";
 
   return true;
 }
 
 }  // namespace device