Close USB device connections when the page is hidden.

third_party/WebKit/Source/modules/webusb/USBDevice.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/USBDevice.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ToV8.h"
@@ skipping 12 matching lines @@
 #include "wtf/Assertions.h"
 
 namespace blink {
 
 namespace {
 
 const char kDeviceStateChangeInProgress[] = "An operation that changes the device state is in progress.";
 const char kInterfaceNotFound[] = "The interface number provided is not supported by the device in its current configuration.";
 const char kInterfaceStateChangeInProgress[] = "An operation that changes interface state is in progress.";
 const char kOpenRequired[] = "The device must be opened first.";
+const char kVisibiltyError[] = "Connection is only allowed while the page is visible. This is a temporary measure until we are able to effectively communicate to the user that the page is connected to a device.";
 
 DOMException* convertControlTransferParameters(
     WebUSBDevice::TransferDirection direction,
     const USBControlTransferParameters& parameters,
     WebUSBDevice::ControlTransferParameters* webParameters)
 {
     webParameters->direction = direction;
 
     if (parameters.requestType() == "standard")
         webParameters->type = WebUSBDevice::RequestType::Standard;
@@ skipping 44 matching lines @@
         : m_device(device)
         , m_resolver(resolver)
         , m_desiredState(desiredState)
     {
     }
 
     void onSuccess() override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
+
         m_device->onDeviceOpenedOrClosed(m_desiredState);
-        m_resolver->resolve();
+        if (m_device->page()->isPageVisible()) {
+            m_resolver->resolve();
+        } else {
+            m_device->pageVisibilityChanged();
+            m_resolver->reject(DOMException::create(SecurityError, kVisibiltyError));
+            return;
+        }
     }
 
     void onError(const WebUSBError& e) override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         m_device->onDeviceOpenedOrClosed(!m_desiredState);
         m_resolver->reject(USBError::take(m_resolver, e));
     }
 
@@ skipping 196 matching lines @@
 } // namespace
 
 // static
 USBDevice* USBDevice::take(ScriptPromiseResolver* resolver, PassOwnPtr<WebUSBDevice> device)
 {
     return USBDevice::create(device, resolver->getExecutionContext());
 }
 
 USBDevice::USBDevice(PassOwnPtr<WebUSBDevice> device, ExecutionContext* context)
     : ContextLifecycleObserver(context)
+    , PageLifecycleObserver(toDocument(context)->page())
     , m_device(device)
     , m_opened(false)
     , m_deviceStateChangeInProgress(false)
     , m_configurationIndex(-1)
 {
     int configurationIndex = findConfigurationIndex(info().activeConfiguration);
     if (configurationIndex != -1)
         onConfigurationSelected(true /* success */, configurationIndex);
 }
 
@@ skipping 275 matching lines @@
         if (!m_opened)
             resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
         else
             m_device->reset(new CallbackPromiseAdapter<void, USBError>(resolver));
     }
     return promise;
 }
 
 void USBDevice::contextDestroyed()
 {
-    if (m_opened)
+    if (m_opened) {
         m_device->close(new WebUSBDeviceCloseCallbacks());
+        m_opened = false;
+    }
+}
+
+void USBDevice::pageVisibilityChanged()
+{
+    if (!page()->isPageVisible() && m_opened) {
+        m_device->close(new WebUSBDeviceCloseCallbacks());
+        m_opened = false;
+    }
 }
 
 DEFINE_TRACE(USBDevice)
 {
     ContextLifecycleObserver::trace(visitor);
+    PageLifecycleObserver::trace(visitor);
 }
 
 int USBDevice::findConfigurationIndex(uint8_t configurationValue) const
 {
     const auto& configurations = info().configurations;
     for (size_t i = 0; i < configurations.size(); ++i) {
         if (configurations[i].configurationValue == configurationValue)
             return i;
     }
     return -1;
@@ skipping 14 matching lines @@
 {
     ASSERT(m_configurationIndex != -1);
     const auto& alternates = info().configurations[m_configurationIndex].interfaces[interfaceIndex].alternates;
     for (size_t i = 0; i < alternates.size(); ++i) {
         if (alternates[i].alternateSetting == alternateSetting)
             return i;
     }
     return -1;
 }
 
+bool USBDevice::ensurePageVisible(ScriptPromiseResolver* resolver) const
+{
+    if (!page()->isPageVisible()) {
+        resolver->reject(DOMException::create(SecurityError, kVisibiltyError));
+        return false;
+    }
+    return true;
+}
+
 bool USBDevice::ensureNoDeviceOrInterfaceChangeInProgress(ScriptPromiseResolver* resolver) const
 {
-    if (m_deviceStateChangeInProgress) {
-        resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
-    } else if (anyInterfaceChangeInProgress()) {
-        resolver->reject(DOMException::create(InvalidStateError, kInterfaceStateChangeInProgress));
-    } else {
-        return true;
+    if (ensurePageVisible(resolver)) {

[ortuno, 2016/03/22 02:09:08]

nit: if you want to save a level of indentation:
if (!ensurePageVisible(resolver))
  return false;
...

+        if (m_deviceStateChangeInProgress)
+            resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
+        else if (anyInterfaceChangeInProgress())
+            resolver->reject(DOMException::create(InvalidStateError, kInterfaceStateChangeInProgress));
+        else
+            return true;
     }
     return false;
 }
 
 bool USBDevice::ensureDeviceConfigured(ScriptPromiseResolver* resolver) const
 {
-    if (!m_opened) {
-        resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
-    } else if (m_deviceStateChangeInProgress) {
-        resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
-    } else if (m_configurationIndex == -1) {
-        resolver->reject(DOMException::create(InvalidStateError, "The device must have a configuration selected."));
-    } else {
-        return true;
+    if (ensurePageVisible(resolver)) {

[ortuno, 2016/03/22 02:09:08]

nit: same here

+        if (m_deviceStateChangeInProgress)
+            resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
+        else if (!m_opened)
+            resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
+        else if (m_configurationIndex == -1)
+            resolver->reject(DOMException::create(InvalidStateError, "The device must have a configuration selected."));
+        else
+            return true;
     }
     return false;
 }
 
 bool USBDevice::ensureInterfaceClaimed(uint8_t interfaceNumber, ScriptPromiseResolver* resolver) const
 {
     if (!ensureDeviceConfigured(resolver))
         return false;
     int interfaceIndex = findInterfaceIndex(interfaceNumber);
-    if (interfaceIndex == -1) {
+    if (interfaceIndex == -1)
         resolver->reject(DOMException::create(NotFoundError, kInterfaceNotFound));
-    } else if (m_interfaceStateChangeInProgress.get(interfaceIndex)) {
+    else if (m_interfaceStateChangeInProgress.get(interfaceIndex))
         resolver->reject(DOMException::create(InvalidStateError, kInterfaceStateChangeInProgress));
-    } else if (!m_claimedInterfaces.get(interfaceIndex)) {
+    else if (!m_claimedInterfaces.get(interfaceIndex))
         resolver->reject(DOMException::create(InvalidStateError, "The specified interface has not been claimed."));
-    } else {
+    else
         return true;
-    }
     return false;
 }
 
 bool USBDevice::ensureEndpointAvailable(bool inTransfer, uint8_t endpointNumber, ScriptPromiseResolver* resolver) const
 {
     // TODO(reillyg): Check endpoint availability once Blink is tracking which
     // alternate interfaces are selected.
     return ensureDeviceConfigured(resolver);
 }
 
 bool USBDevice::anyInterfaceChangeInProgress() const
 {
     for (size_t i = 0; i < m_interfaceStateChangeInProgress.size(); ++i) {
         if (m_interfaceStateChangeInProgress.quickGet(i))
             return true;
     }
     return false;
 }
 
 } // namespace blink