Make extensions DSE persistent in browser prefs

components/search_engines/default_search_manager_unittest.cc

 // Copyright 2014 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/search_engines/default_search_manager.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/pref_registry/testing_pref_service_syncable.h"
 #include "components/search_engines/search_engines_pref_names.h"
 #include "components/search_engines/template_url_data.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
+#include "components/search_engines/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 // A dictionary to hold all data related to the Default Search Engine.
 // Eventually, this should replace all the data stored in the
 // default_search_provider.* prefs.
 const char kDefaultSearchProviderData[] =
     "default_search_provider_data.template_url_data";
 
 // Checks that the two TemplateURLs are similar. Does not check the id, the
@@ skipping 51 matching lines @@
   prefs->SetUserPref(prefs::kSearchProviderOverrides, overrides);
 }
 
 void SetPolicy(user_prefs::TestingPrefServiceSyncable* prefs,
                bool enabled,
                TemplateURLData* data) {
   if (enabled) {
     EXPECT_FALSE(data->keyword().empty());
     EXPECT_FALSE(data->url().empty());
   }
-  std::unique_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
-  entry->SetString(DefaultSearchManager::kShortName, data->short_name());
-  entry->SetString(DefaultSearchManager::kKeyword, data->keyword());
-  entry->SetString(DefaultSearchManager::kURL, data->url());
-  entry->SetString(DefaultSearchManager::kFaviconURL, data->favicon_url.spec());
-  entry->SetString(DefaultSearchManager::kSuggestionsURL,
-                   data->suggestions_url);
-  entry->SetBoolean(DefaultSearchManager::kSafeForAutoReplace,
-                    data->safe_for_autoreplace);
-  std::unique_ptr<base::ListValue> alternate_urls(new base::ListValue);
-  for (std::vector<std::string>::const_iterator it =
-           data->alternate_urls.begin();
-       it != data->alternate_urls.end();
-       ++it) {
-    alternate_urls->AppendString(*it);
-  }
-  entry->Set(DefaultSearchManager::kAlternateURLs, alternate_urls.release());
-
-  std::unique_ptr<base::ListValue> encodings(new base::ListValue);
-  for (std::vector<std::string>::const_iterator it =
-           data->input_encodings.begin();
-       it != data->input_encodings.end();
-       ++it) {
-    encodings->AppendString(*it);
-  }
-  entry->Set(DefaultSearchManager::kInputEncodings, encodings.release());
-
-  entry->SetString(DefaultSearchManager::kSearchTermsReplacementKey,
-                   data->search_terms_replacement_key);
+  std::unique_ptr<base::DictionaryValue> entry(
+      TemplateUrlDataToDictionary(*data));
   entry->SetBoolean(DefaultSearchManager::kDisabledByPolicy, !enabled);
   prefs->SetManagedPref(kDefaultSearchProviderData, entry.release());
 }
 
+void SetExtensionControlledDSE(const std::string& extension_id,
+    user_prefs::TestingPrefServiceSyncable* prefs,
+    TemplateURLData* data) {
+
+}
+
+void ClearExtensionControlledDSE(
+    user_prefs::TestingPrefServiceSyncable* prefs) {
+
+}

[vasilii, 2016/11/09 14:29:56]

Why are they empty?

[Alexander Yashkin, 2016/11/28 19:16:17]

I was thinking at first to modify this unittest to check how
DefaultSearchManager works with extension overriden prefs.
But after looking at code and existing extensions tests I decided to add browser
test that installs/remove extension and 
checks DefaultSearchManager interaction with extension DSE.

+
 std::unique_ptr<TemplateURLData> GenerateDummyTemplateURLData(
     const std::string& type) {
   std::unique_ptr<TemplateURLData> data(new TemplateURLData());
   data->SetShortName(base::UTF8ToUTF16(std::string(type).append("name")));
   data->SetKeyword(base::UTF8ToUTF16(std::string(type).append("key")));
   data->SetURL(std::string("http://").append(type).append("foo/{searchTerms}"));
   data->suggestions_url = std::string("http://").append(type).append("sugg");
   data->alternate_urls.push_back(
       std::string("http://").append(type).append("foo/alt"));
   data->favicon_url = GURL("http://icon1");
@@ skipping 142 matching lines @@
   TemplateURLData null_policy_data;
   SetPolicy(pref_service(), false, &null_policy_data);
   EXPECT_EQ(NULL, manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_POLICY, source);
 
   pref_service()->RemoveManagedPref(kDefaultSearchProviderData);
   ExpectSimilar(data.get(), manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_USER, source);
 }
 
+
+class DefaultSearchManagerExensionControlled : public testing::Test {
+  void SetUp() override {
+    pref_service_.reset(new user_prefs::TestingPrefServiceSyncable);
+    DefaultSearchManager::RegisterProfilePrefs(pref_service_->registry());
+    TemplateURLPrepopulateData::RegisterProfilePrefs(pref_service_->registry());
+  }
+
+  user_prefs::TestingPrefServiceSyncable* pref_service() {
+    return pref_service_.get();
+  }
+
+ private:
+  std::unique_ptr<user_prefs::TestingPrefServiceSyncable> pref_service_;
+
+  DISALLOW_COPY_AND_ASSIGN(DefaultSearchManagerExensionControlled);
+};
+
 // Test DefaultSearchManager handles extension-controlled DSEs correctly.
-TEST_F(DefaultSearchManagerTest, DefaultSearchSetByExtension) {
+TEST_F(DefaultSearchManagerExensionControlled, DefaultSearchSetByExtension) {
   DefaultSearchManager manager(pref_service(),
                                DefaultSearchManager::ObserverCallback());
   std::unique_ptr<TemplateURLData> data = GenerateDummyTemplateURLData("user");
   manager.SetUserSelectedDefaultSearchEngine(*data);
 
   DefaultSearchManager::Source source = DefaultSearchManager::FROM_FALLBACK;
   ExpectSimilar(data.get(), manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_USER, source);
 
   // Extension trumps prefs:
   std::unique_ptr<TemplateURLData> extension_data_1 =
       GenerateDummyTemplateURLData("ext1");
-  manager.SetExtensionControlledDefaultSearchEngine(*extension_data_1);
+//  manager.SetExtensionControlledDefaultSearchEngine(*extension_data_1);

[vasilii, 2016/11/09 14:29:56]

Looks like you wanted to change something in this file but forgot.

[Alexander Yashkin, 2016/11/28 19:16:17]

Deleted, see comment above.

+  SetExtensionControlledDSE("ext_id1", pref_service(), extension_data_1.get());
 
   ExpectSimilar(extension_data_1.get(),
                 manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_EXTENSION, source);
 
   // Policy trumps extension:
   std::unique_ptr<TemplateURLData> policy_data =
       GenerateDummyTemplateURLData("policy");
   SetPolicy(pref_service(), true, policy_data.get());
 
   ExpectSimilar(policy_data.get(), manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_POLICY, source);
   pref_service()->RemoveManagedPref(kDefaultSearchProviderData);
 
   // Extensions trump each other:
   std::unique_ptr<TemplateURLData> extension_data_2 =
       GenerateDummyTemplateURLData("ext2");
   std::unique_ptr<TemplateURLData> extension_data_3 =
       GenerateDummyTemplateURLData("ext3");
-  manager.SetExtensionControlledDefaultSearchEngine(*extension_data_2);
-  manager.SetExtensionControlledDefaultSearchEngine(*extension_data_3);
+  //manager.SetExtensionControlledDefaultSearchEngine(*extension_data_2);
+  SetExtensionControlledDSE("ext_id2", pref_service(), extension_data_2.get());
+  //manager.SetExtensionControlledDefaultSearchEngine(*extension_data_3);
+  SetExtensionControlledDSE("ext_id3", pref_service(), extension_data_3.get);
 
   ExpectSimilar(extension_data_3.get(),
                 manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_EXTENSION, source);
 
-  manager.ClearExtensionControlledDefaultSearchEngine();
+  // manager.ClearExtensionControlledDefaultSearchEngine();
+  ClearExtensionControlledDSE(pref_service());
 
   ExpectSimilar(data.get(), manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_USER, source);
 }