WebUSB: Remove guid property from USBDevice.

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 127 matching lines @@
 }
 
 void USB::contextDestroyed()
 {
     m_deviceManager.reset();
     m_deviceManagerRequests.clear();
     m_chooserService.reset();
     m_chooserServiceRequests.clear();
 }
 
+USBDevice* USB::getOrCreateDevice(usb::DeviceInfoPtr deviceInfo)
+{
+    USBDevice* device = m_deviceCache.get(deviceInfo->guid);
+    if (!device) {
+        String guid = deviceInfo->guid;
+        usb::DevicePtr pipe;
+        m_deviceManager->GetDevice(guid, mojo::GetProxy(&pipe));
+        device = USBDevice::create(std::move(deviceInfo), std::move(pipe), getExecutionContext());
+        m_deviceCache.add(guid, device);
+    }
+    return device;
+}
+
 void USB::onGetDevices(ScriptPromiseResolver* resolver, mojo::WTFArray<usb::DeviceInfoPtr> deviceInfos)
 {
     auto requestEntry = m_deviceManagerRequests.find(resolver);
     if (requestEntry == m_deviceManagerRequests.end())
         return;
     m_deviceManagerRequests.remove(requestEntry);
 
     HeapVector<Member<USBDevice>> devices;
-    for (auto& deviceInfo : deviceInfos.PassStorage()) {
-        usb::DevicePtr device;
-        m_deviceManager->GetDevice(deviceInfo->guid, mojo::GetProxy(&device));
-        devices.append(USBDevice::create(std::move(deviceInfo), std::move(device), resolver->getExecutionContext()));
-    }
+    for (auto& deviceInfo : deviceInfos.PassStorage())
+        devices.append(getOrCreateDevice(std::move(deviceInfo)));
     resolver->resolve(devices);
     m_deviceManagerRequests.remove(resolver);
 }
 
 void USB::onGetPermission(ScriptPromiseResolver* resolver, usb::DeviceInfoPtr deviceInfo)
 {
     auto requestEntry = m_chooserServiceRequests.find(resolver);
     if (requestEntry == m_chooserServiceRequests.end())
         return;
     m_chooserServiceRequests.remove(requestEntry);
 
     if (!m_deviceManager) {
         resolver->reject(DOMException::create(NotFoundError, kNoServiceError));
         return;
     }
 
-    if (deviceInfo) {
-        usb::DevicePtr device;
-        m_deviceManager->GetDevice(deviceInfo->guid, mojo::GetProxy(&device));
-        resolver->resolve(USBDevice::create(std::move(deviceInfo), std::move(device), resolver->getExecutionContext()));
-    } else {
+    if (deviceInfo)
+        resolver->resolve(getOrCreateDevice(std::move(deviceInfo)));
+    else
         resolver->reject(DOMException::create(NotFoundError, "No device selected."));
-    }
 }
 
 void USB::OnDeviceAdded(usb::DeviceInfoPtr deviceInfo)
 {
     if (!m_deviceManager)
         return;
 
-    usb::DevicePtr device;
-    m_deviceManager->GetDevice(deviceInfo->guid, mojo::GetProxy(&device));
-    dispatchEvent(USBConnectionEvent::create(EventTypeNames::connect, USBDevice::create(std::move(deviceInfo), std::move(device), getExecutionContext())));
+    dispatchEvent(USBConnectionEvent::create(EventTypeNames::connect, getOrCreateDevice(std::move(deviceInfo))));
 }
 
 void USB::OnDeviceRemoved(usb::DeviceInfoPtr deviceInfo)
 {
-    dispatchEvent(USBConnectionEvent::create(EventTypeNames::disconnect, USBDevice::create(std::move(deviceInfo), nullptr, getExecutionContext())));
+    String guid = deviceInfo->guid;
+    USBDevice* device = m_deviceCache.get(guid);
+    if (!device)
+        device = USBDevice::create(std::move(deviceInfo), nullptr, getExecutionContext());
+    dispatchEvent(USBConnectionEvent::create(EventTypeNames::disconnect, device));
+    m_deviceCache.remove(guid);
 }
 
 void USB::onDeviceManagerConnectionError()
 {
     m_deviceManager.reset();
     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();
 }
 
 DEFINE_TRACE(USB)
 {
     EventTargetWithInlineData::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
     visitor->trace(m_deviceManagerRequests);
     visitor->trace(m_chooserServiceRequests);
+    visitor->trace(m_deviceCache);
 }
 
 } // namespace blink