Home | History | Annotate | Download | only in importer 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/importer/profile_writer.h"
      6 
      7 #include <string>
      8 
      9 #include "base/message_loop/message_loop.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 #include "chrome/browser/bookmarks/bookmark_model.h"
     12 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
     13 #include "chrome/browser/bookmarks/bookmark_test_helpers.h"
     14 #include "chrome/browser/bookmarks/bookmark_title_match.h"
     15 #include "chrome/browser/bookmarks/bookmark_utils.h"
     16 #include "chrome/browser/history/history_service.h"
     17 #include "chrome/browser/history/history_service_factory.h"
     18 #include "chrome/browser/history/history_types.h"
     19 #include "chrome/browser/importer/importer_unittest_utils.h"
     20 #include "chrome/common/importer/imported_bookmark_entry.h"
     21 #include "chrome/test/base/testing_profile.h"
     22 #include "content/public/test/test_browser_thread.h"
     23 #include "testing/gtest/include/gtest/gtest.h"
     24 
     25 using content::BrowserThread;
     26 
     27 class TestProfileWriter : public ProfileWriter {
     28  public:
     29   explicit TestProfileWriter(Profile* profile) : ProfileWriter(profile) {}
     30  protected:
     31   virtual ~TestProfileWriter() {}
     32 };
     33 
     34 class ProfileWriterTest : public testing::Test {
     35  public:
     36   ProfileWriterTest()
     37       : loop_(base::MessageLoop::TYPE_DEFAULT),
     38         ui_thread_(BrowserThread::UI, &loop_),
     39         file_thread_(BrowserThread::FILE, &loop_) {
     40   }
     41   virtual ~ProfileWriterTest() {}
     42 
     43   // Create test bookmark entries to be added to ProfileWriter to
     44   // simulate bookmark importing.
     45   void CreateImportedBookmarksEntries() {
     46     AddImportedBookmarkEntry(GURL("http://www.google.com"),
     47                              ASCIIToUTF16("Google"));
     48     AddImportedBookmarkEntry(GURL("http://www.yahoo.com"),
     49                              ASCIIToUTF16("Yahoo"));
     50   }
     51 
     52   // Helper function to create history entries.
     53   history::URLRow MakeURLRow(const char* url,
     54                              base::string16 title,
     55                              int visit_count,
     56                              int days_since_last_visit,
     57                              int typed_count) {
     58     history::URLRow row(GURL(url), 0);
     59     row.set_title(title);
     60     row.set_visit_count(visit_count);
     61     row.set_typed_count(typed_count);
     62     row.set_last_visit(base::Time::NowFromSystemTime() -
     63                        base::TimeDelta::FromDays(days_since_last_visit));
     64     return row;
     65   }
     66 
     67   // Create test history entries to be added to ProfileWriter to
     68   // simulate history importing.
     69   void CreateHistoryPageEntries() {
     70     history::URLRow row1(
     71         MakeURLRow("http://www.google.com", ASCIIToUTF16("Google"), 3, 10, 1));
     72     history::URLRow row2(
     73         MakeURLRow("http://www.yahoo.com", ASCIIToUTF16("Yahoo"), 3, 30, 10));
     74     pages_.push_back(row1);
     75     pages_.push_back(row2);
     76   }
     77 
     78   void VerifyBookmarksCount(
     79       const std::vector<BookmarkService::URLAndTitle>& bookmarks_record,
     80       BookmarkModel* bookmark_model,
     81       size_t expected) {
     82     std::vector<BookmarkTitleMatch> matches;
     83     for (size_t i = 0; i < bookmarks_record.size(); ++i) {
     84       bookmark_model->GetBookmarksWithTitlesMatching(bookmarks_record[i].title,
     85                                                      10,
     86                                                      &matches);
     87       EXPECT_EQ(expected, matches.size());
     88       matches.clear();
     89     }
     90   }
     91 
     92   void VerifyHistoryCount(Profile* profile) {
     93     HistoryService* history_service =
     94         HistoryServiceFactory::GetForProfile(profile,
     95                                              Profile::EXPLICIT_ACCESS);
     96     history::QueryOptions options;
     97     CancelableRequestConsumer history_request_consumer;
     98     history_service->QueryHistory(
     99         base::string16(),
    100         options,
    101         &history_request_consumer,
    102         base::Bind(&ProfileWriterTest::HistoryQueryComplete,
    103                    base::Unretained(this)));
    104     base::MessageLoop::current()->Run();
    105   }
    106 
    107   void HistoryQueryComplete(HistoryService::Handle handle,
    108                             history::QueryResults* results) {
    109     base::MessageLoop::current()->Quit();
    110     history_count_ = results->size();
    111   }
    112 
    113  protected:
    114   std::vector<ImportedBookmarkEntry> bookmarks_;
    115   history::URLRows pages_;
    116   size_t history_count_;
    117 
    118  private:
    119   void AddImportedBookmarkEntry(const GURL& url, const base::string16& title) {
    120     base::Time date;
    121     ImportedBookmarkEntry entry;
    122     entry.creation_time = date;
    123     entry.url = url;
    124     entry.title = title;
    125     entry.in_toolbar = true;
    126     entry.is_folder = false;
    127     bookmarks_.push_back(entry);
    128   }
    129 
    130   base::MessageLoop loop_;
    131   content::TestBrowserThread ui_thread_;
    132   content::TestBrowserThread file_thread_;
    133 
    134   DISALLOW_COPY_AND_ASSIGN(ProfileWriterTest);
    135 };
    136 
    137 // Add bookmarks via ProfileWriter to profile1 when profile2 also exists.
    138 TEST_F(ProfileWriterTest, CheckBookmarksWithMultiProfile) {
    139   TestingProfile profile2;
    140   profile2.CreateBookmarkModel(true);
    141 
    142   BookmarkModel* bookmark_model2 =
    143       BookmarkModelFactory::GetForProfile(&profile2);
    144   test::WaitForBookmarkModelToLoad(bookmark_model2);
    145   bookmark_utils::AddIfNotBookmarked(bookmark_model2,
    146                                      GURL("http://www.bing.com"),
    147                                      ASCIIToUTF16("Bing"));
    148   TestingProfile profile1;
    149   profile1.CreateBookmarkModel(true);
    150 
    151   CreateImportedBookmarksEntries();
    152   BookmarkModel* bookmark_model1 =
    153       BookmarkModelFactory::GetForProfile(&profile1);
    154   test::WaitForBookmarkModelToLoad(bookmark_model1);
    155 
    156   scoped_refptr<TestProfileWriter> profile_writer(
    157       new TestProfileWriter(&profile1));
    158   profile_writer->AddBookmarks(bookmarks_,
    159                                ASCIIToUTF16("Imported from Firefox"));
    160 
    161   std::vector<BookmarkService::URLAndTitle> url_record1;
    162   bookmark_model1->GetBookmarks(&url_record1);
    163   EXPECT_EQ(2u, url_record1.size());
    164 
    165   std::vector<BookmarkService::URLAndTitle> url_record2;
    166   bookmark_model2->GetBookmarks(&url_record2);
    167   EXPECT_EQ(1u, url_record2.size());
    168 }
    169 
    170 // Verify that bookmarks are duplicated when added twice.
    171 TEST_F(ProfileWriterTest, CheckBookmarksAfterWritingDataTwice) {
    172   TestingProfile profile;
    173   profile.CreateBookmarkModel(true);
    174 
    175   CreateImportedBookmarksEntries();
    176   BookmarkModel* bookmark_model =
    177       BookmarkModelFactory::GetForProfile(&profile);
    178   test::WaitForBookmarkModelToLoad(bookmark_model);
    179 
    180   scoped_refptr<TestProfileWriter> profile_writer(
    181       new TestProfileWriter(&profile));
    182   profile_writer->AddBookmarks(bookmarks_,
    183                                ASCIIToUTF16("Imported from Firefox"));
    184   std::vector<BookmarkService::URLAndTitle> bookmarks_record;
    185   bookmark_model->GetBookmarks(&bookmarks_record);
    186   EXPECT_EQ(2u, bookmarks_record.size());
    187 
    188   VerifyBookmarksCount(bookmarks_record, bookmark_model, 1);
    189 
    190   profile_writer->AddBookmarks(bookmarks_,
    191                                ASCIIToUTF16("Imported from Firefox"));
    192   // Verify that duplicate bookmarks exist.
    193   VerifyBookmarksCount(bookmarks_record, bookmark_model, 2);
    194 }
    195 
    196 // Verify that history entires are not duplicated when added twice.
    197 TEST_F(ProfileWriterTest, CheckHistoryAfterWritingDataTwice) {
    198   TestingProfile profile;
    199   ASSERT_TRUE(profile.CreateHistoryService(true, false));
    200   profile.BlockUntilHistoryProcessesPendingRequests();
    201 
    202   CreateHistoryPageEntries();
    203   scoped_refptr<TestProfileWriter> profile_writer(
    204       new TestProfileWriter(&profile));
    205   profile_writer->AddHistoryPage(pages_, history::SOURCE_FIREFOX_IMPORTED);
    206   VerifyHistoryCount(&profile);
    207   size_t original_history_count = history_count_;
    208   history_count_ = 0;
    209 
    210   profile_writer->AddHistoryPage(pages_, history::SOURCE_FIREFOX_IMPORTED);
    211   VerifyHistoryCount(&profile);
    212   EXPECT_EQ(original_history_count, history_count_);
    213 }
    214