Make new WebUSB implementation more resilient to garbage collection.

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/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ToV8.h"
 #include "core/dom/DOMArrayBuffer.h"
@@ skipping 81 matching lines @@
 } // namespace
 
 USBDevice::USBDevice(usb::DeviceInfoPtr deviceInfo, usb::DevicePtr device, ExecutionContext* context)
     : ContextLifecycleObserver(context)
     , m_deviceInfo(std::move(deviceInfo))
     , m_device(std::move(device))
     , m_opened(false)
     , m_deviceStateChangeInProgress(false)
     , m_configurationIndex(-1)
 {
-    if (m_device) {
-        m_device.set_connection_error_handler([this]() {
-            m_device.reset();
-            m_opened = false;
-            for (ScriptPromiseResolver* resolver : m_deviceRequests) {
-                if (isActive(resolver))
-                    resolver->reject(DOMException::create(NotFoundError, kDeviceUnavailable));
-            }
-        });
-    }
+    if (m_device)
+        m_device.set_connection_error_handler(createBaseCallback(bind(&USBDevice::onConnectionError, WeakPersistentThisPointer<USBDevice>(this))));

[haraken, 2016/04/25 08:47:05]

Just to confirm: Your intention is that the error callback should not be called
if the USBDevice object is already garbage-collected when the error callback is
about to run, right?

I'm curious why you cannot just use a Persistent handle (implicitly created by
WTF::bind when you pass the |this| pointer).

     int configurationIndex = findConfigurationIndex(info().active_configuration);
     if (configurationIndex != -1)
         onConfigurationSelected(true /* success */, configurationIndex);
 }
 
 USBDevice::~USBDevice()
 {
-    DCHECK(!m_device);
+    // |m_device| may still be valid but there should be no more outstanding
+    // requests because each holds a persistent handle to this object.
     DCHECK(m_deviceRequests.isEmpty());
 }
 
 bool USBDevice::isInterfaceClaimed(size_t configurationIndex, size_t interfaceIndex) const
 {
     return m_configurationIndex != -1 && static_cast<size_t>(m_configurationIndex) == configurationIndex && m_claimedInterfaces.get(interfaceIndex);
 }
 
 size_t USBDevice::selectedAlternateInterface(size_t interfaceIndex) const
 {
@@ skipping 660 matching lines @@
     m_deviceRequests.remove(resolver);
     if (!isActive(resolver))
         return;
 
     if (success)
         resolver->resolve();
     else
         resolver->reject(DOMException::create(NetworkError, "Unable to reset the device."));
 }
 
+void USBDevice::onConnectionError()
+{
+    m_device.reset();
+    m_opened = false;
+    for (ScriptPromiseResolver* resolver : m_deviceRequests) {
+        if (isActive(resolver))
+            resolver->reject(DOMException::create(NotFoundError, kDeviceUnavailable));
+    }
+    m_deviceRequests.clear();
+}
+
 } // namespace blink