[PhysicalWeb] Add physical_web namespace.

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/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/test_scheme_classifier.h"
 #include "components/physical_web/data_source/physical_web_data_source.h"
 #include "components/physical_web/data_source/physical_web_listener.h"
 #include "grit/components_strings.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/text_elider.h"
 #include "url/gurl.h"
 
+using physical_web::PhysicalWebDataSource;
+using physical_web::PhysicalWebListener;
+
 namespace {
 
 // A mock implementation of the Physical Web data source that allows setting
 // metadata for nearby URLs directly.
 class MockPhysicalWebDataSource : public PhysicalWebDataSource {

[vitaliii, 2016/11/25 11:57:02]

I am going to move this to components/physical_web/data_source in the following
CL.
Context: New Tab Page is a new client of Physical Web and we wrote exactly the
same class and were suggested to move it to 
components/physical_web/data_source.

  public:
   MockPhysicalWebDataSource() : metadata_(new base::ListValue()) {}
   ~MockPhysicalWebDataSource() override {}
 
   void StartDiscovery(bool network_request_enabled) override {}
   void StopDiscovery() override {}
 
   std::unique_ptr<base::ListValue> GetMetadata() override {
     return metadata_->CreateDeepCopy();
   }
@@ skipping 74 matching lines @@
 
   // 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(
       size_t metadata_count) {
     auto metadata_list = base::MakeUnique<base::ListValue>();
     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(kPhysicalWebScannedUrlKey, url);
-      metadata_item->SetString(kPhysicalWebResolvedUrlKey, url);
-      metadata_item->SetString(kPhysicalWebIconUrlKey, url);
-      metadata_item->SetString(kPhysicalWebTitleKey,
+      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(kPhysicalWebDescriptionKey,
+      metadata_item->SetString(physical_web::kDescriptionKey,
                                "Example description " + item_id);
       metadata_list->Append(std::move(metadata_item));
     }
     return metadata_list;
   }
 
   // Construct an AutocompleteInput to represent tapping the omnibox from the
   // new tab page.
   static AutocompleteInput CreateInputForNTP() {
     return AutocompleteInput(
@@ skipping 134 matching lines @@
   MockPhysicalWebDataSource* data_source =
       client_->GetMockPhysicalWebDataSource();
   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(kPhysicalWebResolvedUrlKey,
-                                       &resolved_url));
+  EXPECT_TRUE(
+      metadata_item->GetString(physical_web::kResolvedUrlKey, &resolved_url));
   std::string title;
-  EXPECT_TRUE(metadata_item->GetString(kPhysicalWebTitleKey, &title));
+  EXPECT_TRUE(metadata_item->GetString(physical_web::kTitleKey, &title));
 
   data_source->SetMetadata(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);
@@ skipping 54 matching lines @@
                        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(kPhysicalWebTitleKey, "Extra long example title 0");
+  metadata_item->SetString(physical_web::kTitleKey,
+                           "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(kPhysicalWebTitleKey, "");
+  metadata_item->SetString(physical_web::kTitleKey, "");
 
   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(kPhysicalWebTitleKey, "ויקיפדיה");
+  metadata_item->SetString(physical_web::kTitleKey, "ויקיפדיה");
 
   OverflowItemTestCase(CreateInputForNTP(), std::move(metadata_list),
                        "ויקיפדיה", PhysicalWebProvider::kPhysicalWebMaxMatches,
                        false, true);
 }
 
 TEST_F(PhysicalWebProviderTest, TestNoMatchesInIncognito) {
   // Enable incognito mode
   client_->SetOffTheRecord(true);
 
   MockPhysicalWebDataSource* data_source =
       client_->GetMockPhysicalWebDataSource();
   EXPECT_TRUE(data_source);
 
   data_source->SetMetadata(CreateMetadata(1));
   provider_->Start(CreateInputForNTP(), false);
 
   EXPECT_TRUE(provider_->matches().empty());
 }