Make USB a ContextLifecycleObserver.

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/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
@@ skipping 57 matching lines @@
         HeapVector<Member<USBDevice>> devices;
         for (const auto webDevice : *webDevices)
             devices.append(USBDevice::create(adoptPtr(webDevice), resolver->getExecutionContext()));
         return devices;
     }
 };
 
 } // namespace
 
 USB::USB(LocalFrame& frame)
-    : LocalFrameLifecycleObserver(&frame)
+    : ContextLifecycleObserver(frame.document())
     , m_client(USBController::from(frame).client())

[haraken, 2016/04/06 00:15:12]

It looks strange that USB is observing ExecutionContext while USBController is
associated with Frame. Would you explain the relationship between Page (which
doesn't change over navigation), Frame (which changes over navigation),
ExecutionContext (which is actually a document in the frame) and USB things?

[Reilly Grant (use Gerrit), 2016/04/06 00:54:34]

The Frame is what provides a connection to Mojo services in Chrome. Currently
that's mediated through the WebUSBClient provided by the USBController but very
soon this constructor will simply request an instance of the
device::usb::DeviceManager Mojo service from frame.serviceRegistry().

I believe that the USB objects in Blink, however, should be owned by a
particular ExecutionContext. I don't want to depend on GC to clean them up
because if the page is refreshed I want old device connections to be cleaned up
immediately so that the page can reconnect as soon as it loads.

 {
     if (m_client)
         m_client->addObserver(this);
 }
 
 USB::~USB()
 {
     if (m_client)
         m_client->removeObserver(this);
 }
@@ skipping 31 matching lines @@
 
     WebUSBDeviceRequestOptions webOptions;
     convertDeviceRequestOptions(options, &webOptions);
     m_client->requestDevice(webOptions, new CallbackPromiseAdapter<USBDevice, USBError>(resolver));
 
     return promise;
 }
 
 ExecutionContext* USB::getExecutionContext() const
 {
-    return frame() ? frame()->document() : nullptr;
+    return ContextLifecycleObserver::getExecutionContext();
 }
 
 const AtomicString& USB::interfaceName() const
 {
     return EventTargetNames::USB;
 }
 
-void USB::willDetachFrameHost()
+void USB::contextDestroyed()
 {
     if (m_client)
         m_client->removeObserver(this);
     m_client = nullptr;
 }
 
 void USB::onDeviceConnected(WebPassOwnPtr<WebUSBDevice> device)
 {
     dispatchEvent(USBConnectionEvent::create(EventTypeNames::connect, USBDevice::create(device.release(), getExecutionContext())));
 }
 
 void USB::onDeviceDisconnected(WebPassOwnPtr<WebUSBDevice> device)
 {
     dispatchEvent(USBConnectionEvent::create(EventTypeNames::disconnect, USBDevice::create(device.release(), getExecutionContext())));
 }
 
 DEFINE_TRACE(USB)
 {
     RefCountedGarbageCollectedEventTargetWithInlineData<USB>::trace(visitor);
-    LocalFrameLifecycleObserver::trace(visitor);
+    ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink