Merge search engines sync data type with Preferences. Sync the default search provider. Add some ...

chrome/browser/search_engines/template_url_service_sync_unittest.cc

 // Copyright (c) 2011 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 "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
+#include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/sync/protocol/search_engine_specifics.pb.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_pref_service.h"
 #include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/notification_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace {
 
 // Extract the GUID from a search engine SyncData.
 std::string GetGUID(const SyncData& sync_data) {
   return sync_data.GetSpecifics().GetExtension(
       sync_pb::search_engine).sync_guid();
 }
 
-// Extract the keyword from a search engine SyncData.
+// Extract the URL from a search engine SyncData.
 std::string GetURL(const SyncData& sync_data) {
   return sync_data.GetSpecifics().GetExtension(
       sync_pb::search_engine).url();
 }
 
 // Extract the keyword from a search engine SyncData.
 std::string GetKeyword(const SyncData& sync_data) {
   return sync_data.GetSpecifics().GetExtension(
       sync_pb::search_engine).keyword();
 }
 
+// TODO(stevet): Share these with template_url_service_unittest.
+// Set the managed preferences for the default search provider and trigger
+// notification.
+void SetManagedDefaultSearchPreferences(TemplateURLService* turl_service,
+                                        TestingProfile* profile,
+                                        bool enabled,
+                                        const char* name,
+                                        const char* search_url,
+                                        const char* suggest_url,
+                                        const char* icon_url,
+                                        const char* encodings,
+                                        const char* keyword) {
+  TestingPrefService* pref_service = profile->GetTestingPrefService();
+  pref_service->SetManagedPref(prefs::kDefaultSearchProviderEnabled,

[Nicolas Zea, 2011/11/04 23:08:06]

Are these prefs always set all-at-once like this? I wonder (as a completely
separate idea from this patch) if they should just be combined into one
dictionary pref

[SteveT, 2011/11/07 21:48:56]

I believe the policy system allows an admin to set any combination of these
managed prefs at once, but generally they get set as a group at a time.
Jean-Luc: Any thoughts on this? I was following the format of your unit test for
managed DSPs. Should we be testing changes at a lower granularity both here and
in your unit tests?

+                               Value::CreateBooleanValue(enabled));
+  pref_service->SetManagedPref(prefs::kDefaultSearchProviderName,
+                               Value::CreateStringValue(name));
+  pref_service->SetManagedPref(prefs::kDefaultSearchProviderSearchURL,
+                               Value::CreateStringValue(search_url));
+  pref_service->SetManagedPref(prefs::kDefaultSearchProviderSuggestURL,
+                               Value::CreateStringValue(suggest_url));
+  pref_service->SetManagedPref(prefs::kDefaultSearchProviderIconURL,
+                               Value::CreateStringValue(icon_url));
+  pref_service->SetManagedPref(prefs::kDefaultSearchProviderEncodings,
+                               Value::CreateStringValue(encodings));
+  pref_service->SetManagedPref(prefs::kDefaultSearchProviderKeyword,
+                               Value::CreateStringValue(keyword));
+}
+
+// Remove all the managed preferences for the default search provider and
+// trigger notification.
+void RemoveManagedDefaultSearchPreferences(TemplateURLService* turl_service,
+                                           TestingProfile* profile) {
+  TestingPrefService* pref_service = profile->GetTestingPrefService();
+  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderSearchURL);
+  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderEnabled);
+  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderName);
+  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderSuggestURL);
+  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderIconURL);
+  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderEncodings);
+  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderKeyword);
+  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderID);
+  pref_service->RemoveManagedPref(prefs::kDefaultSearchProviderPrepopulateID);
+}
+
 // Dummy SyncChangeProcessor used to help review what SyncChanges are pushed
 // back up to Sync.
 class TestChangeProcessor : public SyncChangeProcessor {
  public:
   TestChangeProcessor() : erroneous_(false) {
   }
   virtual ~TestChangeProcessor() { }
 
   // Store a copy of all the changes passed in so we can examine them later.
   virtual SyncError ProcessSyncChanges(
@@ skipping 33 matching lines @@
 };
 
 class TemplateURLServiceSyncTest : public testing::Test {
  public:
   typedef TemplateURLService::SyncDataMap SyncDataMap;
 
   TemplateURLServiceSyncTest() {}
 
   virtual void SetUp() {
     profile_a_.reset(new TestingProfile);
+    TemplateURLServiceFactory::GetInstance()->RegisterUserPrefsOnProfile(
+        profile_a_.get());
     model_a_.reset(new TemplateURLService(profile_a_.get()));
     model_a_->Load();
     profile_b_.reset(new TestingProfile);
+    TemplateURLServiceFactory::GetInstance()->RegisterUserPrefsOnProfile(
+        profile_b_.get());
     model_b_.reset(new TemplateURLService(profile_b_.get()));
     model_b_->Load();
   }
 
   virtual void TearDown() { }
 
   TemplateURLService* model() { return model_a_.get(); }
   // For readability, we redefine an accessor for Model A for use in tests that
   // involve syncing two models.
   TemplateURLService* model_a() { return model_a_.get(); }
@@ skipping 951 matching lines @@
   error = model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
                                             initial_data,
                                             processor());
   ASSERT_FALSE(error.IsSet());
 
   // Check that the TemplateURL was not modified.
   const TemplateURL* reupdated_turl = model()->GetTemplateURLForGUID("key1");
   ASSERT_TRUE(reupdated_turl);
   AssertEquals(updated_turl, *reupdated_turl);
 }
+
+TEST_F(TemplateURLServiceSyncTest, SyncWithManagedDefaultSearch) {
+  // First start off with a few entries and make sure we can set an unmanaged
+  // default search provider.
+  SyncDataList initial_data = CreateInitialSyncData();
+  model()->MergeDataAndStartSyncing(
+      syncable::SEARCH_ENGINES,
+      initial_data,
+      processor());
+  model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID("key2"));
+
+  EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+  ASSERT_FALSE(model()->is_default_search_managed());
+  ASSERT_TRUE(model()->GetDefaultSearchProvider());
+
+  // Change the default search provider to a managed one.
+  const char kName[] = "manageddefault";
+  const char kSearchURL[] = "http://manageddefault.com/search?t={searchTerms}";
+  const char kIconURL[] = "http://manageddefault.com/icon.jpg";
+  const char kEncodings[] = "UTF-16;UTF-32";
+  SetManagedDefaultSearchPreferences(model(), profile_a_.get(), true, kName,
+                                     kSearchURL, "", kIconURL, kEncodings, "");
+  const TemplateURL* dsp_turl = model()->GetDefaultSearchProvider();
+
+  EXPECT_TRUE(model()->is_default_search_managed());
+
+  // Add a new entry from Sync. It should still sync in despite the default
+  // being managed.
+  SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(
+      SyncChange::ACTION_ADD,
+      CreateTestTemplateURL("newkeyword", "http://new.com", "newdefault")));
+  model()->ProcessSyncChanges(FROM_HERE, changes);
+
+  EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+
+  // Change kSyncedDefaultSearchProviderGUID to point to the new entry and
+  // ensure that the DSP remains managed.
+  profile_a_->GetTestingPrefService()->SetString(
+      prefs::kSyncedDefaultSearchProviderGUID,
+      "newdefault");
+
+  EXPECT_EQ(dsp_turl, model()->GetDefaultSearchProvider());
+  EXPECT_TRUE(model()->is_default_search_managed());
+  EXPECT_TRUE(profile_a_->GetTestingPrefService()->GetBoolean(
+      prefs::kPendingSyncedDefaultSearchProviderChange));
+
+  // Go unmanaged. Ensure that the DSP changes to the expected pending entry
+  // from Sync.
+  const TemplateURL* expected_default =
+      model()->GetTemplateURLForGUID("newdefault");
+  RemoveManagedDefaultSearchPreferences(model(), profile_a_.get());
+
+  EXPECT_EQ(expected_default, model()->GetDefaultSearchProvider());
+  EXPECT_FALSE(profile_a_->GetTestingPrefService()->GetBoolean(
+      prefs::kPendingSyncedDefaultSearchProviderChange));

[Nicolas Zea, 2011/11/04 23:08:06]

add a case where the synceddefaultsearchproviderguid arrives for a sync guid
that doesn't exist yet?

[SteveT, 2011/11/07 21:48:56]

Ah yes, of course :)

Added SyncedDefaultGUIDArrivesFirst to account for that case.

+}