Replace deprecated calls to GetMetadata in Physical Web omnibox provider

components/omnibox/browser/physical_web_provider_unittest.cc

 // Copyright 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 <memory>
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/values.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/omnibox/browser/mock_autocomplete_provider_client.h"
 #include "components/omnibox/browser/omnibox_field_trial.h"
 #include "components/omnibox/browser/test_scheme_classifier.h"
 #include "components/physical_web/data_source/fake_physical_web_data_source.h"
 #include "components/physical_web/data_source/physical_web_data_source.h"
 #include "components/physical_web/data_source/physical_web_listener.h"
 #include "components/variations/entropy_provider.h"
 #include "components/variations/variations_associated_data.h"
 #include "grit/components_strings.h"
@@ skipping 82 matching lines @@
     params[OmniboxFieldTrial::kPhysicalWebZeroSuggestRule] = "true";
     params[OmniboxFieldTrial::kPhysicalWebAfterTypingRule] = "true";
     variations::AssociateVariationParams(
         OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A", params);
     return base::FieldTrialList::CreateFieldTrial(
         OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A");
   }
 
   // Create a dummy metadata list with |metadata_count| items. Each item is
   // populated with a unique scanned URL and page metadata.
-  static std::unique_ptr<base::ListValue> CreateMetadata(
+  static std::unique_ptr<physical_web::MetadataList> CreateMetadata(
       size_t metadata_count) {
-    auto metadata_list = base::MakeUnique<base::ListValue>();
+    auto metadata_list = base::MakeUnique<physical_web::MetadataList>();
     for (size_t i = 0; i < metadata_count; ++i) {
       std::string item_id = base::SizeTToString(i);
       std::string url = "https://example.com/" + item_id;
-      auto metadata_item = base::MakeUnique<base::DictionaryValue>();
-      metadata_item->SetString(physical_web::kScannedUrlKey, url);
-      metadata_item->SetString(physical_web::kResolvedUrlKey, url);
-      metadata_item->SetString(physical_web::kIconUrlKey, url);
-      metadata_item->SetString(physical_web::kTitleKey,
-                               "Example title " + item_id);
-      metadata_item->SetString(physical_web::kDescriptionKey,
-                               "Example description " + item_id);
-      metadata_list->Append(std::move(metadata_item));
+      metadata_list->emplace_back();
+      auto& metadata_item = metadata_list->back();
+      metadata_item.scanned_url = GURL(url);
+      metadata_item.resolved_url = GURL(url);
+      metadata_item.icon_url = GURL(url);
+      metadata_item.title = "Example title " + item_id;
+      metadata_item.description = "Example description " + item_id;
     }
     return metadata_list;
   }
 
   // Construct an AutocompleteInput to represent tapping the omnibox from the
   // new tab page.
   static AutocompleteInput CreateInputForNTP() {
     return AutocompleteInput(
         base::string16(), base::string16::npos, std::string(), GURL(),
         metrics::OmniboxEventProto::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS,
@@ skipping 51 matching lines @@
   }
 
   // Run a test case using |input| as the simulated state of the omnibox input
   // field, |metadata_list| as the list of simulated Physical Web metadata,
   // and |title_truncated| as the truncated title of the first match. In
   // addition to checking the fields of the overflow item, this will also check
   // that the total number of matches is equal to |expected_match_count| and
   // that a default match and overflow item are only present when
   // |should_expect_default_match| or |should_expect_overflow_item| are true.
   // Metadata matches are not checked.
-  void OverflowItemTestCase(const AutocompleteInput& input,
-                            std::unique_ptr<base::ListValue> metadata_list,
-                            const std::string& title_truncated,
-                            size_t expected_match_count,
-                            bool should_expect_default_match,
-                            bool should_expect_overflow_item) {
-    const size_t metadata_count = metadata_list->GetSize();
+  void OverflowItemTestCase(
+      const AutocompleteInput& input,
+      std::unique_ptr<physical_web::MetadataList> metadata_list,
+      const std::string& title_truncated,
+      size_t expected_match_count,
+      bool should_expect_default_match,
+      bool should_expect_overflow_item) {
+    const size_t metadata_count = metadata_list->size();
 
     FakePhysicalWebDataSource* data_source =
         client_->GetFakePhysicalWebDataSource();
     EXPECT_TRUE(data_source);
 
-    data_source->SetMetadata(std::move(metadata_list));
+    data_source->SetMetadataList(std::move(metadata_list));
 
     provider_->Start(input, false);
 
     const size_t match_count = provider_->matches().size();
     EXPECT_EQ(expected_match_count, match_count);
 
     const size_t match_count_without_default =
         should_expect_default_match ? match_count - 1 : match_count;
 
     if (should_expect_overflow_item) {
@@ skipping 27 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PhysicalWebProviderTest);
 };
 
 TEST_F(PhysicalWebProviderTest, TestEmptyMetadataListCreatesNoMatches) {
   FakePhysicalWebDataSource* data_source =
       client_->GetFakePhysicalWebDataSource();
   EXPECT_TRUE(data_source);
 
-  data_source->SetMetadata(CreateMetadata(0));
+  data_source->SetMetadataList(CreateMetadata(0));
 
   // Run the test with no text in the omnibox input to simulate NTP.
   provider_->Start(CreateInputForNTP(), false);
   EXPECT_TRUE(provider_->matches().empty());
 
   // Run the test again with a URL in the omnibox input.
   provider_->Start(CreateInputWithCurrentUrl("http://www.cnn.com"), false);
   EXPECT_TRUE(provider_->matches().empty());
 }
 
 TEST_F(PhysicalWebProviderTest, TestSingleMetadataItemCreatesOneMatch) {
   FakePhysicalWebDataSource* data_source =
       client_->GetFakePhysicalWebDataSource();
   EXPECT_TRUE(data_source);
 
   // Extract the URL and title before inserting the metadata into the data
   // source.
-  std::unique_ptr<base::ListValue> metadata_list = CreateMetadata(1);
-  base::DictionaryValue* metadata_item;
-  EXPECT_TRUE(metadata_list->GetDictionary(0, &metadata_item));
-  std::string resolved_url;
-  EXPECT_TRUE(
-      metadata_item->GetString(physical_web::kResolvedUrlKey, &resolved_url));
-  std::string title;
-  EXPECT_TRUE(metadata_item->GetString(physical_web::kTitleKey, &title));
+  auto metadata_list = CreateMetadata(1);
+  const auto& metadata_item = metadata_list->front();
+  std::string resolved_url = metadata_item.resolved_url.spec();
+  std::string title = metadata_item.title;
 
-  data_source->SetMetadata(std::move(metadata_list));
+  data_source->SetMetadataList(std::move(metadata_list));
 
   // Run the test with no text in the omnibox input to simulate NTP.
   provider_->Start(CreateInputForNTP(), false);
 
   // Check that there is only one match item and its fields are correct.
   EXPECT_EQ(1U, provider_->matches().size());
   const AutocompleteMatch& metadata_match = provider_->matches().front();
   EXPECT_EQ(AutocompleteMatchType::PHYSICAL_WEB, metadata_match.type);
   ValidateMatch(metadata_match, resolved_url, resolved_url, title, false);
 
@@ skipping 15 matching lines @@
   EXPECT_EQ(2U, provider_->matches().size());
   EXPECT_EQ(1U, metadata_match_count);
   EXPECT_EQ(1U, default_match_count);
 }
 
 TEST_F(PhysicalWebProviderTest, TestNoMatchesWithUserInput) {
   FakePhysicalWebDataSource* data_source =
       client_->GetFakePhysicalWebDataSource();
   EXPECT_TRUE(data_source);
 
-  data_source->SetMetadata(CreateMetadata(1));
+  data_source->SetMetadataList(CreateMetadata(1));
 
   // Construct an AutocompleteInput to simulate user input in the omnibox input
   // field. The provider should not generate any matches.
   std::string text("user input");
   const AutocompleteInput input(
       base::UTF8ToUTF16(text), text.length(), std::string(), GURL(),
       metrics::OmniboxEventProto::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS,
       true, false, true, true, false, TestSchemeClassifier());
   provider_->Start(input, false);
 
@@ skipping 14 matching lines @@
   OverflowItemTestCase(CreateInputWithCurrentUrl("http://www.cnn.com"),
                        CreateMetadata(metadata_count), "Example title 0",
                        PhysicalWebProvider::kPhysicalWebMaxMatches + 1, true,
                        true);
 }
 
 TEST_F(PhysicalWebProviderTest, TestLongPageTitleIsTruncatedInOverflowItem) {
   // Set a long title for the first item. The page title for this item will
   // appear in the overflow item's content string.
   auto metadata_list = CreateMetadata(AutocompleteProvider::kMaxMatches + 1);
-  base::DictionaryValue* metadata_item;
-  EXPECT_TRUE(metadata_list->GetDictionary(0, &metadata_item));
-  metadata_item->SetString(physical_web::kTitleKey,
-                           "Extra long example title 0");
+  auto& metadata_item = metadata_list->front();
+  metadata_item.title = "Extra long example title 0";
 
   OverflowItemTestCase(CreateInputForNTP(), std::move(metadata_list),
                        "Extra long exa" + std::string(gfx::kEllipsis),
                        PhysicalWebProvider::kPhysicalWebMaxMatches, false,
                        true);
 }
 
 TEST_F(PhysicalWebProviderTest, TestEmptyPageTitleInOverflowItem) {
   // Set an empty title for the first item. Because the title is empty, we will
   // display an alternate string in the overflow item's contents.
   auto metadata_list = CreateMetadata(AutocompleteProvider::kMaxMatches + 1);
-  base::DictionaryValue* metadata_item;
-  EXPECT_TRUE(metadata_list->GetDictionary(0, &metadata_item));
-  metadata_item->SetString(physical_web::kTitleKey, "");
+  auto& metadata_item = metadata_list->front();
+  metadata_item.title = "";
 
   OverflowItemTestCase(CreateInputForNTP(), std::move(metadata_list), "",
                        PhysicalWebProvider::kPhysicalWebMaxMatches, false,
                        true);
 }
 
 TEST_F(PhysicalWebProviderTest, TestRTLPageTitleInOverflowItem) {
   // Set a Hebrew title for the first item.
   auto metadata_list = CreateMetadata(AutocompleteProvider::kMaxMatches + 1);
-  base::DictionaryValue* metadata_item;
-  EXPECT_TRUE(metadata_list->GetDictionary(0, &metadata_item));
-  metadata_item->SetString(physical_web::kTitleKey, "ויקיפדיה");
+  auto& metadata_item = metadata_list->front();
+  metadata_item.title = "ויקיפדיה";
 
   OverflowItemTestCase(CreateInputForNTP(), std::move(metadata_list),
                        "ויקיפדיה", PhysicalWebProvider::kPhysicalWebMaxMatches,
                        false, true);
 }
 
 TEST_F(PhysicalWebProviderTest, TestNoMatchesInIncognito) {
   // Enable incognito mode
   client_->SetOffTheRecord(true);
 
   FakePhysicalWebDataSource* data_source =
       client_->GetFakePhysicalWebDataSource();
   EXPECT_TRUE(data_source);
 
-  data_source->SetMetadata(CreateMetadata(1));
+  data_source->SetMetadataList(CreateMetadata(1));
   provider_->Start(CreateInputForNTP(), false);
 
   EXPECT_TRUE(provider_->matches().empty());
 }