Revert of 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;
-  }
-
-  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());
-
+  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));
   scoped_ptr<base::ListValue> alternate_url_list(new base::ListValue());
   if (!alternate_url.empty())
     alternate_url_list->Append(base::Value::CreateStringValue(alternate_url));
-  value->Set(DefaultSearchManager::kAlternateURLs,
-             alternate_url_list.release());
-
+  pref_service->SetManagedPref(prefs::kDefaultSearchProviderAlternateURLs,
+                               alternate_url_list.release());
   pref_service->SetManagedPref(
-      DefaultSearchManager::kDefaultSearchProviderDataPrefName,
-      value.release());
+      prefs::kDefaultSearchProviderSearchTermsReplacementKey,
+      base::Value::CreateStringValue(search_terms_replacement_key));
+  model()->Observe(chrome::NOTIFICATION_DEFAULT_SEARCH_POLICY_CHANGED,
+                   content::NotificationService::AllSources(),
+                   content::NotificationService::NoDetails());
 }
 
 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(
-      DefaultSearchManager::kDefaultSearchProviderDataPrefName);
+      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());
 }
 
 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();
 }