Make navigator.usb open the DeviceManager connection lazily.

third_party/WebKit/Source/modules/webusb/USB.cpp

 // Copyright 2015 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 "modules/webusb/USB.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
@@ skipping 35 matching lines @@
   if (mojoFilter->has_protocol_code)
     mojoFilter->protocol_code = filter.protocolCode();
   if (filter.hasSerialNumber())
     mojoFilter->serial_number = filter.serialNumber();
   return mojoFilter;
 }
 
 }  // namespace
 
 USB::USB(LocalFrame& frame)
-    : ContextLifecycleObserver(frame.document()), m_clientBinding(this) {
-  frame.interfaceProvider()->getInterface(mojo::MakeRequest(&m_deviceManager));
-  m_deviceManager.set_connection_error_handler(convertToBaseCallback(WTF::bind(
-      &USB::onDeviceManagerConnectionError, wrapWeakPersistent(this))));
-  m_deviceManager->SetClient(m_clientBinding.CreateInterfacePtrAndBind());
-}
+    : ContextLifecycleObserver(frame.document()), m_clientBinding(this) {}
 
 USB::~USB() {
   // |m_deviceManager| and |m_chooserService| may still be valid but there
   // should be no more outstanding requests to them because each holds a
   // persistent handle to this object.
   DCHECK(m_deviceManagerRequests.isEmpty());
   DCHECK(m_chooserServiceRequests.isEmpty());
 }
 
 void USB::dispose() {
   // The pipe to this object must be closed when is marked unreachable to
   // prevent messages from being dispatched before lazy sweeping.
   m_clientBinding.Close();
 }
 
 ScriptPromise USB::getDevices(ScriptState* scriptState) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
+  ensureDeviceManagerConnection();
   if (!m_deviceManager) {
     resolver->reject(DOMException::create(NotSupportedError));
   } else {
     m_deviceManagerRequests.insert(resolver);
     m_deviceManager->GetDevices(
         nullptr, convertToBaseCallback(WTF::bind(&USB::onGetDevices,
                                                  wrapPersistent(this),
                                                  wrapPersistent(resolver))));
   }
   return promise;
 }
 
 ScriptPromise USB::requestDevice(ScriptState* scriptState,
                                  const USBDeviceRequestOptions& options) {
-  ExecutionContext* executionContext = scriptState->getExecutionContext();
-
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   if (!m_chooserService) {
-    LocalFrame* frame = executionContext->isDocument()
-                            ? toDocument(executionContext)->frame()
-                            : nullptr;
-    if (!frame) {
+    if (!frame()) {
       resolver->reject(DOMException::create(NotSupportedError));
       return promise;
     }
-    frame->interfaceProvider()->getInterface(
+    frame()->interfaceProvider()->getInterface(
         mojo::MakeRequest(&m_chooserService));
     m_chooserService.set_connection_error_handler(
         convertToBaseCallback(WTF::bind(&USB::onChooserServiceConnectionError,
                                         wrapWeakPersistent(this))));
   }
 
   if (!UserGestureIndicator::consumeUserGesture()) {
     resolver->reject(DOMException::create(
         SecurityError,
         "Must be handling a user gesture to show a permission request."));
@@ skipping 55 matching lines @@
   m_deviceManagerRequests.erase(resolver);
 }
 
 void USB::onGetPermission(ScriptPromiseResolver* resolver,
                           usb::DeviceInfoPtr deviceInfo) {
   auto requestEntry = m_chooserServiceRequests.find(resolver);
   if (requestEntry == m_chooserServiceRequests.end())
     return;
   m_chooserServiceRequests.erase(requestEntry);
 
+  ensureDeviceManagerConnection();
   if (!m_deviceManager) {
     resolver->reject(DOMException::create(NotFoundError, kNoServiceError));
     return;
   }
 
-  if (deviceInfo)
+  if (deviceInfo) {
     resolver->resolve(getOrCreateDevice(std::move(deviceInfo)));
-  else
+  } else {
     resolver->reject(
         DOMException::create(NotFoundError, "No device selected."));
+  }
 }
 
 void USB::OnDeviceAdded(usb::DeviceInfoPtr deviceInfo) {
   if (!m_deviceManager)
     return;
 
   dispatchEvent(USBConnectionEvent::create(
       EventTypeNames::connect, getOrCreateDevice(std::move(deviceInfo))));
 }
 
 void USB::OnDeviceRemoved(usb::DeviceInfoPtr deviceInfo) {
   String guid = deviceInfo->guid;
   USBDevice* device = m_deviceCache.at(guid);
-  if (!device)
+  if (!device) {
     device = USBDevice::create(std::move(deviceInfo), nullptr,
                                getExecutionContext());
+  }
   dispatchEvent(USBConnectionEvent::create(EventTypeNames::disconnect, device));
   m_deviceCache.erase(guid);
 }
 
 void USB::onDeviceManagerConnectionError() {
   m_deviceManager.reset();
+  m_clientBinding.Close();
   for (ScriptPromiseResolver* resolver : m_deviceManagerRequests)
     resolver->reject(DOMException::create(NotFoundError, kNoServiceError));
   m_deviceManagerRequests.clear();
 }
 
 void USB::onChooserServiceConnectionError() {
   m_chooserService.reset();
   for (ScriptPromiseResolver* resolver : m_chooserServiceRequests)
     resolver->reject(DOMException::create(NotFoundError, kNoServiceError));
   m_chooserServiceRequests.clear();
 }
 
+void USB::addedEventListener(const AtomicString& eventType,
+                             RegisteredEventListener& listener) {
+  EventTargetWithInlineData::addedEventListener(eventType, listener);
+  if (eventType == EventTypeNames::connect ||
+      eventType == EventTypeNames::disconnect) {
+    ensureDeviceManagerConnection();

[mcasas, 2017/03/16 17:00:48]

Can USB receive connect/disconnect events before 
running either getDevices() or requestDevice(...) ? 
Still, why do we need to connect to the device 
manager here? Wouldn't we do it  anyway during either 
of the two USB.idl operations?

[Reilly Grant (use Gerrit), 2017/03/16 17:43:14]

Yes. An event will be dispatched whenever a device the script has permission to
access is added or removed. getDevices() returns the current state and
requestDevice() asks for more permissions.

+  }
+}
+
+void USB::ensureDeviceManagerConnection() {
+  if (m_deviceManager || !frame())
+    return;
+
+  frame()->interfaceProvider()->getInterface(
+      mojo::MakeRequest(&m_deviceManager));
+  m_deviceManager.set_connection_error_handler(convertToBaseCallback(WTF::bind(
+      &USB::onDeviceManagerConnectionError, wrapWeakPersistent(this))));
+
+  DCHECK(!m_clientBinding.is_bound());
+  m_deviceManager->SetClient(m_clientBinding.CreateInterfacePtrAndBind());
+}
+
 DEFINE_TRACE(USB) {
   visitor->trace(m_deviceManagerRequests);
   visitor->trace(m_chooserServiceRequests);
   visitor->trace(m_deviceCache);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
 
 }  // namespace blink