Replace deprecated calls to GetMetadata in Physical Web omnibox provider

components/omnibox/browser/physical_web_provider.cc

 // Copyright (c) 2016 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 "components/omnibox/browser/physical_web_provider.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/values.h"
 #include "components/bookmarks/browser/titled_url_index.h"
 #include "components/bookmarks/browser/titled_url_node_sorter.h"
 #include "components/omnibox/browser/autocomplete_provider_client.h"
 #include "components/omnibox/browser/autocomplete_provider_listener.h"
 #include "components/omnibox/browser/history_url_provider.h"
 #include "components/omnibox/browser/omnibox_field_trial.h"
 #include "components/omnibox/browser/physical_web_node.h"
 #include "components/omnibox/browser/titled_url_match_utils.h"
 #include "components/omnibox/browser/url_prefix.h"
 #include "components/omnibox/browser/verbatim_match.h"
@@ skipping 48 matching lines @@
 
   physical_web::PhysicalWebDataSource* data_source =
       client_->GetPhysicalWebDataSource();
   if (!data_source) {
     done_ = true;
     nearby_url_count_ = 0;
     return;
   }
 
   if (input.from_omnibox_focus()) {
-    ConstructZeroSuggestMatches(data_source->GetMetadata());
+    ConstructZeroSuggestMatches(data_source->GetMetadataList());
 
     if (!matches_.empty()) {
       had_physical_web_suggestions_ = true;
       had_physical_web_suggestions_at_focus_or_later_ = true;
     }
 
     if (!zero_suggest_enabled_) {
       matches_.clear();
     }
 
     // In zero-suggest, Physical Web matches should never be default. If the
     // omnibox input is non-empty and we have at least one Physical Web match,
     // add the current URL as the default so that hitting enter after focusing
     // the omnibox causes the current page to reload. If the input field is
     // empty, no default match is required.
     if (!matches_.empty() && !input.text().empty()) {
       matches_.push_back(VerbatimMatchForURL(
           client_, input, input.current_url(), history_url_provider_, -1));
     }
   } else {
-    ConstructQuerySuggestMatches(data_source->GetMetadata(), input);
+    ConstructQuerySuggestMatches(data_source->GetMetadataList(), input);
 
     if (!matches_.empty()) {
       had_physical_web_suggestions_ = true;
       had_physical_web_suggestions_at_focus_or_later_ = true;
     }
 
     if (!after_typing_enabled_) {
       matches_.clear();
     }
   }
@@ skipping 43 matching lines @@
           OmniboxFieldTrial::InPhysicalWebAfterTypingFieldTrial()),
       zero_suggest_base_relevance_(
           OmniboxFieldTrial::GetPhysicalWebZeroSuggestBaseRelevance()),
       after_typing_base_relevance_(
           OmniboxFieldTrial::GetPhysicalWebAfterTypingBaseRelevance()) {}
 
 PhysicalWebProvider::~PhysicalWebProvider() {
 }
 
 void PhysicalWebProvider::ConstructZeroSuggestMatches(
-    std::unique_ptr<base::ListValue> metadata_list) {
-  nearby_url_count_ = metadata_list->GetSize();
+    std::unique_ptr<physical_web::MetadataList> metadata_list) {
+  nearby_url_count_ = metadata_list->size();
   size_t used_slots = 0;
 
   for (size_t i = 0; i < nearby_url_count_; ++i) {
-    base::DictionaryValue* metadata_item = NULL;
-    if (!metadata_list->GetDictionary(i, &metadata_item)) {
-      continue;
-    }
-
-    std::string url_string;
-    std::string title_string;
-    if (!metadata_item->GetString(physical_web::kResolvedUrlKey, &url_string) ||
-        !metadata_item->GetString(physical_web::kTitleKey, &title_string)) {
-      continue;
-    }
+    const auto& metadata_item = (*metadata_list)[i];
+    std::string url_string = metadata_item.resolved_url.spec();
+    std::string title_string = metadata_item.title;
     base::string16 title =
         AutocompleteMatch::SanitizeString(base::UTF8ToUTF16(title_string));
 
     // Add match items with decreasing relevance to preserve the ordering in
     // the metadata list.
     int relevance = zero_suggest_base_relevance_ - used_slots;
 
     // Append an overflow item if creating a match for each metadata item would
     // exceed the match limit.
     const size_t remaining_slots = kPhysicalWebMaxMatches - used_slots;
@@ skipping 27 matching lines @@
 
     matches_.push_back(match);
     ++used_slots;
   }
 
   UMA_HISTOGRAM_EXACT_LINEAR(
       "Omnibox.PhysicalWebProviderMatches", matches_.size(), kMaxMatches);
 }
 
 void PhysicalWebProvider::ConstructQuerySuggestMatches(
-    std::unique_ptr<base::ListValue> metadata_list,
+    std::unique_ptr<physical_web::MetadataList> metadata_list,
     const AutocompleteInput& input) {
   // Passing nullptr for the TitledUrlNodeSorter will cause the returned match
   // list to be unsorted.
   bookmarks::TitledUrlIndex index(nullptr);
   std::vector<std::unique_ptr<PhysicalWebNode>> nodes;
-  const size_t metadata_count = metadata_list->GetSize();
-  for (size_t i = 0; i < metadata_count; ++i) {
-    base::DictionaryValue* metadata_item = NULL;
-    if (metadata_list->GetDictionary(i, &metadata_item)) {
-      nodes.push_back(base::MakeUnique<PhysicalWebNode>(*metadata_item));
-      index.Add(nodes.back().get());
-    }
+  for (const auto& metadata_item : *metadata_list) {
+    nodes.push_back(base::MakeUnique<PhysicalWebNode>(metadata_item));
+    index.Add(nodes.back().get());
   }
 
   std::vector<bookmarks::TitledUrlMatch> titled_url_matches;
   index.GetResultsMatching(input.text(), kPhysicalWebIndexMaxMatches,
                            query_parser::MatchingAlgorithm::DEFAULT,
                            &titled_url_matches);
 
   size_t used_slots = 0;
   const base::string16 fixed_up_input(FixupUserInput(input).second);
   for (auto titled_url_match : titled_url_matches) {
@@ skipping 35 matching lines @@
       AutocompleteInput::FormattedStringWithEquivalentMeaning(
           url, match.contents, client_->GetSchemeClassifier());
 
   match.description =
       l10n_util::GetStringUTF16(IDS_PHYSICAL_WEB_OVERFLOW_DESCRIPTION);
   match.description_class.push_back(
       ACMatchClassification(0, ACMatchClassification::NONE));
 
   matches_.push_back(match);
 }