Add a Physical Web data source

ios/chrome/common/physical_web/physical_web_scanner.mm

 // 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.
 
 #import "ios/chrome/common/physical_web/physical_web_scanner.h"
 
+#import <CoreBluetooth/CoreBluetooth.h>
+
 #include <string>
 #include <vector>
 
-#import <CoreBluetooth/CoreBluetooth.h>
-
-#include "base/ios/weak_nsobject.h"
+#import "base/ios/weak_nsobject.h"
 #include "base/logging.h"
-#include "base/mac/scoped_nsobject.h"
-#include "base/macros.h"
+#import "base/mac/scoped_nsobject.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/sys_string_conversions.h"
+#include "base/values.h"
 #include "device/bluetooth/uribeacon/uri_encoder.h"
-#include "ios/chrome/common/physical_web/physical_web_device.h"
+#import "ios/chrome/common/physical_web/physical_web_device.h"
 #import "ios/chrome/common/physical_web/physical_web_request.h"
-#include "ios/chrome/common/physical_web/physical_web_types.h"
+#import "ios/chrome/common/physical_web/physical_web_types.h"
 
 namespace {
 
 NSString* const kUriBeaconServiceUUID = @"FED8";
 NSString* const kEddystoneBeaconServiceUUID = @"FEAA";
 
 enum BeaconType {
   BEACON_TYPE_NONE,
   BEACON_TYPE_URIBEACON,
   BEACON_TYPE_EDDYSTONE,
@@ skipping 111 matching lines @@
     if ([device1 rank] > [device2 rank]) {
       return NSOrderedDescending;
     }
     if ([device1 rank] < [device2 rank]) {
       return NSOrderedAscending;
     }
     return NSOrderedSame;
   }];
 }
 
+- (std::unique_ptr<base::ListValue>)metadata {
+  auto metadataList = base::MakeUnique<base::ListValue>();
+
+  for (PhysicalWebDevice* device in [self devices]) {
+    std::string scannedUrl =
+        base::SysNSStringToUTF8([[device requestURL] absoluteString]);
+    std::string resolvedUrl =
+        base::SysNSStringToUTF8([[device url] absoluteString]);
+    std::string icon = base::SysNSStringToUTF8([[device icon] absoluteString]);
+    std::string title = base::SysNSStringToUTF8([device title]);
+    std::string description = base::SysNSStringToUTF8([device description]);
+
+    auto metadataItem = base::MakeUnique<base::DictionaryValue>();
+    metadataItem->SetString("scannedUrl", scannedUrl);
+    metadataItem->SetString("resolvedUrl", resolvedUrl);
+    metadataItem->SetString("icon", icon);
+    metadataItem->SetString("title", title);
+    metadataItem->SetString("description", description);
+    metadataList->Append(std::move(metadataItem));
+  }
+
+  return metadataList;
+}
+
 - (void)setNetworkRequestEnabled:(BOOL)enabled {
   if (networkRequestEnabled_ == enabled) {
     return;
   }
   networkRequestEnabled_ = enabled;
   if (!networkRequestEnabled_)
     return;
 
   // Sends the pending requests.
   for (PhysicalWebDevice* device in unresolvedDevices_.get()) {
@@ skipping 125 matching lines @@
   // TX Power in the UriBeacon advertising packet is the received power at 0
   // meters. The Transmit Power Level represents the transmit power level in
   // dBm, and the value ranges from -100 dBm to +20 dBm to a resolution of 1
   // dBm.
   int transmitPower = static_cast<char>(bytes[1]);
   // - scheme and URL are at offset 2.
   std::vector<uint8_t> encodedURI(&bytes[2], &bytes[[data length]]);
   std::string utf8URI;
   device::DecodeUriBeaconUri(encodedURI, utf8URI);
   NSString* uriString = base::SysUTF8ToNSString(utf8URI);
-  return [[PhysicalWebDevice alloc] initWithURL:[NSURL URLWithString:uriString]
+  NSURL* url = [NSURL URLWithString:uriString];
+
+  // Ensure URL is valid.
+  if (!url)
+    return nil;
+
+  return [[PhysicalWebDevice alloc] initWithURL:url
                                      requestURL:nil
                                            icon:nil
                                           title:nil
                                     description:nil
                                   transmitPower:transmitPower
                                            rssi:rssi
                                            rank:physical_web::kMaxRank];
 }
 
 - (void)requestMetadataForDevice:(PhysicalWebDevice*)device {
@@ skipping 13 matching lines @@
         [strongSelf.get()->devices_ addObject:device];
         [strongSelf.get()->delegate_ scannerUpdatedDevices:weakSelf];
         [strongSelf.get()->finalUrls_ addObject:[device url]];
       }
     }
     [strongSelf.get()->pendingRequests_ removeObject:strongRequest];
   }];
 }
 
 @end