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

chrome/browser/ui/search_engines/keyword_editor_controller_unittest.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 "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/search_engines/default_search_manager.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/ui/search_engines/keyword_editor_controller.h"
 #include "chrome/browser/ui/search_engines/template_url_table_model.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 44 matching lines @@
   }
 
   void ClearChangeCount() {
     model_changed_count_ = items_changed_count_ = added_count_ =
         removed_count_ = 0;
   }
 
   void SimulateDefaultSearchIsManaged(const std::string& url) {
     ASSERT_FALSE(url.empty());
     TestingPrefServiceSyncable* service = profile_->GetTestingPrefService();
-    service->SetManagedPref(prefs::kDefaultSearchProviderEnabled,
-                            new base::FundamentalValue(true));
-    service->SetManagedPref(prefs::kDefaultSearchProviderSearchURL,
-                            new base::StringValue(url));
-    service->SetManagedPref(prefs::kDefaultSearchProviderName,
-                            new base::StringValue("managed"));
-    service->SetManagedPref(prefs::kDefaultSearchProviderKeyword,
-                            new base::StringValue("managed"));
-    // Clear the IDs that are not specified via policy.
-    service->SetManagedPref(prefs::kDefaultSearchProviderID,
-                            new base::StringValue(std::string()));
-    service->SetManagedPref(prefs::kDefaultSearchProviderPrepopulateID,
-                            new base::StringValue(std::string()));
-    model_->Observe(chrome::NOTIFICATION_DEFAULT_SEARCH_POLICY_CHANGED,
-                    content::NotificationService::AllSources(),
-                    content::NotificationService::NoDetails());
+    scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+    value->Set(DefaultSearchManager::kShortName,
+               base::Value::CreateStringValue("managed"));
+    value->Set(DefaultSearchManager::kKeyword,
+               base::Value::CreateStringValue("managed"));
+    value->Set(DefaultSearchManager::kURL,
+               base::Value::CreateStringValue(url));
+    service->SetManagedPref(
+        DefaultSearchManager::kDefaultSearchProviderDataPrefName,
+        value.release());
   }
 
   TemplateURLTableModel* table_model() const {
     return controller_->table_model();
   }
 
  protected:
   base::MessageLoopForUI message_loop_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<KeywordEditorController> controller_;
@@ skipping 18 matching lines @@
   model_ = TemplateURLServiceFactory::GetForProfile(profile_.get());
   if (simulate_load_failure)
     model_->OnWebDataServiceRequestDone(0, NULL);
 
   controller_.reset(new KeywordEditorController(profile_.get()));
   controller_->table_model()->SetObserver(this);
 }
 
 // Tests adding a TemplateURL.
 TEST_F(KeywordEditorControllerTest, Add) {
+  int original_row_count = table_model()->RowCount();
   controller_->AddTemplateURL(kA, kB, "http://c");
 
   // Verify the observer was notified.
   VerifyChangeCount(0, 0, 1, 0);
   if (HasFatalFailure())
     return;
 
   // Verify the TableModel has the new data.
-  ASSERT_EQ(1, table_model()->RowCount());
+  ASSERT_EQ(original_row_count + 1, table_model()->RowCount());
 
-  // Verify the TemplateURLService has the new entry.
-  ASSERT_EQ(1U, model_->GetTemplateURLs().size());
-
-  // Verify the entry is what we added.
-  const TemplateURL* turl = model_->GetTemplateURLs()[0];
+  // Verify the TemplateURLService has the new data.
+  const TemplateURL* turl = model_->GetTemplateURLForKeyword(kB);
+  ASSERT_TRUE(turl);
   EXPECT_EQ(ASCIIToUTF16("a"), turl->short_name());
   EXPECT_EQ(ASCIIToUTF16("b"), turl->keyword());
   EXPECT_EQ("http://c", turl->url());
 }
 
 // Tests modifying a TemplateURL.
 TEST_F(KeywordEditorControllerTest, Modify) {
   controller_->AddTemplateURL(kA, kB, "http://c");
   ClearChangeCount();
 
   // Modify the entry.
   TemplateURL* turl = model_->GetTemplateURLs()[0];
   controller_->ModifyTemplateURL(turl, kA1, kB1, "http://c1");
 
   // Make sure it was updated appropriately.
   VerifyChangeCount(0, 1, 0, 0);
   EXPECT_EQ(ASCIIToUTF16("a1"), turl->short_name());
   EXPECT_EQ(ASCIIToUTF16("b1"), turl->keyword());
   EXPECT_EQ("http://c1", turl->url());
 }
 
 // Tests making a TemplateURL the default search provider.
 TEST_F(KeywordEditorControllerTest, MakeDefault) {
-  controller_->AddTemplateURL(kA, kB, "http://c{searchTerms}");
+  int index = controller_->AddTemplateURL(kA, kB, "http://c{searchTerms}");
   ClearChangeCount();
 
-  const TemplateURL* turl = model_->GetTemplateURLs()[0];
-  int new_default = controller_->MakeDefaultTemplateURL(0);
-  EXPECT_EQ(0, new_default);
+  const TemplateURL* turl = model_->GetTemplateURLForKeyword(kB);
+  int new_default = controller_->MakeDefaultTemplateURL(index);
+  EXPECT_EQ(index, new_default);
   // Making an item the default sends a handful of changes. Which are sent isn't
   // important, what is important is 'something' is sent.
   ASSERT_TRUE(items_changed_count_ > 0 || added_count_ > 0 ||
               removed_count_ > 0);
   ASSERT_TRUE(model_->GetDefaultSearchProvider() == turl);
 
   // Making it default a second time should fail.
-  new_default = controller_->MakeDefaultTemplateURL(0);
+  new_default = controller_->MakeDefaultTemplateURL(index);
   EXPECT_EQ(-1, new_default);
 }
 
 // Tests that a TemplateURL can't be made the default if the default search
 // provider is managed via policy.
 TEST_F(KeywordEditorControllerTest, CannotSetDefaultWhileManaged) {
   controller_->AddTemplateURL(kA, kB, "http://c{searchTerms}");
   controller_->AddTemplateURL(kA1, kB1, "http://d{searchTerms}");
   ClearChangeCount();
 
@@ skipping 37 matching lines @@
   EXPECT_TRUE(model_->is_default_search_managed());
   EXPECT_TRUE(controller_->CanEdit(turl1));
   EXPECT_TRUE(controller_->CanEdit(turl2));
   EXPECT_FALSE(controller_->CanEdit(model_->GetDefaultSearchProvider()));
 }
 
 TEST_F(KeywordEditorControllerTest, MakeDefaultNoWebData) {
   // Simulate a failure to load Web Data.
   Init(true);
 
-  controller_->AddTemplateURL(kA, kB, "http://c{searchTerms}");
+  int index = controller_->AddTemplateURL(kA, kB, "http://c{searchTerms}");
   ClearChangeCount();
 
   // This should not result in a crash.
-  int new_default = controller_->MakeDefaultTemplateURL(0);
-  EXPECT_EQ(0, new_default);
+  int new_default = controller_->MakeDefaultTemplateURL(index);
+  EXPECT_EQ(index, new_default);
 }
 
 // Mutates the TemplateURLService and make sure table model is updating
 // appropriately.
 TEST_F(KeywordEditorControllerTest, MutateTemplateURLService) {
+  int original_row_count = table_model()->RowCount();
+
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("b");
   data.SetKeyword(ASCIIToUTF16("a"));
   TemplateURL* turl = new TemplateURL(profile_.get(), data);
   model_->Add(turl);
 
   // Table model should have updated.
   VerifyChangeCount(1, 0, 0, 0);
 
   // And should contain the newly added TemplateURL.
-  ASSERT_EQ(1, table_model()->RowCount());
-  ASSERT_EQ(0, table_model()->IndexOfTemplateURL(turl));
+  ASSERT_EQ(original_row_count + 1, table_model()->RowCount());
+  ASSERT_GE(table_model()->IndexOfTemplateURL(turl), 0);
 }