#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
-#include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/search_engines/search_terms_data.h"
-#include "chrome/browser/search_engines/template_url.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/common/pref_names.h"
-#include "chrome/common/url_constants.h"
+#include "chrome/browser/search_engines/ui_thread_search_terms_data.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 "extensions/common/constants.h"
+#include "components/search_engines/search_engines_pref_names.h"
+#include "components/search_engines/template_url.h"
+#include "components/search_engines/template_url_prepopulate_data.h"
+#include "components/search_engines/template_url_service.h"
+#include "components/search_engines/template_url_service_client.h"
#include "net/base/net_util.h"
#include "sync/api/sync_change_processor_wrapper_for_test.h"
#include "sync/api/sync_error_factory.h"
virtual void SetUp() OVERRIDE;
virtual void TearDown() OVERRIDE;
- TemplateURLService* model() { return test_util_a_.model(); }
+ TemplateURLService* model() { return test_util_a_->model(); }
// For readability, we redefine an accessor for Model A for use in tests that
// involve syncing two models.
- TemplateURLService* model_a() { return test_util_a_.model(); }
+ TemplateURLService* model_a() { return test_util_a_->model(); }
TemplateURLService* model_b() { return model_b_.get(); }
- TestingProfile* profile_a() { return test_util_a_.profile(); }
+ TestingProfile* profile_a() { return test_util_a_->profile(); }
TestChangeProcessor* processor() { return sync_processor_.get(); }
scoped_ptr<syncer::SyncChangeProcessor> PassProcessor();
scoped_ptr<syncer::SyncErrorFactory> CreateAndPassSyncErrorFactory();
- // Create a TemplateURL with some test values. The caller owns the returned
+ // Creates a TemplateURL with some test values. The caller owns the returned
// TemplateURL*.
TemplateURL* CreateTestTemplateURL(const base::string16& keyword,
const std::string& url,
protected:
// We keep two TemplateURLServices to test syncing between them.
- TemplateURLServiceTestUtil test_util_a_;
+ scoped_ptr<TemplateURLServiceTestUtil> test_util_a_;
scoped_ptr<TestingProfile> profile_b_;
scoped_ptr<TemplateURLService> model_b_;
sync_processor_.get())) {}
void TemplateURLServiceSyncTest::SetUp() {
- TemplateURLService::set_fallback_search_engines_disabled(true);
- test_util_a_.SetUp();
+ DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(true);
+ test_util_a_.reset(new TemplateURLServiceTestUtil);
// Use ChangeToLoadState() instead of VerifyLoad() so we don't actually pull
// in the prepopulate data, which the sync tests don't care about (and would
// just foul them up).
- test_util_a_.ChangeModelToLoadState();
+ test_util_a_->ChangeModelToLoadState();
profile_b_.reset(new TestingProfile);
TemplateURLServiceFactory::GetInstance()->
RegisterUserPrefsOnBrowserContextForTest(profile_b_.get());
- model_b_.reset(new TemplateURLService(profile_b_.get()));
+ model_b_.reset(new TemplateURLService(
+ profile_b_->GetPrefs(), scoped_ptr<SearchTermsData>(
+ new UIThreadSearchTermsData(profile_b_.get())), NULL,
+ scoped_ptr<TemplateURLServiceClient>(), NULL, NULL, base::Closure()));
model_b_->Load();
}
void TemplateURLServiceSyncTest::TearDown() {
- test_util_a_.TearDown();
- TemplateURLService::set_fallback_search_engines_disabled(false);
+ test_util_a_.reset();
+ DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(false);
}
scoped_ptr<syncer::SyncChangeProcessor>
data.prepopulate_id = 999999;
if (!guid.empty())
data.sync_guid = guid;
- return new TemplateURL(NULL, data);
+ return new TemplateURL(data);
}
void TemplateURLServiceSyncTest::AssertEquals(const TemplateURL& expected,
TemplateURL* TemplateURLServiceSyncTest::Deserialize(
const syncer::SyncData& sync_data) {
syncer::SyncChangeList dummy;
- return TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(NULL,
- NULL, sync_data, &dummy);
+ return TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(
+ NULL, SearchTermsData(), NULL, sync_data, &dummy);
}
TemplateURL* TemplateURLServiceSyncTest::CopyTemplateURL(
data.date_created = Time::FromTimeT(100);
data.last_modified = Time::FromTimeT(100);
data.sync_guid = guid;
- return new TemplateURL(NULL, data);
+ return new TemplateURL(data);
}
// Actual tests ---------------------------------------------------------------
TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataWithExtension) {
model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
- model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key3"),
- std::string(extensions::kExtensionScheme) + "://blahblahblah"));
+ model()->RegisterOmniboxKeyword("blahblahblah", "unittest", "key3",
+ "http://blahblahblah");
syncer::SyncDataList all_sync_data =
model()->GetAllSyncData(syncer::SEARCH_ENGINES);
CreateAndPassSyncErrorFactory());
// Add some extension keywords locally.
- TemplateURL* extension1 = CreateTestTemplateURL(ASCIIToUTF16("keyword1"),
- std::string(extensions::kExtensionScheme) + "://extension1");
- model()->Add(extension1);
+ model()->RegisterOmniboxKeyword("extension1", "unittest", "keyword1",
+ "http://extension1");
+ TemplateURL* extension1 =
+ model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1"));
+ ASSERT_TRUE(extension1);
EXPECT_EQ(1U, processor()->change_list_size());
- TemplateURL* extension2 = CreateTestTemplateURL(ASCIIToUTF16("keyword2"),
- std::string(extensions::kExtensionScheme) + "://extension2");
- model()->Add(extension2);
+
+ model()->RegisterOmniboxKeyword("extension2", "unittest", "keyword2",
+ "http://extension2");
+ TemplateURL* extension2 =
+ model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2"));
+ ASSERT_TRUE(extension2);
EXPECT_EQ(1U, processor()->change_list_size());
// Create some sync changes that will conflict with the extension keywords.
data.date_created = Time::FromTimeT(100);
data.last_modified = Time::FromTimeT(100);
data.sync_guid = "keyword";
- scoped_ptr<TemplateURL> turl(new TemplateURL(NULL, data));
+ scoped_ptr<TemplateURL> turl(new TemplateURL(data));
initial_data.push_back(
TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
// Keep a copy of it so we can compare it after we re-merge.
TemplateURL* key1_url = model()->GetTemplateURLForGUID("key1");
ASSERT_TRUE(key1_url);
- scoped_ptr<TemplateURL> updated_turl(new TemplateURL(key1_url->profile(),
- key1_url->data()));
+ scoped_ptr<TemplateURL> updated_turl(new TemplateURL(key1_url->data()));
EXPECT_EQ(Time::FromTimeT(90), updated_turl->last_modified());
// Modify a single field of the initial data. This should not be updated in
scoped_ptr<TemplateURL> temp_turl(Deserialize(initial_data[0]));
TemplateURLData data(temp_turl->data());
data.short_name = ASCIIToUTF16("SomethingDifferent");
- temp_turl.reset(new TemplateURL(temp_turl->profile(), data));
+ temp_turl.reset(new TemplateURL(data));
initial_data.clear();
initial_data.push_back(
TemplateURLService::CreateSyncDataFromTemplateURL(*temp_turl));
data.prepopulate_id = 999999;
data.sync_guid = "key2";
data.show_in_default_list = true;
- scoped_ptr<TemplateURL> turl2(new TemplateURL(NULL, data));
+ scoped_ptr<TemplateURL> turl2(new TemplateURL(data));
initial_data.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(
*turl1));
initial_data.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(
const char kAlternateURL[] =
"http://manageddefault.com/search#t={searchTerms}";
const char kSearchTermsReplacementKey[] = "espv";
- test_util_a_.SetManagedDefaultSearchPreferences(true, kName, kName,
+ test_util_a_->SetManagedDefaultSearchPreferences(true, kName, kName,
kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL,
kSearchTermsReplacementKey);
const TemplateURL* dsp_turl = model()->GetDefaultSearchProvider();
// from Sync.
const TemplateURL* expected_default =
model()->GetTemplateURLForGUID("newdefault");
- test_util_a_.RemoveManagedDefaultSearchPreferences();
+ test_util_a_->RemoveManagedDefaultSearchPreferences();
EXPECT_EQ(expected_default, model()->GetDefaultSearchProvider());
}
data_copy.SetKeyword(ASCIIToUTF16(kNewKeyword));
// Set safe_for_autoreplace to false so our keyword survives.
data_copy.safe_for_autoreplace = false;
- model()->Add(new TemplateURL(profile_a(), data_copy));
+ model()->Add(new TemplateURL(data_copy));
// Merge the prepopulate search engines.
base::Time pre_merge_time = base::Time::Now();
base::RunLoop().RunUntilIdle();
- test_util_a_.ResetModel(true);
+ test_util_a_->ResetModel(true);
// The newly added search engine should have been safely merged, with an
// updated time.
syncer::SyncDataList initial_data;
data_copy.SetKeyword(original_keyword);
data_copy.sync_guid = sync_guid;
- scoped_ptr<TemplateURL> sync_turl(new TemplateURL(profile_a(), data_copy));
+ scoped_ptr<TemplateURL> sync_turl(new TemplateURL(data_copy));
initial_data.push_back(
TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
TEST_F(TemplateURLServiceSyncTest, SyncBaseURLs) {
// Verify that bringing in a remote TemplateURL that uses Google base URLs
// causes it to get a local keyword that matches the local base URL.
- test_util_a_.SetGoogleBaseURL(GURL("http://google.com/"));
+ test_util_a_->SetGoogleBaseURL(GURL("http://google.com/"));
syncer::SyncDataList initial_data;
scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(
ASCIIToUTF16("google.co.uk"), "{google:baseURL}search?q={searchTerms}",
// A local change to the Google base URL should update the keyword and
// generate a sync change.
- test_util_a_.SetGoogleBaseURL(GURL("http://google.co.in/"));
+ test_util_a_->SetGoogleBaseURL(GURL("http://google.co.in/"));
EXPECT_EQ(ASCIIToUTF16("google.co.in"), synced_turl->keyword());
EXPECT_EQ(1U, processor()->change_list_size());
ASSERT_TRUE(processor()->contains_guid("guid"));
TemplateURLData data = *default_turl;
data.SetURL("http://old.wrong.url.com?q={searchTerms}");
data.sync_guid = "default";
- model()->Add(new TemplateURL(NULL, data));
+ model()->Add(new TemplateURL(data));
syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
syncer::SEARCH_ENGINES, syncer::SyncDataList(), PassProcessor(),
data.date_created = Time::FromTimeT(50);
data.last_modified = Time::FromTimeT(50);
data.sync_guid = "default";
- model()->Add(new TemplateURL(NULL, data));
+ model()->Add(new TemplateURL(data));
data.date_created = Time::FromTimeT(100);
data.last_modified = Time::FromTimeT(100);
- scoped_ptr<TemplateURL> sync_turl(new TemplateURL(NULL, data));
+ scoped_ptr<TemplateURL> sync_turl(new TemplateURL(data));
syncer::SyncDataList list;
list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
data.date_created = Time::FromTimeT(50);
data.last_modified = Time::FromTimeT(50);
data.sync_guid = "default";
- model()->Add(new TemplateURL(NULL, data));
+ model()->Add(new TemplateURL(data));
data.date_created = Time::FromTimeT(100);
data.last_modified = Time::FromTimeT(100);
- scoped_ptr<TemplateURL> sync_turl(new TemplateURL(NULL, data));
+ scoped_ptr<TemplateURL> sync_turl(new TemplateURL(data));
syncer::SyncDataList list;
list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
projects / platform / framework / web / crosswalk.git / blobdiff