src/chrome/browser/sync/test/integration/typed_urls_helper.cc

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