// 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 "build/build_config.h"
#if defined(OS_WIN)
// The order of these includes is important.
#include <windows.h>
#include <unknwn.h>
#include <intshcut.h>
#include <pstore.h>
#include <urlhist.h>
#include <shlguid.h>
#endif
#include <vector>
#include "app/win/scoped_com_initializer.h"
#include "base/compiler_specific.h"
#include "base/file_util.h"
#include "base/message_loop.h"
#include "base/path_service.h"
#include "base/stl_util-inl.h"
#include "base/string_util.h"
#include "base/utf_string_conversions.h"
#include "base/memory/scoped_temp_dir.h"
#include "chrome/browser/history/history_types.h"
#include "chrome/browser/importer/importer_bridge.h"
#include "chrome/browser/importer/importer_data_types.h"
#include "chrome/browser/importer/importer_host.h"
#include "chrome/browser/importer/importer_progress_observer.h"
#include "chrome/browser/search_engines/template_url.h"
#include "chrome/common/chrome_paths.h"
#include "content/browser/browser_thread.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webkit/glue/password_form.h"
#if defined(OS_WIN)
#include "base/win/scoped_comptr.h"
#include "base/win/windows_version.h"
#include "chrome/browser/importer/ie_importer.h"
#include "chrome/browser/password_manager/ie7_password.h"
#endif
// TODO(estade): some of these are disabled on mac. http://crbug.com/48007
#if defined(OS_MACOSX)
#define MAYBE(x) DISABLED_##x
#else
#define MAYBE(x) x
#endif
class ImporterTest : public testing::Test {
public:
ImporterTest()
: ui_thread_(BrowserThread::UI, &message_loop_),
file_thread_(BrowserThread::FILE, &message_loop_) {}
protected:
virtual void SetUp() {
// Creates a new profile in a new subdirectory in the temp directory.
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
FilePath test_path = temp_dir_.path().AppendASCII("ImporterTest");
file_util::Delete(test_path, true);
file_util::CreateDirectory(test_path);
profile_path_ = test_path.AppendASCII("profile");
app_path_ = test_path.AppendASCII("app");
file_util::CreateDirectory(app_path_);
}
void Firefox3xImporterTest(std::string profile_dir,
importer::ImporterProgressObserver* observer,
ProfileWriter* writer,
bool import_search_plugins) {
FilePath data_path;
ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_path));
data_path = data_path.AppendASCII(profile_dir);
ASSERT_TRUE(file_util::CopyDirectory(data_path, profile_path_, true));
ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_path));
data_path = data_path.AppendASCII("firefox3_nss");
ASSERT_TRUE(file_util::CopyDirectory(data_path, profile_path_, false));
FilePath search_engine_path = app_path_;
search_engine_path = search_engine_path.AppendASCII("searchplugins");
file_util::CreateDirectory(search_engine_path);
if (import_search_plugins) {
ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_path));
data_path = data_path.AppendASCII("firefox3_searchplugins");
if (!file_util::PathExists(data_path)) {
// TODO(maruel): Create search test data that we can open source!
LOG(ERROR) << L"Missing internal test data";
return;
}
ASSERT_TRUE(file_util::CopyDirectory(data_path,
search_engine_path, false));
}
MessageLoop* loop = MessageLoop::current();
importer::SourceProfile source_profile;
source_profile.importer_type = importer::FIREFOX3;
source_profile.app_path = app_path_;
source_profile.source_path = profile_path_;
scoped_refptr<ImporterHost> host(new ImporterHost);
host->SetObserver(observer);
int items = importer::HISTORY | importer::PASSWORDS | importer::FAVORITES;
if (import_search_plugins)
items = items | importer::SEARCH_ENGINES;
loop->PostTask(FROM_HERE, NewRunnableMethod(host.get(),
&ImporterHost::StartImportSettings, source_profile,
static_cast<Profile*>(NULL), items, make_scoped_refptr(writer), true));
loop->Run();
}
ScopedTempDir temp_dir_;
MessageLoopForUI message_loop_;
BrowserThread ui_thread_;
BrowserThread file_thread_;
FilePath profile_path_;
FilePath app_path_;
};
const int kMaxPathSize = 5;
struct BookmarkList {
const bool in_toolbar;
const size_t path_size;
const wchar_t* path[kMaxPathSize];
const wchar_t* title;
const char* url;
};
// Returns true if the |entry| is in the |list|.
bool FindBookmarkEntry(const ProfileWriter::BookmarkEntry& entry,
const BookmarkList* list, int list_size) {
for (int i = 0; i < list_size; ++i) {
if (list[i].in_toolbar == entry.in_toolbar &&
list[i].path_size == entry.path.size() &&
list[i].url == entry.url.spec() &&
WideToUTF16Hack(list[i].title) == entry.title) {
bool equal = true;
for (size_t k = 0; k < list[i].path_size; ++k)
if (WideToUTF16Hack(list[i].path[k]) != entry.path[k]) {
equal = false;
break;
}
if (equal)
return true;
}
}
return false;
}
#if defined(OS_WIN)
static const BookmarkList kIEBookmarks[] = {
{true, 0, {},
L"TheLink",
"http://www.links-thelink.com/"},
{true, 1, {L"SubFolderOfLinks"},
L"SubLink",
"http://www.links-sublink.com/"},
{false, 0, {},
L"Google Home Page",
"http://www.google.com/"},
{false, 0, {},
L"TheLink",
"http://www.links-thelink.com/"},
{false, 1, {L"SubFolder"},
L"Title",
"http://www.link.com/"},
{false, 0, {},
L"WithPortAndQuery",
"http://host:8080/cgi?q=query"},
{false, 1, {L"a"},
L"\x4E2D\x6587",
"http://chinese-title-favorite/"},
};
static const wchar_t* kIEIdentifyUrl =
L"http://A79029D6-753E-4e27-B807-3D46AB1545DF.com:8080/path?key=value";
static const wchar_t* kIEIdentifyTitle =
L"Unittest GUID";
class TestObserver : public ProfileWriter,
public importer::ImporterProgressObserver {
public:
TestObserver() : ProfileWriter(NULL) {
bookmark_count_ = 0;
history_count_ = 0;
password_count_ = 0;
}
// importer::ImporterProgressObserver:
virtual void ImportStarted() OVERRIDE {}
virtual void ImportItemStarted(importer::ImportItem item) OVERRIDE {}
virtual void ImportItemEnded(importer::ImportItem item) OVERRIDE {}
virtual void ImportEnded() OVERRIDE {
MessageLoop::current()->Quit();
EXPECT_EQ(arraysize(kIEBookmarks), bookmark_count_);
EXPECT_EQ(1, history_count_);
#if 0 // This part of the test is disabled. See bug #2466
if (base::win::GetVersion() >= base::win::VERSION_VISTA)
EXPECT_EQ(0, password_count_);
else
EXPECT_EQ(1, password_count_);
#endif
}
virtual bool BookmarkModelIsLoaded() const {
// Profile is ready for writing.
return true;
}
virtual bool TemplateURLModelIsLoaded() const {
return true;
}
virtual void AddPasswordForm(const webkit_glue::PasswordForm& form) {
// Importer should obtain this password form only.
EXPECT_EQ(GURL("http://localhost:8080/security/index.htm"), form.origin);
EXPECT_EQ("http://localhost:8080/", form.signon_realm);
EXPECT_EQ(L"user", form.username_element);
EXPECT_EQ(L"1", form.username_value);
EXPECT_EQ(L"", form.password_element);
EXPECT_EQ(L"2", form.password_value);
EXPECT_EQ("", form.action.spec());
++password_count_;
}
virtual void AddHistoryPage(const std::vector<history::URLRow>& page,
history::VisitSource visit_source) {
// Importer should read the specified URL.
for (size_t i = 0; i < page.size(); ++i) {
if (page[i].title() == kIEIdentifyTitle &&
page[i].url() == GURL(kIEIdentifyUrl))
++history_count_;
}
EXPECT_EQ(history::SOURCE_IE_IMPORTED, visit_source);
}
virtual void AddBookmarkEntry(const std::vector<BookmarkEntry>& bookmark,
const string16& first_folder_name,
int options) {
// Importer should import the IE Favorites folder the same as the list.
for (size_t i = 0; i < bookmark.size(); ++i) {
if (FindBookmarkEntry(bookmark[i], kIEBookmarks,
arraysize(kIEBookmarks)))
++bookmark_count_;
}
}
virtual void AddKeyword(std::vector<TemplateURL*> template_url,
int default_keyword_index) {
// TODO(jcampan): bug 1169230: we should test keyword importing for IE.
// In order to do that we'll probably need to mock the Windows registry.
NOTREACHED();
STLDeleteContainerPointers(template_url.begin(), template_url.end());
}
private:
~TestObserver() {}
size_t bookmark_count_;
size_t history_count_;
size_t password_count_;
};
bool CreateUrlFile(std::wstring file, std::wstring url) {
base::win::ScopedComPtr<IUniformResourceLocator> locator;
HRESULT result = locator.CreateInstance(CLSID_InternetShortcut, NULL,
CLSCTX_INPROC_SERVER);
if (FAILED(result))
return false;
base::win::ScopedComPtr<IPersistFile> persist_file;
result = persist_file.QueryFrom(locator);
if (FAILED(result))
return false;
result = locator->SetURL(url.c_str(), 0);
if (FAILED(result))
return false;
result = persist_file->Save(file.c_str(), TRUE);
if (FAILED(result))
return false;
return true;
}
void ClearPStoreType(IPStore* pstore, const GUID* type, const GUID* subtype) {
base::win::ScopedComPtr<IEnumPStoreItems, NULL> item;
HRESULT result = pstore->EnumItems(0, type, subtype, 0, item.Receive());
if (result == PST_E_OK) {
wchar_t* item_name;
while (SUCCEEDED(item->Next(1, &item_name, 0))) {
pstore->DeleteItem(0, type, subtype, item_name, NULL, 0);
CoTaskMemFree(item_name);
}
}
pstore->DeleteSubtype(0, type, subtype, 0);
pstore->DeleteType(0, type, 0);
}
void WritePStore(IPStore* pstore, const GUID* type, const GUID* subtype) {
struct PStoreItem {
wchar_t* name;
int data_size;
char* data;
} items[] = {
{L"http://localhost:8080/security/index.htm#ref:StringData", 8,
"\x31\x00\x00\x00\x32\x00\x00\x00"},
{L"http://localhost:8080/security/index.htm#ref:StringIndex", 20,
"\x57\x49\x43\x4b\x18\x00\x00\x00\x02\x00"
"\x00\x00\x2f\x00\x74\x00\x01\x00\x00\x00"},
{L"user:StringData", 4,
"\x31\x00\x00\x00"},
{L"user:StringIndex", 20,
"\x57\x49\x43\x4b\x18\x00\x00\x00\x01\x00"
"\x00\x00\x2f\x00\x74\x00\x00\x00\x00\x00"},
};
for (int i = 0; i < arraysize(items); ++i) {
HRESULT res = pstore->WriteItem(0, type, subtype, items[i].name,
items[i].data_size, reinterpret_cast<BYTE*>(items[i].data),
NULL, 0, 0);
ASSERT_TRUE(res == PST_E_OK);
}
}
TEST_F(ImporterTest, IEImporter) {
// Sets up a favorites folder.
app::win::ScopedCOMInitializer com_init;
std::wstring path = temp_dir_.path().AppendASCII("Favorites").value();
CreateDirectory(path.c_str(), NULL);
CreateDirectory((path + L"\\SubFolder").c_str(), NULL);
CreateDirectory((path + L"\\Links").c_str(), NULL);
CreateDirectory((path + L"\\Links\\SubFolderOfLinks").c_str(), NULL);
CreateDirectory((path + L"\\\x0061").c_str(), NULL);
ASSERT_TRUE(CreateUrlFile(path + L"\\Google Home Page.url",
L"http://www.google.com/"));
ASSERT_TRUE(CreateUrlFile(path + L"\\SubFolder\\Title.url",
L"http://www.link.com/"));
ASSERT_TRUE(CreateUrlFile(path + L"\\TheLink.url",
L"http://www.links-thelink.com/"));
ASSERT_TRUE(CreateUrlFile(path + L"\\WithPortAndQuery.url",
L"http://host:8080/cgi?q=query"));
ASSERT_TRUE(CreateUrlFile(path + L"\\\x0061\\\x4E2D\x6587.url",
L"http://chinese-title-favorite/"));
ASSERT_TRUE(CreateUrlFile(path + L"\\Links\\TheLink.url",
L"http://www.links-thelink.com/"));
ASSERT_TRUE(CreateUrlFile(path + L"\\Links\\SubFolderOfLinks\\SubLink.url",
L"http://www.links-sublink.com/"));
file_util::WriteFile(path + L"\\InvalidUrlFile.url", "x", 1);
file_util::WriteFile(path + L"\\PlainTextFile.txt", "x", 1);
// Sets up dummy password data.
HRESULT res;
#if 0 // This part of the test is disabled. See bug #2466
base::win::ScopedComPtr<IPStore> pstore;
HMODULE pstorec_dll;
GUID type = IEImporter::kUnittestGUID;
GUID subtype = IEImporter::kUnittestGUID;
// PStore is read-only in Windows Vista.
if (base::win::GetVersion() < base::win::VERSION_VISTA) {
typedef HRESULT (WINAPI *PStoreCreateFunc)(IPStore**, DWORD, DWORD, DWORD);
pstorec_dll = LoadLibrary(L"pstorec.dll");
PStoreCreateFunc PStoreCreateInstance =
(PStoreCreateFunc)GetProcAddress(pstorec_dll, "PStoreCreateInstance");
res = PStoreCreateInstance(pstore.Receive(), 0, 0, 0);
ASSERT_TRUE(res == S_OK);
ClearPStoreType(pstore, &type, &subtype);
PST_TYPEINFO type_info;
type_info.szDisplayName = L"TestType";
type_info.cbSize = 8;
pstore->CreateType(0, &type, &type_info, 0);
pstore->CreateSubtype(0, &type, &subtype, &type_info, NULL, 0);
WritePStore(pstore, &type, &subtype);
}
#endif
// Sets up a special history link.
base::win::ScopedComPtr<IUrlHistoryStg2> url_history_stg2;
res = url_history_stg2.CreateInstance(CLSID_CUrlHistory, NULL,
CLSCTX_INPROC_SERVER);
ASSERT_TRUE(res == S_OK);
res = url_history_stg2->AddUrl(kIEIdentifyUrl, kIEIdentifyTitle, 0);
ASSERT_TRUE(res == S_OK);
// Starts to import the above settings.
MessageLoop* loop = MessageLoop::current();
scoped_refptr<ImporterHost> host(new ImporterHost);
TestObserver* observer = new TestObserver();
host->SetObserver(observer);
importer::SourceProfile source_profile;
source_profile.importer_type = importer::MS_IE;
source_profile.source_path = temp_dir_.path();
loop->PostTask(FROM_HERE, NewRunnableMethod(host.get(),
&ImporterHost::StartImportSettings,
source_profile,
static_cast<Profile*>(NULL),
importer::HISTORY | importer::PASSWORDS | importer::FAVORITES,
observer,
true));
loop->Run();
// Cleans up.
url_history_stg2->DeleteUrl(kIEIdentifyUrl, 0);
url_history_stg2.Release();
#if 0 // This part of the test is disabled. See bug #2466
if (base::win::GetVersion() < base::win::VERSION_VISTA) {
ClearPStoreType(pstore, &type, &subtype);
// Releases it befor unload the dll.
pstore.Release();
FreeLibrary(pstorec_dll);
}
#endif
}
TEST_F(ImporterTest, IE7Importer) {
// This is the unencrypted values of my keys under Storage2.
// The passwords have been manually changed to abcdef... but the size remains
// the same.
unsigned char data1[] = "\x0c\x00\x00\x00\x38\x00\x00\x00\x2c\x00\x00\x00"
"\x57\x49\x43\x4b\x18\x00\x00\x00\x02\x00\x00\x00"
"\x67\x00\x72\x00\x01\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x4e\xfa\x67\x76\x22\x94\xc8\x01"
"\x08\x00\x00\x00\x12\x00\x00\x00\x4e\xfa\x67\x76"
"\x22\x94\xc8\x01\x0c\x00\x00\x00\x61\x00\x62\x00"
"\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00"
"\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00"
"\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00"
"\x6c\x00\x00\x00";
unsigned char data2[] = "\x0c\x00\x00\x00\x38\x00\x00\x00\x24\x00\x00\x00"
"\x57\x49\x43\x4b\x18\x00\x00\x00\x02\x00\x00\x00"
"\x67\x00\x72\x00\x01\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\xa8\xea\xf4\xe5\x9f\x9a\xc8\x01"
"\x09\x00\x00\x00\x14\x00\x00\x00\xa8\xea\xf4\xe5"
"\x9f\x9a\xc8\x01\x07\x00\x00\x00\x61\x00\x62\x00"
"\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00"
"\x69\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00"
"\x65\x00\x66\x00\x67\x00\x00\x00";
std::vector<unsigned char> decrypted_data1;
decrypted_data1.resize(arraysize(data1));
memcpy(&decrypted_data1.front(), data1, sizeof(data1));
std::vector<unsigned char> decrypted_data2;
decrypted_data2.resize(arraysize(data2));
memcpy(&decrypted_data2.front(), data2, sizeof(data2));
std::wstring password;
std::wstring username;
ASSERT_TRUE(ie7_password::GetUserPassFromData(decrypted_data1, &username,
&password));
EXPECT_EQ(L"abcdefgh", username);
EXPECT_EQ(L"abcdefghijkl", password);
ASSERT_TRUE(ie7_password::GetUserPassFromData(decrypted_data2, &username,
&password));
EXPECT_EQ(L"abcdefghi", username);
EXPECT_EQ(L"abcdefg", password);
}
#endif // defined(OS_WIN)
static const BookmarkList kFirefox2Bookmarks[] = {
{true, 1, {L"Folder"},
L"On Toolbar's Subfolder",
"http://on.toolbar/bookmark/folder"},
{true, 0, {},
L"On Bookmark Toolbar",
"http://on.toolbar/bookmark"},
{false, 1, {L"Folder"},
L"New Bookmark",
"http://domain/"},
{false, 0, {},
L"<Name>",
"http://domain.com/q?a=%22er%22&b=%3C%20%20%3E"},
{false, 0, {},
L"Google Home Page",
"http://www.google.com/"},
{false, 0, {},
L"\x4E2D\x6587",
"http://chinese.site.cn/path?query=1#ref"},
{false, 0, {},
L"mail",
"mailto:username@host"},
};
struct PasswordList {
const char* origin;
const char* action;
const char* realm;
const wchar_t* username_element;
const wchar_t* username;
const wchar_t* password_element;
const wchar_t* password;
bool blacklisted;
};
static const PasswordList kFirefox2Passwords[] = {
{"https://www.google.com/", "", "https://www.google.com/",
L"", L"", L"", L"", true},
{"http://localhost:8080/", "", "http://localhost:8080/corp.google.com",
L"", L"http", L"", L"Http1+1abcdefg", false},
{"http://localhost:8080/", "http://localhost:8080/", "http://localhost:8080/",
L"loginuser", L"usr", L"loginpass", L"pwd", false},
{"http://localhost:8080/", "http://localhost:8080/", "http://localhost:8080/",
L"loginuser", L"firefox", L"loginpass", L"firefox", false},
{"http://localhost/", "", "http://localhost/",
L"loginuser", L"hello", L"", L"world", false},
};
struct KeywordList {
const wchar_t* keyword;
const char* url;
};
static const KeywordList kFirefox2Keywords[] = {
// Searh plugins
{ L"amazon.com",
"http://www.amazon.com/exec/obidos/external-search/?field-keywords="
"{searchTerms}&mode=blended" },
{ L"answers.com",
"http://www.answers.com/main/ntquery?s={searchTerms}&gwp=13" },
{ L"search.creativecommons.org",
"http://search.creativecommons.org/?q={searchTerms}" },
{ L"search.ebay.com",
"http://search.ebay.com/search/search.dll?query={searchTerms}&"
"MfcISAPICommand=GetResult&ht=1&ebaytag1=ebayreg&srchdesc=n&"
"maxRecordsReturned=300&maxRecordsPerPage=50&SortProperty=MetaEndSort" },
{ L"google.com",
"http://www.google.com/search?q={searchTerms}&ie=utf-8&oe=utf-8&aq=t" },
{ L"search.yahoo.com",
"http://search.yahoo.com/search?p={searchTerms}&ei=UTF-8" },
{ L"flickr.com",
"http://www.flickr.com/photos/tags/?q={searchTerms}" },
{ L"imdb.com",
"http://www.imdb.com/find?q={searchTerms}" },
{ L"webster.com",
"http://www.webster.com/cgi-bin/dictionary?va={searchTerms}" },
// Search keywords.
{ L"google", "http://www.google.com/" },
{ L"< > & \" ' \\ /", "http://g.cn/"},
};
static const int kDefaultFirefox2KeywordIndex = 8;
class FirefoxObserver : public ProfileWriter,
public importer::ImporterProgressObserver {
public:
FirefoxObserver() : ProfileWriter(NULL) {
bookmark_count_ = 0;
history_count_ = 0;
password_count_ = 0;
keyword_count_ = 0;
}
// importer::ImporterProgressObserver:
virtual void ImportStarted() OVERRIDE {}
virtual void ImportItemStarted(importer::ImportItem item) OVERRIDE {}
virtual void ImportItemEnded(importer::ImportItem item) OVERRIDE {}
virtual void ImportEnded() OVERRIDE {
MessageLoop::current()->Quit();
EXPECT_EQ(arraysize(kFirefox2Bookmarks), bookmark_count_);
EXPECT_EQ(1U, history_count_);
EXPECT_EQ(arraysize(kFirefox2Passwords), password_count_);
EXPECT_EQ(arraysize(kFirefox2Keywords), keyword_count_);
EXPECT_EQ(kFirefox2Keywords[kDefaultFirefox2KeywordIndex].keyword,
default_keyword_);
EXPECT_EQ(kFirefox2Keywords[kDefaultFirefox2KeywordIndex].url,
default_keyword_url_);
}
virtual bool BookmarkModelIsLoaded() const {
// Profile is ready for writing.
return true;
}
virtual bool TemplateURLModelIsLoaded() const {
return true;
}
virtual void AddPasswordForm(const webkit_glue::PasswordForm& form) {
PasswordList p = kFirefox2Passwords[password_count_];
EXPECT_EQ(p.origin, form.origin.spec());
EXPECT_EQ(p.realm, form.signon_realm);
EXPECT_EQ(p.action, form.action.spec());
EXPECT_EQ(WideToUTF16(p.username_element), form.username_element);
EXPECT_EQ(WideToUTF16(p.username), form.username_value);
EXPECT_EQ(WideToUTF16(p.password_element), form.password_element);
EXPECT_EQ(WideToUTF16(p.password), form.password_value);
EXPECT_EQ(p.blacklisted, form.blacklisted_by_user);
++password_count_;
}
virtual void AddHistoryPage(const std::vector<history::URLRow>& page,
history::VisitSource visit_source) {
ASSERT_EQ(1U, page.size());
EXPECT_EQ("http://en-us.www.mozilla.com/", page[0].url().spec());
EXPECT_EQ(ASCIIToUTF16("Firefox Updated"), page[0].title());
EXPECT_EQ(history::SOURCE_FIREFOX_IMPORTED, visit_source);
++history_count_;
}
virtual void AddBookmarkEntry(const std::vector<BookmarkEntry>& bookmark,
const string16& first_folder_name,
int options) {
for (size_t i = 0; i < bookmark.size(); ++i) {
if (FindBookmarkEntry(bookmark[i], kFirefox2Bookmarks,
arraysize(kFirefox2Bookmarks)))
++bookmark_count_;
}
}
virtual void AddKeywords(const std::vector<TemplateURL*>& template_urls,
int default_keyword_index,
bool unique_on_host_and_path) {
for (size_t i = 0; i < template_urls.size(); ++i) {
// The order might not be deterministic, look in the expected list for
// that template URL.
bool found = false;
string16 keyword = template_urls[i]->keyword();
for (size_t j = 0; j < arraysize(kFirefox2Keywords); ++j) {
if (template_urls[i]->keyword() ==
WideToUTF16Hack(kFirefox2Keywords[j].keyword)) {
EXPECT_EQ(kFirefox2Keywords[j].url, template_urls[i]->url()->url());
found = true;
break;
}
}
EXPECT_TRUE(found);
++keyword_count_;
}
if (default_keyword_index != -1) {
EXPECT_LT(default_keyword_index, static_cast<int>(template_urls.size()));
TemplateURL* default_turl = template_urls[default_keyword_index];
default_keyword_ = UTF16ToWideHack(default_turl->keyword());
default_keyword_url_ = default_turl->url()->url();
}
STLDeleteContainerPointers(template_urls.begin(), template_urls.end());
}
void AddFavicons(const std::vector<history::ImportedFaviconUsage>& favicons) {
}
private:
~FirefoxObserver() {}
size_t bookmark_count_;
size_t history_count_;
size_t password_count_;
size_t keyword_count_;
std::wstring default_keyword_;
std::string default_keyword_url_;
};
TEST_F(ImporterTest, MAYBE(Firefox2Importer)) {
FilePath data_path;
ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_path));
data_path = data_path.AppendASCII("firefox2_profile");
ASSERT_TRUE(file_util::CopyDirectory(data_path, profile_path_, true));
ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_path));
data_path = data_path.AppendASCII("firefox2_nss");
ASSERT_TRUE(file_util::CopyDirectory(data_path, profile_path_, false));
FilePath search_engine_path = app_path_;
search_engine_path = search_engine_path.AppendASCII("searchplugins");
file_util::CreateDirectory(search_engine_path);
ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_path));
data_path = data_path.AppendASCII("firefox2_searchplugins");
if (!file_util::PathExists(data_path)) {
// TODO(maruel): Create test data that we can open source!
LOG(ERROR) << L"Missing internal test data";
return;
}
ASSERT_TRUE(file_util::CopyDirectory(data_path, search_engine_path, false));
MessageLoop* loop = MessageLoop::current();
scoped_refptr<ImporterHost> host(new ImporterHost);
FirefoxObserver* observer = new FirefoxObserver();
host->SetObserver(observer);
importer::SourceProfile source_profile;
source_profile.importer_type = importer::FIREFOX2;
source_profile.app_path = app_path_;
source_profile.source_path = profile_path_;
loop->PostTask(FROM_HERE, NewRunnableMethod(
host.get(),
&ImporterHost::StartImportSettings,
source_profile,
static_cast<Profile*>(NULL),
importer::HISTORY | importer::PASSWORDS |
importer::FAVORITES | importer::SEARCH_ENGINES,
make_scoped_refptr(observer),
true));
loop->Run();
}
static const BookmarkList kFirefox3Bookmarks[] = {
{true, 0, {},
L"Toolbar",
"http://site/"},
{false, 0, {},
L"Title",
"http://www.google.com/"},
};
static const PasswordList kFirefox3Passwords[] = {
{"http://localhost:8080/", "http://localhost:8080/", "http://localhost:8080/",
L"loginuser", L"abc", L"loginpass", L"123", false},
{"http://localhost:8080/", "", "http://localhost:8080/localhost",
L"", L"http", L"", L"Http1+1abcdefg", false},
};
static const KeywordList kFirefox3Keywords[] = {
{ L"amazon.com",
"http://www.amazon.com/exec/obidos/external-search/?field-keywords="
"{searchTerms}&mode=blended" },
{ L"answers.com",
"http://www.answers.com/main/ntquery?s={searchTerms}&gwp=13" },
{ L"search.creativecommons.org",
"http://search.creativecommons.org/?q={searchTerms}" },
{ L"search.ebay.com",
"http://search.ebay.com/search/search.dll?query={searchTerms}&"
"MfcISAPICommand=GetResult&ht=1&ebaytag1=ebayreg&srchdesc=n&"
"maxRecordsReturned=300&maxRecordsPerPage=50&SortProperty=MetaEndSort" },
{ L"google.com",
"http://www.google.com/search?q={searchTerms}&ie=utf-8&oe=utf-8&aq=t" },
{ L"en.wikipedia.org",
"http://en.wikipedia.org/wiki/Special:Search?search={searchTerms}" },
{ L"search.yahoo.com",
"http://search.yahoo.com/search?p={searchTerms}&ei=UTF-8" },
{ L"flickr.com",
"http://www.flickr.com/photos/tags/?q={searchTerms}" },
{ L"imdb.com",
"http://www.imdb.com/find?q={searchTerms}" },
{ L"webster.com",
"http://www.webster.com/cgi-bin/dictionary?va={searchTerms}" },
// Search keywords.
{ L"\x4E2D\x6587", "http://www.google.com/" },
};
static const int kDefaultFirefox3KeywordIndex = 8;
class Firefox3Observer : public ProfileWriter,
public importer::ImporterProgressObserver {
public:
Firefox3Observer()
: ProfileWriter(NULL), bookmark_count_(0), history_count_(0),
password_count_(0), keyword_count_(0), import_search_engines_(true) {
}
explicit Firefox3Observer(bool import_search_engines)
: ProfileWriter(NULL), bookmark_count_(0), history_count_(0),
password_count_(0), keyword_count_(0),
import_search_engines_(import_search_engines) {
}
// importer::ImporterProgressObserver:
virtual void ImportStarted() OVERRIDE {}
virtual void ImportItemStarted(importer::ImportItem item) OVERRIDE {}
virtual void ImportItemEnded(importer::ImportItem item) OVERRIDE {}
virtual void ImportEnded() OVERRIDE {
MessageLoop::current()->Quit();
EXPECT_EQ(arraysize(kFirefox3Bookmarks), bookmark_count_);
EXPECT_EQ(1U, history_count_);
EXPECT_EQ(arraysize(kFirefox3Passwords), password_count_);
if (import_search_engines_) {
EXPECT_EQ(arraysize(kFirefox3Keywords), keyword_count_);
EXPECT_EQ(kFirefox3Keywords[kDefaultFirefox3KeywordIndex].keyword,
default_keyword_);
EXPECT_EQ(kFirefox3Keywords[kDefaultFirefox3KeywordIndex].url,
default_keyword_url_);
}
}
virtual bool BookmarkModelIsLoaded() const {
// Profile is ready for writing.
return true;
}
virtual bool TemplateURLModelIsLoaded() const {
return true;
}
virtual void AddPasswordForm(const webkit_glue::PasswordForm& form) {
PasswordList p = kFirefox3Passwords[password_count_];
EXPECT_EQ(p.origin, form.origin.spec());
EXPECT_EQ(p.realm, form.signon_realm);
EXPECT_EQ(p.action, form.action.spec());
EXPECT_EQ(WideToUTF16(p.username_element), form.username_element);
EXPECT_EQ(WideToUTF16(p.username), form.username_value);
EXPECT_EQ(WideToUTF16(p.password_element), form.password_element);
EXPECT_EQ(WideToUTF16(p.password), form.password_value);
EXPECT_EQ(p.blacklisted, form.blacklisted_by_user);
++password_count_;
}
virtual void AddHistoryPage(const std::vector<history::URLRow>& page,
history::VisitSource visit_source) {
ASSERT_EQ(3U, page.size());
EXPECT_EQ("http://www.google.com/", page[0].url().spec());
EXPECT_EQ(ASCIIToUTF16("Google"), page[0].title());
EXPECT_EQ("http://www.google.com/", page[1].url().spec());
EXPECT_EQ(ASCIIToUTF16("Google"), page[1].title());
EXPECT_EQ("http://www.cs.unc.edu/~jbs/resources/perl/perl-cgi/programs/form1-POST.html",
page[2].url().spec());
EXPECT_EQ(ASCIIToUTF16("example form (POST)"), page[2].title());
EXPECT_EQ(history::SOURCE_FIREFOX_IMPORTED, visit_source);
++history_count_;
}
virtual void AddBookmarkEntry(const std::vector<BookmarkEntry>& bookmark,
const string16& first_folder_name,
int options) {
for (size_t i = 0; i < bookmark.size(); ++i) {
if (FindBookmarkEntry(bookmark[i], kFirefox3Bookmarks,
arraysize(kFirefox3Bookmarks)))
++bookmark_count_;
}
}
void AddKeywords(const std::vector<TemplateURL*>& template_urls,
int default_keyword_index,
bool unique_on_host_and_path) {
for (size_t i = 0; i < template_urls.size(); ++i) {
// The order might not be deterministic, look in the expected list for
// that template URL.
bool found = false;
string16 keyword = template_urls[i]->keyword();
for (size_t j = 0; j < arraysize(kFirefox3Keywords); ++j) {
if (template_urls[i]->keyword() ==
WideToUTF16Hack(kFirefox3Keywords[j].keyword)) {
EXPECT_EQ(kFirefox3Keywords[j].url, template_urls[i]->url()->url());
found = true;
break;
}
}
EXPECT_TRUE(found);
++keyword_count_;
}
if (default_keyword_index != -1) {
EXPECT_LT(default_keyword_index, static_cast<int>(template_urls.size()));
TemplateURL* default_turl = template_urls[default_keyword_index];
default_keyword_ = UTF16ToWideHack(default_turl->keyword());
default_keyword_url_ = default_turl->url()->url();
}
STLDeleteContainerPointers(template_urls.begin(), template_urls.end());
}
void AddFavicons(const std::vector<history::ImportedFaviconUsage>& favicons) {
}
private:
~Firefox3Observer() {}
size_t bookmark_count_;
size_t history_count_;
size_t password_count_;
size_t keyword_count_;
bool import_search_engines_;
std::wstring default_keyword_;
std::string default_keyword_url_;
};
TEST_F(ImporterTest, MAYBE(Firefox30Importer)) {
scoped_refptr<Firefox3Observer> observer(new Firefox3Observer());
Firefox3xImporterTest("firefox3_profile", observer.get(), observer.get(),
true);
}
TEST_F(ImporterTest, MAYBE(Firefox35Importer)) {
bool import_search_engines = false;
scoped_refptr<Firefox3Observer> observer(
new Firefox3Observer(import_search_engines));
Firefox3xImporterTest("firefox35_profile", observer.get(), observer.get(),
import_search_engines);
}