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

chrome/browser/profile_resetter/automatic_profile_resetter_delegate_unittest.cc

 // Copyright 2013 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/profile_resetter/automatic_profile_resetter_delegate.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service_unittest.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/profile_resetter/brandcoded_default_settings.h"
 #include "chrome/browser/profile_resetter/profile_reset_global_error.h"
-#include "chrome/browser/search_engines/default_search_manager.h"
 #include "chrome/browser/search_engines/template_url_prepopulate_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/search_engines/template_url_service_test_util.h"
 #include "chrome/browser/ui/global_error/global_error.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_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"
@@ skipping 47 matching lines @@
   base::Closure CreateClosure() {
     return base::Bind(&MockCallbackTarget::Run, base::Unretained(this));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockCallbackTarget);
 };
 
 // Returns the details of the default search provider from |prefs| in a format
 // suitable for usage as |expected_details| in ExpectDetailsMatch().
-const base::DictionaryValue* GetDefaultSearchProviderDetailsFromPrefs(
+scoped_ptr<base::DictionaryValue> GetDefaultSearchProviderDetailsFromPrefs(
     const PrefService* prefs) {
-  return prefs->GetDictionary(
-      DefaultSearchManager::kDefaultSearchProviderDataPrefName);
+  const char kDefaultSearchProviderPrefix[] = "default_search_provider";
+  scoped_ptr<base::DictionaryValue> pref_values_with_path_expansion(
+      prefs->GetPreferenceValues());
+  const base::DictionaryValue* dsp_details = NULL;
+  EXPECT_TRUE(pref_values_with_path_expansion->GetDictionary(
+      kDefaultSearchProviderPrefix, &dsp_details));
+  return scoped_ptr<base::DictionaryValue>(
+      dsp_details ? dsp_details->DeepCopy() : new base::DictionaryValue);
 }
 
 // Verifies that the |details| of a search engine as provided by the delegate
 // are correct in comparison to the |expected_details| coming from the Prefs.
 void ExpectDetailsMatch(const base::DictionaryValue& expected_details,
                         const base::DictionaryValue& details) {
   for (base::DictionaryValue::Iterator it(expected_details); !it.IsAtEnd();
        it.Advance()) {
     SCOPED_TRACE(testing::Message("Key: ") << it.key());
     if (it.key() == "enabled" || it.key() == "synced_guid") {
       // These attributes should not be present.
       EXPECT_FALSE(details.HasKey(it.key()));
       continue;
     }
     const base::Value* expected_value = &it.value();
     const base::Value* actual_value = NULL;
     ASSERT_TRUE(details.Get(it.key(), &actual_value));
 
-    // Ignore ID as it is dynamically assigned by the TemplateURLService.
-    // last_modified may get updated during a run, so ignore value differences.
-    if (it.key() != "id" && it.key() != "last_modified") {
+    if (it.key() == "id") {
+      // Ignore ID as it is dynamically assigned by the TemplateURLService.
+    } else if (it.key() == "encodings") {
+      // Encoding list is stored in Prefs as a single string with tokens
+      // delimited by semicolons.
+      std::string expected_encodings;
+      ASSERT_TRUE(expected_value->GetAsString(&expected_encodings));
+      const base::ListValue* actual_encodings_list = NULL;
+      ASSERT_TRUE(actual_value->GetAsList(&actual_encodings_list));
+      std::vector<std::string> actual_encodings_vector;
+      for (base::ListValue::const_iterator it = actual_encodings_list->begin();
+           it != actual_encodings_list->end(); ++it) {
+        std::string encoding;
+        ASSERT_TRUE((*it)->GetAsString(&encoding));
+        actual_encodings_vector.push_back(encoding);
+      }
+      EXPECT_EQ(expected_encodings, JoinString(actual_encodings_vector, ';'));
+    } else {
       // Everything else is the same format.
       EXPECT_TRUE(actual_value->Equals(expected_value))
           << "Expected: " << *expected_value << ". Actual: " << *actual_value;
     }
   }
 }
 
 // If |simulate_failure| is false, then replies to the pending request on
 // |fetcher| with a brandcoded config that only specifies a home page URL.
 // If |simulate_failure| is true, replies with 404.
@@ skipping 222 matching lines @@
   // TemplateURLService into Prefs.
   scoped_ptr<TemplateURL> owned_custom_dsp(CreateTestTemplateURL());
   TemplateURL* custom_dsp = owned_custom_dsp.get();
   template_url_service->Add(owned_custom_dsp.release());
   template_url_service->SetUserSelectedDefaultSearchProvider(custom_dsp);
 
   PrefService* prefs = profile()->GetPrefs();
   ASSERT_TRUE(prefs);
   scoped_ptr<base::DictionaryValue> dsp_details(
       resetter_delegate()->GetDefaultSearchProviderDetails());
-  const base::DictionaryValue* expected_dsp_details =
-      GetDefaultSearchProviderDetailsFromPrefs(prefs);
+  scoped_ptr<base::DictionaryValue> expected_dsp_details(
+      GetDefaultSearchProviderDetailsFromPrefs(prefs));
 
   ExpectDetailsMatch(*expected_dsp_details, *dsp_details);
   EXPECT_FALSE(resetter_delegate()->IsDefaultSearchProviderManaged());
 }
 
 TEST_F(AutomaticProfileResetterDelegateTest,
        DefaultSearchProviderDataWhenManaged) {
   const char kTestSearchURL[] = "http://example.com/search?q={searchTerms}";
   const char kTestName[] = "name";
   const char kTestKeyword[] = "keyword";
@@ skipping 52 matching lines @@
     ASSERT_TRUE(details->GetString("keyword", &keyword));
     TemplateURL* search_engine =
         template_url_service->GetTemplateURLForKeyword(
             base::ASCIIToUTF16(keyword));
     ASSERT_TRUE(search_engine);
     template_url_service->SetUserSelectedDefaultSearchProvider(
         prepopulated_engines[i]);
 
     PrefService* prefs = profile()->GetPrefs();
     ASSERT_TRUE(prefs);
-    const base::DictionaryValue* expected_dsp_details =
-        GetDefaultSearchProviderDetailsFromPrefs(prefs);
+    scoped_ptr<base::DictionaryValue> expected_dsp_details(
+        GetDefaultSearchProviderDetailsFromPrefs(prefs));
     ExpectDetailsMatch(*expected_dsp_details, *details);
   }
 }
 
 TEST_F(AutomaticProfileResetterDelegateTest,
        FetchAndWaitOnDefaultSettingsVanilla) {
   google_util::BrandForTesting scoped_brand_for_testing((std::string()));
 
   // Expect ready_callback to be called just after empty brandcoded settings
   // are loaded, given this is a vanilla build. Fail if it is not called, or
@@ skipping 147 matching lines @@
   if (ProfileResetGlobalError::IsSupportedOnPlatform())
     ExpectResetPromptState(true /*active*/);
   else
     ExpectResetPromptState(false /*active*/);
   resetter_delegate()->DismissPrompt();
   ExpectResetPromptState(false /*active*/);
   resetter_delegate()->DismissPrompt();
 }
 
 }  // namespace