Remove page visibility requirement for WebUSB.

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"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMArrayBufferView.h"
 #include "core/dom/DOMException.h"
-#include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "modules/webusb/USBConfiguration.h"
 #include "modules/webusb/USBControlTransferParameters.h"
 #include "modules/webusb/USBError.h"
 #include "modules/webusb/USBInTransferResult.h"
 #include "modules/webusb/USBIsochronousInTransferResult.h"
 #include "modules/webusb/USBIsochronousOutTransferResult.h"
 #include "modules/webusb/USBOutTransferResult.h"
 #include "public/platform/modules/webusb/WebUSBTransferInfo.h"
 #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.";
-
-
 
 String convertTransferStatus(const WebUSBTransferInfo::Status& status)
 {
     switch (status) {
     case WebUSBTransferInfo::Status::Ok:
         return "ok";
     case WebUSBTransferInfo::Status::Stall:
         return "stall";
     case WebUSBTransferInfo::Status::Babble:
         return "babble";
@@ skipping 11 matching lines @@
         , m_desiredState(desiredState)
     {
     }
 
     void onSuccess() override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
 
         m_device->onDeviceOpenedOrClosed(m_desiredState);
-        if (m_device->page()->isPageVisible()) {
-            m_resolver->resolve();
-        } else {
-            m_device->pageVisibilityChanged();
-            m_resolver->reject(DOMException::create(SecurityError, kVisibiltyError));
-            return;
-        }
+        m_resolver->resolve();
     }
 
     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)
     , m_inEndpoints(15)
     , m_outEndpoints(15)
 {
     int configurationIndex = findConfigurationIndex(info().activeConfiguration);
     if (configurationIndex != -1)
         onConfigurationSelected(true /* success */, configurationIndex);
@@ skipping 286 matching lines @@
 }
 
 void USBDevice::contextDestroyed()
 {
     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 (!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 (!ensurePageVisible(resolver))
-        return false;
     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;
 }
@@ skipping 94 matching lines @@
             continue; // Ignore endpoints with invalid indices.
         auto& bitVector = endpoint.direction == WebUSBDevice::TransferDirection::In ? m_inEndpoints : m_outEndpoints;
         if (set)
             bitVector.set(endpoint.endpointNumber - 1);
         else
             bitVector.clear(endpoint.endpointNumber - 1);
     }
 }
 
 } // namespace blink