Integrate WebUSB with Feature Policy

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 10 matching lines @@
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 
 using device::mojom::blink::UsbDeviceFilterPtr;
 using device::mojom::blink::UsbDeviceInfoPtr;
 using device::mojom::blink::UsbDevicePtr;
 
 namespace blink {
 namespace {
 
+const char kFeaturePolicyBlocked[] =
+    "Access to the feature \"usb\" is disallowed by feature policy.";
+const char kIframeBlocked[] =
+    "Access to this method is not allowed in embedded frames.";
 const char kNoDeviceSelected[] = "No device selected.";
 
 UsbDeviceFilterPtr ConvertDeviceFilter(const USBDeviceFilter& filter) {
   auto mojo_filter = device::mojom::blink::UsbDeviceFilter::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();
@@ skipping 24 matching lines @@
   DCHECK(chooser_service_requests_.IsEmpty());
 }
 
 void USB::Dispose() {
   // The pipe to this object must be closed when is marked unreachable to
   // prevent messages from being dispatched before lazy sweeping.
   client_binding_.Close();
 }
 
 ScriptPromise USB::getDevices(ScriptState* script_state) {
+  LocalFrame* frame = GetFrame();
+  if (!frame) {
+    return ScriptPromise::RejectWithDOMException(
+        script_state, DOMException::Create(kNotSupportedError));
+  }
+
+  if (RuntimeEnabledFeatures::featurePolicyEnabled()) {
+    if (!frame->IsFeatureEnabled(WebFeaturePolicyFeature::kUsb)) {
+      return ScriptPromise::RejectWithDOMException(
+          script_state,
+          DOMException::Create(kSecurityError, kFeaturePolicyBlocked));
+    }
+  } else if (!frame->IsMainFrame()) {
+    return ScriptPromise::RejectWithDOMException(
+        script_state, DOMException::Create(kSecurityError, kIframeBlocked));
+  }
+
+  EnsureDeviceManagerConnection();
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
-  ScriptPromise promise = resolver->Promise();
-  EnsureDeviceManagerConnection();
-  if (!device_manager_) {
-    resolver->Reject(DOMException::Create(kNotSupportedError));
-  } else {
-    device_manager_requests_.insert(resolver);
-    device_manager_->GetDevices(
-        nullptr, ConvertToBaseCallback(WTF::Bind(&USB::OnGetDevices,
-                                                 WrapPersistent(this),
-                                                 WrapPersistent(resolver))));
-  }
-  return promise;
+  device_manager_requests_.insert(resolver);
+  device_manager_->GetDevices(
+      nullptr,
+      ConvertToBaseCallback(WTF::Bind(&USB::OnGetDevices, WrapPersistent(this),
+                                      WrapPersistent(resolver))));
+  return resolver->Promise();
 }
 
 ScriptPromise USB::requestDevice(ScriptState* script_state,
                                  const USBDeviceRequestOptions& options) {
-  ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
-  ScriptPromise promise = resolver->Promise();
+  LocalFrame* frame = GetFrame();
+  if (!frame) {
+    return ScriptPromise::RejectWithDOMException(
+        script_state, DOMException::Create(kNotSupportedError));
+  }
+
+  if (RuntimeEnabledFeatures::featurePolicyEnabled()) {
+    if (!frame->IsFeatureEnabled(WebFeaturePolicyFeature::kUsb)) {
+      return ScriptPromise::RejectWithDOMException(
+          script_state,
+          DOMException::Create(kSecurityError, kFeaturePolicyBlocked));
+    }
+  } else if (!frame->IsMainFrame()) {
+    return ScriptPromise::RejectWithDOMException(
+        script_state, DOMException::Create(kSecurityError, kIframeBlocked));
+  }
 
   if (!chooser_service_) {
-    if (!GetFrame()) {
-      resolver->Reject(DOMException::Create(kNotSupportedError));
-      return promise;
-    }
     GetFrame()->GetInterfaceProvider()->GetInterface(
         mojo::MakeRequest(&chooser_service_));
     chooser_service_.set_connection_error_handler(
         ConvertToBaseCallback(WTF::Bind(&USB::OnChooserServiceConnectionError,
                                         WrapWeakPersistent(this))));
   }
 
   if (!UserGestureIndicator::ConsumeUserGesture()) {
-    resolver->Reject(DOMException::Create(
-        kSecurityError,
-        "Must be handling a user gesture to show a permission request."));
-  } else {
-    Vector<UsbDeviceFilterPtr> filters;
-    if (options.hasFilters()) {
-      filters.ReserveCapacity(options.filters().size());
-      for (const auto& filter : options.filters())
-        filters.push_back(ConvertDeviceFilter(filter));
-    }
-    chooser_service_requests_.insert(resolver);
-    chooser_service_->GetPermission(
-        std::move(filters), ConvertToBaseCallback(WTF::Bind(
-                                &USB::OnGetPermission, WrapPersistent(this),
-                                WrapPersistent(resolver))));
+    return ScriptPromise::RejectWithDOMException(
+        script_state,
+        DOMException::Create(
+            kSecurityError,
+            "Must be handling a user gesture to show a permission request."));
   }
-  return promise;
+
+  Vector<UsbDeviceFilterPtr> filters;
+  if (options.hasFilters()) {
+    filters.ReserveCapacity(options.filters().size());
+    for (const auto& filter : options.filters())
+      filters.push_back(ConvertDeviceFilter(filter));
+  }
+
+  ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
+  chooser_service_requests_.insert(resolver);
+  chooser_service_->GetPermission(
+      std::move(filters), ConvertToBaseCallback(WTF::Bind(
+                              &USB::OnGetPermission, WrapPersistent(this),
+                              WrapPersistent(resolver))));
+  return resolver->Promise();
 }
 
 ExecutionContext* USB::GetExecutionContext() const {
   return ContextLifecycleObserver::GetExecutionContext();
 }
 
 const AtomicString& USB::InterfaceName() const {
   return EventTargetNames::USB;
 }
 
@@ skipping 33 matching lines @@
 
 void USB::OnGetPermission(ScriptPromiseResolver* resolver,
                           UsbDeviceInfoPtr 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_ && device_info) {
+  if (device_manager_ && device_info)
     resolver->Resolve(GetOrCreateDevice(std::move(device_info)));
-  } else {
+  else
     resolver->Reject(DOMException::Create(kNotFoundError, kNoDeviceSelected));
-  }
 }
 
 void USB::OnDeviceAdded(UsbDeviceInfoPtr device_info) {
   if (!device_manager_)
     return;
 
   DispatchEvent(USBConnectionEvent::Create(
       EventTypeNames::connect, GetOrCreateDevice(std::move(device_info))));
 }
 
@@ skipping 19 matching lines @@
 void USB::OnChooserServiceConnectionError() {
   chooser_service_.reset();
   for (ScriptPromiseResolver* resolver : chooser_service_requests_)
     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) {
+  if (event_type != EventTypeNames::connect &&
+      event_type != EventTypeNames::disconnect) {
+    return;
+  }
+
+  LocalFrame* frame = GetFrame();
+  if (!frame)
+    return;
+
+  if (RuntimeEnabledFeatures::featurePolicyEnabled()) {
+    if (frame->IsFeatureEnabled(WebFeaturePolicyFeature::kUsb))
+      EnsureDeviceManagerConnection();
+  } else if (frame->IsMainFrame()) {
     EnsureDeviceManagerConnection();
   }
 }
 
 void USB::EnsureDeviceManagerConnection() {
-  if (device_manager_ || !GetFrame())
+  if (device_manager_)
     return;
 
+  DCHECK(GetFrame());
   GetFrame()->GetInterfaceProvider()->GetInterface(
       mojo::MakeRequest(&device_manager_));
   device_manager_.set_connection_error_handler(ConvertToBaseCallback(WTF::Bind(
       &USB::OnDeviceManagerConnectionError, WrapWeakPersistent(this))));
 
   DCHECK(!client_binding_.is_bound());
   device_manager_->SetClient(client_binding_.CreateInterfacePtrAndBind());
 }
 
 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