Hide USB service unavailability from web content

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"
 #include "core/dom/ExceptionCode.h"
 #include "device/usb/public/interfaces/device.mojom-blink.h"
 #include "modules/EventTargetModules.h"
 #include "modules/webusb/USBConnectionEvent.h"
 #include "modules/webusb/USBDevice.h"
 #include "modules/webusb/USBDeviceFilter.h"
 #include "modules/webusb/USBDeviceRequestOptions.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/mojo/MojoHelper.h"
 #include "platform/wtf/Functional.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 
 namespace usb = device::usb::blink;
 
 namespace blink {
 namespace {
 
-const char kNoServiceError[] = "USB service unavailable.";
+const char kNoDeviceSelected[] = "No device selected.";
 
 usb::DeviceFilterPtr ConvertDeviceFilter(const USBDeviceFilter& filter) {
   auto mojo_filter = usb::DeviceFilter::New();
   mojo_filter->has_vendor_id = filter.hasVendorId();
   if (mojo_filter->has_vendor_id)
     mojo_filter->vendor_id = filter.vendorId();
   mojo_filter->has_product_id = filter.hasProductId();
   if (mojo_filter->has_product_id)
     mojo_filter->product_id = filter.productId();
   mojo_filter->has_class_code = filter.hasClassCode();
@@ skipping 125 matching lines @@
 }
 
 void USB::OnGetPermission(ScriptPromiseResolver* resolver,
                           usb::DeviceInfoPtr device_info) {
   auto request_entry = chooser_service_requests_.Find(resolver);
   if (request_entry == chooser_service_requests_.end())
     return;
   chooser_service_requests_.erase(request_entry);
 
   EnsureDeviceManagerConnection();
-  if (!device_manager_) {
-    resolver->Reject(DOMException::Create(kNotFoundError, kNoServiceError));
-    return;
-  }
 
-  if (device_info) {
+  if (device_manager_ && device_info) {
     resolver->Resolve(GetOrCreateDevice(std::move(device_info)));
   } else {
-    resolver->Reject(
-        DOMException::Create(kNotFoundError, "No device selected."));
+    resolver->Reject(DOMException::Create(kNotFoundError, kNoDeviceSelected));
   }
 }
 
 void USB::OnDeviceAdded(usb::DeviceInfoPtr device_info) {
   if (!device_manager_)
     return;
 
   DispatchEvent(USBConnectionEvent::Create(
       EventTypeNames::connect, GetOrCreateDevice(std::move(device_info))));
 }
 
 void USB::OnDeviceRemoved(usb::DeviceInfoPtr device_info) {
   String guid = device_info->guid;
   USBDevice* device = device_cache_.at(guid);
   if (!device) {
     device = USBDevice::Create(std::move(device_info), nullptr,
                                GetExecutionContext());
   }
   DispatchEvent(USBConnectionEvent::Create(EventTypeNames::disconnect, device));
   device_cache_.erase(guid);
 }
 
 void USB::OnDeviceManagerConnectionError() {
   device_manager_.reset();
   client_binding_.Close();
   for (ScriptPromiseResolver* resolver : device_manager_requests_)
-    resolver->Reject(DOMException::Create(kNotFoundError, kNoServiceError));
+    resolver->Resolve(HeapVector<Member<USBDevice>>(0));
   device_manager_requests_.Clear();
 }
 
 void USB::OnChooserServiceConnectionError() {
   chooser_service_.reset();
   for (ScriptPromiseResolver* resolver : chooser_service_requests_)
-    resolver->Reject(DOMException::Create(kNotFoundError, kNoServiceError));
+    resolver->Reject(DOMException::Create(kNotFoundError, kNoDeviceSelected));
   chooser_service_requests_.Clear();
 }
 
 void USB::AddedEventListener(const AtomicString& event_type,
                              RegisteredEventListener& listener) {
   EventTargetWithInlineData::AddedEventListener(event_type, listener);
   if (event_type == EventTypeNames::connect ||
       event_type == EventTypeNames::disconnect) {
     EnsureDeviceManagerConnection();
   }
@@ skipping 14 matching lines @@
 
 DEFINE_TRACE(USB) {
   visitor->Trace(device_manager_requests_);
   visitor->Trace(chooser_service_requests_);
   visitor->Trace(device_cache_);
   EventTargetWithInlineData::Trace(visitor);
   ContextLifecycleObserver::Trace(visitor);
 }
 
 }  // namespace blink