Home | History | Annotate | Download | only in integration 
      1 // Copyright (c) 2012 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/sync/test/integration/typed_urls_helper.h"
      6 
      7 #include "base/compiler_specific.h"
      8 #include "base/strings/utf_string_conversions.h"
      9 #include "base/synchronization/waitable_event.h"
     10 #include "base/time/time.h"
     11 #include "chrome/browser/common/cancelable_request.h"
     12 #include "chrome/browser/history/history_backend.h"
     13 #include "chrome/browser/history/history_db_task.h"
     14 #include "chrome/browser/history/history_service.h"
     15 #include "chrome/browser/history/history_service_factory.h"
     16 #include "chrome/browser/history/history_types.h"
     17 #include "chrome/browser/profiles/profile.h"
     18 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
     19 #include "chrome/browser/sync/test/integration/sync_test.h"
     20 
     21 using sync_datatype_helper::test;
     22 
     23 namespace {
     24 
     25 class FlushHistoryDBQueueTask : public history::HistoryDBTask {
     26  public:
     27   explicit FlushHistoryDBQueueTask(base::WaitableEvent* event)
     28       : wait_event_(event) {}
     29   virtual bool RunOnDBThread(history::HistoryBackend* backend,
     30                              history::HistoryDatabase* db) OVERRIDE {
     31     wait_event_->Signal();
     32     return true;
     33   }
     34 
     35   virtual void DoneRunOnMainThread() OVERRIDE {}
     36 
     37  private:
     38   virtual ~FlushHistoryDBQueueTask() {}
     39 
     40   base::WaitableEvent* wait_event_;
     41 };
     42 
     43 class GetTypedUrlsTask : public history::HistoryDBTask {
     44  public:
     45   GetTypedUrlsTask(history::URLRows* rows, base::WaitableEvent* event)
     46       : rows_(rows), wait_event_(event) {}
     47 
     48   virtual bool RunOnDBThread(history::HistoryBackend* backend,
     49                              history::HistoryDatabase* db) OVERRIDE {
     50     // Fetch the typed URLs.
     51     backend->GetAllTypedURLs(rows_);
     52     wait_event_->Signal();
     53     return true;
     54   }
     55 
     56   virtual void DoneRunOnMainThread() OVERRIDE {}
     57 
     58  private:
     59   virtual ~GetTypedUrlsTask() {}
     60 
     61   history::URLRows* rows_;
     62   base::WaitableEvent* wait_event_;
     63 };
     64 
     65 class GetUrlTask : public history::HistoryDBTask {
     66  public:
     67   GetUrlTask(const GURL& url,
     68              history::URLRow* row,
     69              bool* found,
     70              base::WaitableEvent* event)
     71       : url_(url), row_(row), wait_event_(event), found_(found) {}
     72 
     73   virtual bool RunOnDBThread(history::HistoryBackend* backend,
     74                              history::HistoryDatabase* db) OVERRIDE {
     75     // Fetch the typed URLs.
     76     *found_ = backend->GetURL(url_, row_);
     77     wait_event_->Signal();
     78     return true;
     79   }
     80 
     81   virtual void DoneRunOnMainThread() OVERRIDE {}
     82 
     83  private:
     84   virtual ~GetUrlTask() {}
     85 
     86   GURL url_;
     87   history::URLRow* row_;
     88   base::WaitableEvent* wait_event_;
     89   bool* found_;
     90 };
     91 
     92 class GetVisitsTask : public history::HistoryDBTask {
     93  public:
     94   GetVisitsTask(history::URLID id,
     95                 history::VisitVector* visits,
     96                 base::WaitableEvent* event)
     97       : id_(id), visits_(visits), wait_event_(event) {}
     98 
     99   virtual bool RunOnDBThread(history::HistoryBackend* backend,
    100                              history::HistoryDatabase* db) OVERRIDE {
    101     // Fetch the visits.
    102     backend->GetVisitsForURL(id_, visits_);
    103     wait_event_->Signal();
    104     return true;
    105   }
    106 
    107   virtual void DoneRunOnMainThread() OVERRIDE {}
    108 
    109  private:
    110   virtual ~GetVisitsTask() {}
    111 
    112   history::URLID id_;
    113   history::VisitVector* visits_;
    114   base::WaitableEvent* wait_event_;
    115 };
    116 
    117 class RemoveVisitsTask : public history::HistoryDBTask {
    118  public:
    119   RemoveVisitsTask(const history::VisitVector& visits,
    120                    base::WaitableEvent* event)
    121       : visits_(visits), wait_event_(event) {}
    122 
    123   virtual bool RunOnDBThread(history::HistoryBackend* backend,
    124                              history::HistoryDatabase* db) OVERRIDE {
    125     // Fetch the visits.
    126     backend->RemoveVisits(visits_);
    127     wait_event_->Signal();
    128     return true;
    129   }
    130 
    131   virtual void DoneRunOnMainThread() OVERRIDE {}
    132 
    133  private:
    134   virtual ~RemoveVisitsTask() {}
    135 
    136   const history::VisitVector& visits_;
    137   base::WaitableEvent* wait_event_;
    138 };
    139 
    140 // Waits for the history DB thread to finish executing its current set of
    141 // tasks.
    142 void WaitForHistoryDBThread(int index) {
    143   CancelableRequestConsumer cancelable_consumer;
    144   HistoryService* service = HistoryServiceFactory::GetForProfileWithoutCreating(
    145       test()->GetProfile(index));
    146   base::WaitableEvent wait_event(true, false);
    147   service->ScheduleDBTask(new FlushHistoryDBQueueTask(&wait_event),
    148                           &cancelable_consumer);
    149   wait_event.Wait();
    150 }
    151 
    152 // Creates a URLRow in the specified HistoryService with the passed transition
    153 // type.
    154 void AddToHistory(HistoryService* service,
    155                   const GURL& url,
    156                   content::PageTransition transition,
    157                   history::VisitSource source,
    158                   const base::Time& timestamp) {
    159   service->AddPage(url,
    160                    timestamp,
    161                    NULL, // scope
    162                    1234, // page_id
    163                    GURL(),  // referrer
    164                    history::RedirectList(),
    165                    transition,
    166                    source,
    167                    false);
    168   service->SetPageTitle(url, ASCIIToUTF16(url.spec() + " - title"));
    169 }
    170 
    171 history::URLRows GetTypedUrlsFromHistoryService(HistoryService* service) {
    172   CancelableRequestConsumer cancelable_consumer;
    173   history::URLRows rows;
    174   base::WaitableEvent wait_event(true, false);
    175   service->ScheduleDBTask(new GetTypedUrlsTask(&rows, &wait_event),
    176                           &cancelable_consumer);
    177   wait_event.Wait();
    178   return rows;
    179 }
    180 
    181 bool GetUrlFromHistoryService(HistoryService* service,
    182                               const GURL& url, history::URLRow* row) {
    183   CancelableRequestConsumer cancelable_consumer;
    184   base::WaitableEvent wait_event(true, false);
    185   bool found;
    186   service->ScheduleDBTask(new GetUrlTask(url, row, &found, &wait_event),
    187                           &cancelable_consumer);
    188   wait_event.Wait();
    189   return found;
    190 }
    191 
    192 history::VisitVector GetVisitsFromHistoryService(HistoryService* service,
    193                                                  history::URLID id) {
    194   CancelableRequestConsumer cancelable_consumer;
    195   base::WaitableEvent wait_event(true, false);
    196   history::VisitVector visits;
    197   service->ScheduleDBTask(new GetVisitsTask(id, &visits, &wait_event),
    198                           &cancelable_consumer);
    199   wait_event.Wait();
    200   return visits;
    201 }
    202 
    203 void RemoveVisitsFromHistoryService(HistoryService* service,
    204                                     const history::VisitVector& visits) {
    205   CancelableRequestConsumer cancelable_consumer;
    206   base::WaitableEvent wait_event(true, false);
    207   service->ScheduleDBTask(new RemoveVisitsTask(visits, &wait_event),
    208                           &cancelable_consumer);
    209   wait_event.Wait();
    210 }
    211 
    212 static base::Time* timestamp = NULL;
    213 
    214 }  // namespace
    215 
    216 namespace typed_urls_helper {
    217 
    218 history::URLRows GetTypedUrlsFromClient(int index) {
    219   HistoryService* service = HistoryServiceFactory::GetForProfileWithoutCreating(
    220       test()->GetProfile(index));
    221   return GetTypedUrlsFromHistoryService(service);
    222 }
    223 
    224 bool GetUrlFromClient(int index, const GURL& url, history::URLRow* row) {
    225   HistoryService* service = HistoryServiceFactory::GetForProfileWithoutCreating(
    226       test()->GetProfile(index));
    227   return GetUrlFromHistoryService(service, url, row);
    228 }
    229 
    230 history::VisitVector GetVisitsFromClient(int index, history::URLID id) {
    231   HistoryService* service = HistoryServiceFactory::GetForProfileWithoutCreating(
    232       test()->GetProfile(index));
    233   return GetVisitsFromHistoryService(service, id);
    234 }
    235 
    236 void RemoveVisitsFromClient(int index, const history::VisitVector& visits) {
    237   HistoryService* service = HistoryServiceFactory::GetForProfileWithoutCreating(
    238       test()->GetProfile(index));
    239   RemoveVisitsFromHistoryService(service, visits);
    240 }
    241 
    242 base::Time GetTimestamp() {
    243   // The history subsystem doesn't like identical timestamps for page visits,
    244   // and it will massage the visit timestamps if we try to use identical
    245   // values, which can lead to spurious errors. So make sure all timestamps
    246   // are unique.
    247   if (!::timestamp)
    248     ::timestamp = new base::Time(base::Time::Now());
    249   base::Time original = *::timestamp;
    250   *::timestamp += base::TimeDelta::FromMilliseconds(1);
    251   return original;
    252 }
    253 
    254 void AddUrlToHistory(int index, const GURL& url) {
    255   AddUrlToHistoryWithTransition(index, url, content::PAGE_TRANSITION_TYPED,
    256                                 history::SOURCE_BROWSED);
    257 }
    258 void AddUrlToHistoryWithTransition(int index,
    259                                    const GURL& url,
    260                                    content::PageTransition transition,
    261                                    history::VisitSource source) {
    262   base::Time timestamp = GetTimestamp();
    263   AddUrlToHistoryWithTimestamp(index, url, transition, source, timestamp);
    264 }
    265 void AddUrlToHistoryWithTimestamp(int index,
    266                                   const GURL& url,
    267                                   content::PageTransition transition,
    268                                   history::VisitSource source,
    269                                   const base::Time& timestamp) {
    270   AddToHistory(HistoryServiceFactory::GetForProfileWithoutCreating(
    271                    test()->GetProfile(index)),
    272                url,
    273                transition,
    274                source,
    275                timestamp);
    276   if (test()->use_verifier())
    277     AddToHistory(
    278         HistoryServiceFactory::GetForProfile(test()->verifier(),
    279                                              Profile::IMPLICIT_ACCESS),
    280         url,
    281         transition,
    282         source,
    283         timestamp);
    284 
    285   // Wait until the AddPage() request has completed so we know the change has
    286   // filtered down to the sync observers (don't need to wait for the
    287   // verifier profile since it doesn't sync).
    288   WaitForHistoryDBThread(index);
    289 }
    290 
    291 void DeleteUrlFromHistory(int index, const GURL& url) {
    292   HistoryServiceFactory::GetForProfileWithoutCreating(
    293       test()->GetProfile(index))->DeleteURL(url);
    294   if (test()->use_verifier())
    295     HistoryServiceFactory::GetForProfile(test()->verifier(),
    296                                          Profile::IMPLICIT_ACCESS)->
    297         DeleteURL(url);
    298   WaitForHistoryDBThread(index);
    299 }
    300 
    301 void DeleteUrlsFromHistory(int index, const std::vector<GURL>& urls) {
    302   HistoryServiceFactory::GetForProfileWithoutCreating(
    303       test()->GetProfile(index))->DeleteURLsForTest(urls);
    304   if (test()->use_verifier())
    305     HistoryServiceFactory::GetForProfile(test()->verifier(),
    306                                          Profile::IMPLICIT_ACCESS)->
    307         DeleteURLsForTest(urls);
    308   WaitForHistoryDBThread(index);
    309 }
    310 
    311 void AssertURLRowVectorsAreEqual(const history::URLRows& left,
    312                                  const history::URLRows& right) {
    313   ASSERT_EQ(left.size(), right.size());
    314   for (size_t i = 0; i < left.size(); ++i) {
    315     // URLs could be out-of-order, so look for a matching URL in the second
    316     // array.
    317     bool found = false;
    318     for (size_t j = 0; j < right.size(); ++j) {
    319       if (left[i].url() == right[j].url()) {
    320         AssertURLRowsAreEqual(left[i], right[j]);
    321         found = true;
    322         break;
    323       }
    324     }
    325     ASSERT_TRUE(found);
    326   }
    327 }
    328 
    329 bool AreVisitsEqual(const history::VisitVector& visit1,
    330                     const history::VisitVector& visit2) {
    331   if (visit1.size() != visit2.size())
    332     return false;
    333   for (size_t i = 0; i < visit1.size(); ++i) {
    334     if (visit1[i].transition != visit2[i].transition)
    335       return false;
    336     if (visit1[i].visit_time != visit2[i].visit_time)
    337       return false;
    338   }
    339   return true;
    340 }
    341 
    342 bool AreVisitsUnique(const history::VisitVector& visits) {
    343   base::Time t = base::Time::FromInternalValue(0);
    344   for (size_t i = 0; i < visits.size(); ++i) {
    345     if (t == visits[i].visit_time)
    346       return false;
    347     t = visits[i].visit_time;
    348   }
    349   return true;
    350 }
    351 
    352 void AssertURLRowsAreEqual(
    353     const history::URLRow& left, const history::URLRow& right) {
    354   ASSERT_EQ(left.url(), right.url());
    355   ASSERT_EQ(left.title(), right.title());
    356   ASSERT_EQ(left.visit_count(), right.visit_count());
    357   ASSERT_EQ(left.typed_count(), right.typed_count());
    358   ASSERT_EQ(left.last_visit(), right.last_visit());
    359   ASSERT_EQ(left.hidden(), right.hidden());
    360 }
    361 
    362 void AssertAllProfilesHaveSameURLsAsVerifier() {
    363   HistoryService* verifier_service =
    364       HistoryServiceFactory::GetForProfile(test()->verifier(),
    365                                            Profile::IMPLICIT_ACCESS);
    366   history::URLRows verifier_urls =
    367       GetTypedUrlsFromHistoryService(verifier_service);
    368   for (int i = 0; i < test()->num_clients(); ++i) {
    369     history::URLRows urls = GetTypedUrlsFromClient(i);
    370     AssertURLRowVectorsAreEqual(verifier_urls, urls);
    371   }
    372 }
    373 
    374 }  // namespace typed_urls_helper
    375