Use the DefaultSearchManager as the exclusive authority on DSE, ignoring Web Data.

chrome/browser/search_engines/template_url_service_test_util.cc

 // Copyright (c) 2012 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 "chrome/browser/search_engines/template_url_service_test_util.h"
 
 #include "base/bind.h"
 #include "base/run_loop.h"
+#include "base/strings/string_split.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/google/google_url_tracker.h"
+#include "chrome/browser/search_engines/default_search_manager.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/webdata/web_data_service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/notification_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 115 matching lines @@
 void TemplateURLServiceTestUtilBase::SetManagedDefaultSearchPreferences(
     bool enabled,
     const std::string& name,
     const std::string& keyword,
     const std::string& search_url,
     const std::string& suggest_url,
     const std::string& icon_url,
     const std::string& encodings,
     const std::string& alternate_url,
     const std::string& search_terms_replacement_key) {
-  if (enabled) {
-    EXPECT_FALSE(keyword.empty());
-    EXPECT_FALSE(search_url.empty());
+  TestingPrefServiceSyncable* pref_service = profile()->GetTestingPrefService();
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  if (!enabled) {
+    value->SetBoolean(DefaultSearchManager::kDisabledByPolicy, true);
+    pref_service->SetManagedPref(
+        DefaultSearchManager::kDefaultSearchProviderDataPrefName,
+        value.release());
+    return;
   }
-  TestingPrefServiceSyncable* pref_service = profile()->GetTestingPrefService();
-  pref_service->SetManagedPref(prefs::kDefaultSearchProviderEnabled,
-                               base::Value::CreateBooleanValue(enabled));
-  pref_service->SetManagedPref(prefs::kDefaultSearchProviderName,
-                               base::Value::CreateStringValue(name));
-  pref_service->SetManagedPref(prefs::kDefaultSearchProviderKeyword,
-                               base::Value::CreateStringValue(keyword));
-  pref_service->SetManagedPref(prefs::kDefaultSearchProviderSearchURL,
-                               base::Value::CreateStringValue(search_url));
-  pref_service->SetManagedPref(prefs::kDefaultSearchProviderSuggestURL,
-                               base::Value::CreateStringValue(suggest_url));
-  pref_service->SetManagedPref(prefs::kDefaultSearchProviderIconURL,
-                               base::Value::CreateStringValue(icon_url));
-  pref_service->SetManagedPref(prefs::kDefaultSearchProviderEncodings,
-                               base::Value::CreateStringValue(encodings));
+
+  EXPECT_FALSE(keyword.empty());
+  EXPECT_FALSE(search_url.empty());
+  value->Set(DefaultSearchManager::kShortName,
+             base::Value::CreateStringValue(name));
+  value->Set(DefaultSearchManager::kKeyword,
+             base::Value::CreateStringValue(keyword));
+  value->Set(DefaultSearchManager::kURL,
+             base::Value::CreateStringValue(search_url));
+  value->Set(DefaultSearchManager::kSuggestionsURL,
+             base::Value::CreateStringValue(suggest_url));
+  value->Set(DefaultSearchManager::kFaviconURL,
+             base::Value::CreateStringValue(icon_url));
+  value->Set(DefaultSearchManager::kSearchTermsReplacementKey,
+             base::Value::CreateStringValue(search_terms_replacement_key));
+
+  std::vector<std::string> encodings_items;
+  base::SplitString(encodings, ';', &encodings_items);
+  scoped_ptr<base::ListValue> encodings_list(new base::ListValue);
+  for (std::vector<std::string>::const_iterator it = encodings_items.begin();
+       it != encodings_items.end();
+       ++it) {
+    encodings_list->AppendString(*it);
+  }
+  value->Set(DefaultSearchManager::kInputEncodings, encodings_list.release());
+
   scoped_ptr<base::ListValue> alternate_url_list(new base::ListValue());
   if (!alternate_url.empty())
     alternate_url_list->Append(base::Value::CreateStringValue(alternate_url));
-  pref_service->SetManagedPref(prefs::kDefaultSearchProviderAlternateURLs,
-                               alternate_url_list.release());
+  value->Set(DefaultSearchManager::kAlternateURLs,
+             alternate_url_list.release());
+
   pref_service->SetManagedPref(
-      prefs::kDefaultSearchProviderSearchTermsReplacementKey,
-      base::Value::CreateStringValue(search_terms_replacement_key));
-  model()->Observe(chrome::NOTIFICATION_DEFAULT_SEARCH_POLICY_CHANGED,
-                   content::NotificationService::AllSources(),
-                   content::NotificationService::NoDetails());
+      DefaultSearchManager::kDefaultSearchProviderDataPrefName,
+      value.release());
 }
 
 void TemplateURLServiceTestUtilBase::RemoveManagedDefaultSearchPreferences() {
   TestingPrefServiceSyncable* pref_service = profile()->GetTestingPrefService();
-  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderEnabled);
-  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderName);
-  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderKeyword);
-  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderSearchURL);
-  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderSuggestURL);
-  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderIconURL);
-  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderEncodings);
-  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderAlternateURLs);
   pref_service->RemoveManagedPref(
-      prefs::kDefaultSearchProviderSearchTermsReplacementKey);
-  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderID);
-  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderPrepopulateID);
-  model()->Observe(chrome::NOTIFICATION_DEFAULT_SEARCH_POLICY_CHANGED,
-                   content::NotificationService::AllSources(),
-                   content::NotificationService::NoDetails());
+      DefaultSearchManager::kDefaultSearchProviderDataPrefName);
 }
 
 TemplateURLService* TemplateURLServiceTestUtilBase::model() const {
   return TemplateURLServiceFactory::GetForProfile(profile());
 }
 
 
 // TemplateURLServiceTestUtil -------------------------------------------------
 
 TemplateURLServiceTestUtil::TemplateURLServiceTestUtil()
@@ skipping 20 matching lines @@
 
   UIThreadSearchTermsData::SetGoogleBaseURL(std::string());
 
   // Flush the message loop to make application verifiers happy.
   base::RunLoop().RunUntilIdle();
 }
 
 TestingProfile* TemplateURLServiceTestUtil::profile() const {
   return profile_.get();
 }