Read WebUSB landing page even if allowed origin read fails

device/usb/webusb_descriptors.cc

 // 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 "device/usb/webusb_descriptors.h"
 
 #include <stddef.h>
 
 #include <iterator>
 #include <map>
@@ skipping 139 matching lines @@
     configuration->functions.push_back(function);
   }
 
   return true;
 }
 
 void OnDoneReadingUrls(std::unique_ptr<WebUsbAllowedOrigins> allowed_origins,
                        uint8_t landing_page_id,
                        std::unique_ptr<std::map<uint8_t, GURL>> url_map,
                        const ReadWebUsbDescriptorsCallback& callback) {
-  for (uint8_t origin_id : allowed_origins->origin_ids) {
-    const auto& it = url_map->find(origin_id);
-    if (it != url_map->end())
-      allowed_origins->origins.push_back(it->second.GetOrigin());
-  }
-
-  for (auto& configuration : allowed_origins->configurations) {
-    for (uint8_t origin_id : configuration.origin_ids) {
+  if (allowed_origins) {
+    for (uint8_t origin_id : allowed_origins->origin_ids) {
       const auto& it = url_map->find(origin_id);
       if (it != url_map->end())
-        configuration.origins.push_back(it->second.GetOrigin());
+        allowed_origins->origins.push_back(it->second.GetOrigin());
     }
 
-    for (auto& function : configuration.functions) {
-      for (uint8_t origin_id : function.origin_ids) {
+    for (auto& configuration : allowed_origins->configurations) {
+      for (uint8_t origin_id : configuration.origin_ids) {
         const auto& it = url_map->find(origin_id);
         if (it != url_map->end())
-          function.origins.push_back(it->second.GetOrigin());
+          configuration.origins.push_back(it->second.GetOrigin());
+      }
+
+      for (auto& function : configuration.functions) {
+        for (uint8_t origin_id : function.origin_ids) {
+          const auto& it = url_map->find(origin_id);
+          if (it != url_map->end())
+            function.origins.push_back(it->second.GetOrigin());
+        }
       }
     }
   }
 
   GURL landing_page;
   if (landing_page_id != 0)
     landing_page = (*url_map)[landing_page_id];
 
   callback.Run(std::move(allowed_origins), landing_page);
 }
@@ skipping 28 matching lines @@
                        const base::Closure& callback) {
   scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(255);
   device_handle->ControlTransfer(
       UsbTransferDirection::INBOUND, UsbControlTransferType::VENDOR,
       UsbControlTransferRecipient::DEVICE, vendor_code, index, kGetUrlRequest,
       buffer, buffer->size(), kControlTransferTimeoutMs,
       base::Bind(&OnReadUrlDescriptor, url_map, index, callback));
 }
 
 // Reads URL descriptors from the device so that it can fill |allowed_origins|
-// with the GURLs matching the indicies already collected.
+// with the GURLs matching the indices already collected.
 void ReadUrlDescriptors(scoped_refptr<UsbDeviceHandle> device_handle,
                         uint8_t vendor_code,
                         uint8_t landing_page_id,
                         const ReadWebUsbDescriptorsCallback& callback,
                         std::unique_ptr<WebUsbAllowedOrigins> allowed_origins) {
-  if (!allowed_origins) {
-    callback.Run(nullptr, GURL());
-    return;
-  }
-
   std::set<uint8_t> to_request;
   if (landing_page_id != 0)
     to_request.insert(landing_page_id);
 
-  to_request.insert(allowed_origins->origin_ids.begin(),
-                    allowed_origins->origin_ids.end());
-  for (auto& config : allowed_origins->configurations) {
-    to_request.insert(config.origin_ids.begin(), config.origin_ids.end());
-    for (auto& function : config.functions) {
-      to_request.insert(function.origin_ids.begin(), function.origin_ids.end());
+  if (allowed_origins) {
+    to_request.insert(allowed_origins->origin_ids.begin(),
+                      allowed_origins->origin_ids.end());
+    for (auto& config : allowed_origins->configurations) {
+      to_request.insert(config.origin_ids.begin(), config.origin_ids.end());
+      for (auto& function : config.functions) {
+        to_request.insert(function.origin_ids.begin(),
+                          function.origin_ids.end());
+      }
     }
   }
 
   std::unique_ptr<std::map<uint8_t, GURL>> url_map(
       new std::map<uint8_t, GURL>());
   std::map<uint8_t, GURL>* url_map_ptr = url_map.get();
   base::Closure barrier = base::BarrierClosure(
       static_cast<int>(to_request.size()),
       base::Bind(&OnDoneReadingUrls, base::Passed(&allowed_origins),
                  landing_page_id, base::Passed(&url_map), callback));
 
-  for (uint8_t index : to_request) {
+  for (uint8_t index : to_request)
     ReadUrlDescriptor(device_handle, vendor_code, url_map_ptr, index, barrier);
-  }
 }
 
 void OnReadWebUsbAllowedOrigins(
     const ReadWebUsbAllowedOriginsCallback& callback,
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length) {
   if (status != UsbTransferStatus::COMPLETED) {
     USB_LOG(EVENT) << "Failed to read WebUSB allowed origins.";
     callback.Run(nullptr);
@@ skipping 331 matching lines @@
 
       if (base::ContainsValue(function.origins, origin))
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace device