src/chrome/browser/history/android/android_provider_backend_unittest.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/history/android/android_provider_backend.h"
   6
   7 #include <vector>
   8
   9 #include "base/file_util.h"
  10 #include "base/files/file_path.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/strings/stringprintf.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  16 #include "chrome/browser/chrome_notification_types.h"
  17 #include "chrome/browser/favicon/favicon_changed_details.h"
  18 #include "chrome/browser/history/android/android_time.h"
  19 #include "chrome/browser/history/chrome_history_client.h"
  20 #include "chrome/browser/history/chrome_history_client_factory.h"
  21 #include "chrome/browser/history/history_backend.h"
  22 #include "chrome/browser/profiles/profile_manager.h"
  23 #include "chrome/common/chrome_constants.h"
  24 #include "chrome/test/base/testing_browser_process.h"
  25 #include "chrome/test/base/testing_profile.h"
  26 #include "chrome/test/base/testing_profile_manager.h"
  27 #include "components/bookmarks/browser/bookmark_model.h"
  28 #include "components/bookmarks/test/bookmark_test_helpers.h"
  29 #include "content/public/browser/browser_thread.h"
  30 #include "content/public/test/test_browser_thread.h"
  31 #include "content/public/test/test_utils.h"
  32 #include "testing/gtest/include/gtest/gtest.h"
  33
  34 using base::Time;
  35 using base::TimeDelta;
  36 using base::UTF8ToUTF16;
  37 using content::BrowserThread;
  38
  39 namespace history {
  40
  41 namespace {
  42
  43 struct BookmarkCacheRow {
  44  public:
  45   BookmarkCacheRow()
  46       : url_id_(0),
  47         bookmark_(false),
  48         favicon_id_(0) {
  49   }
  50   URLID url_id_;
  51   Time create_time_;
  52   Time last_visit_time_;
  53   bool bookmark_;
  54   favicon_base::FaviconID favicon_id_;
  55 };
  56
  57 }  // namespace
  58
  59 class AndroidProviderBackendDelegate : public HistoryBackend::Delegate {
  60  public:
  61   AndroidProviderBackendDelegate() {}
  62
  63   virtual void NotifyProfileError(sql::InitStatus init_status) OVERRIDE {}
  64   virtual void SetInMemoryBackend(
  65       scoped_ptr<InMemoryHistoryBackend> backend) OVERRIDE {}
  66   virtual void BroadcastNotifications(
  67       int type,
  68       scoped_ptr<HistoryDetails> details) OVERRIDE {
  69     switch (type) {
  70       case chrome::NOTIFICATION_HISTORY_URLS_DELETED:
  71         deleted_details_.reset(
  72             static_cast<URLsDeletedDetails*>(details.release()));
  73         break;
  74       case chrome::NOTIFICATION_FAVICON_CHANGED:
  75         favicon_details_.reset(
  76             static_cast<FaviconChangedDetails*>(details.release()));
  77         break;
  78       case chrome::NOTIFICATION_HISTORY_URLS_MODIFIED:
  79         modified_details_.reset(
  80             static_cast<URLsModifiedDetails*>(details.release()));
  81         break;
  82     }
  83   }
  84   virtual void DBLoaded() OVERRIDE {}
  85   virtual void NotifyVisitDBObserversOnAddVisit(
  86       const history::BriefVisitInfo& info) OVERRIDE {}
  87
  88   URLsDeletedDetails* deleted_details() const {
  89     return deleted_details_.get();
  90   }
  91
  92   URLsModifiedDetails* modified_details() const {
  93     return modified_details_.get();
  94   }
  95
  96   FaviconChangedDetails* favicon_details() const {
  97     return favicon_details_.get();
  98   }
  99
 100   void ResetDetails() {
 101     deleted_details_.reset();
 102     modified_details_.reset();
 103     favicon_details_.reset();
 104   }
 105
 106  private:
 107   scoped_ptr<URLsDeletedDetails> deleted_details_;
 108   scoped_ptr<URLsModifiedDetails> modified_details_;
 109   scoped_ptr<FaviconChangedDetails> favicon_details_;
 110
 111   DISALLOW_COPY_AND_ASSIGN(AndroidProviderBackendDelegate);
 112 };
 113
 114 class AndroidProviderBackendTest : public testing::Test {
 115  public:
 116   AndroidProviderBackendTest()
 117       : profile_manager_(
 118           TestingBrowserProcess::GetGlobal()),
 119         bookmark_model_(NULL),
 120         ui_thread_(BrowserThread::UI, &message_loop_),
 121         file_thread_(BrowserThread::FILE, &message_loop_) {
 122   }
 123   virtual ~AndroidProviderBackendTest() {}
 124
 125  protected:
 126   virtual void SetUp() OVERRIDE {
 127     // Setup the testing profile, so the bookmark_model_sql_handler could
 128     // get the bookmark model from it.
 129     ASSERT_TRUE(profile_manager_.SetUp());
 130     // It seems that the name has to be chrome::kInitialProfile, so it
 131     // could be found by ProfileManager::GetLastUsedProfile().
 132     TestingProfile* testing_profile = profile_manager_.CreateTestingProfile(
 133         chrome::kInitialProfile);
 134     testing_profile->CreateBookmarkModel(true);
 135     bookmark_model_ = BookmarkModelFactory::GetForProfile(testing_profile);
 136     history_client_ =
 137         ChromeHistoryClientFactory::GetForProfile(testing_profile);
 138     test::WaitForBookmarkModelToLoad(bookmark_model_);
 139     ASSERT_TRUE(bookmark_model_);
 140
 141     // Get the BookmarkModel from LastUsedProfile, this is the same way that
 142     // how the BookmarkModelSQLHandler gets the BookmarkModel.
 143     Profile* profile = ProfileManager::GetLastUsedProfile();
 144     ASSERT_TRUE(profile);
 145
 146     // Setup the database directory and files.
 147     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 148
 149     history_db_name_ = temp_dir_.path().AppendASCII(chrome::kHistoryFilename);
 150     thumbnail_db_name_ = temp_dir_.path().AppendASCII(
 151         chrome::kFaviconsFilename);
 152     android_cache_db_name_ = temp_dir_.path().AppendASCII(
 153         "TestAndroidCache.db");
 154   }
 155
 156   void AddBookmark(const GURL& url) {
 157     const BookmarkNode* mobile_node = bookmark_model_->mobile_node();
 158     ASSERT_TRUE(mobile_node);
 159     ASSERT_TRUE(bookmark_model_->AddURL(mobile_node, 0, base::string16(), url));
 160   }
 161
 162   bool GetAndroidURLsRows(std::vector<AndroidURLRow>* rows,
 163                           AndroidProviderBackend* backend) {
 164     sql::Statement statement(backend->db_->GetCachedStatement(SQL_FROM_HERE,
 165         "SELECT id, raw_url, url_id FROM android_urls ORDER BY url_id ASC"));
 166
 167     while (statement.Step()) {
 168       AndroidURLRow row;
 169       row.id = statement.ColumnInt64(0);
 170       row.raw_url = statement.ColumnString(1);
 171       row.url_id = statement.ColumnInt64(2);
 172       rows->push_back(row);
 173     }
 174     return true;
 175   }
 176
 177   bool GetBookmarkCacheRows(std::vector<BookmarkCacheRow>* rows,
 178                             AndroidProviderBackend* backend) {
 179     sql::Statement statement(backend->db_->GetCachedStatement(SQL_FROM_HERE,
 180         "SELECT created_time, last_visit_time, url_id, bookmark, favicon_id "
 181         "FROM android_cache_db.bookmark_cache ORDER BY url_id ASC"));
 182
 183     while (statement.Step()) {
 184       BookmarkCacheRow row;
 185       row.create_time_ = FromDatabaseTime(statement.ColumnInt64(0));
 186       row.last_visit_time_ = FromDatabaseTime(statement.ColumnInt64(1));
 187       row.url_id_ = statement.ColumnInt64(2);
 188       row.bookmark_ = statement.ColumnBool(3);
 189       row.favicon_id_ = statement.ColumnInt64(4);
 190       rows->push_back(row);
 191     }
 192     return true;
 193   }
 194
 195   AndroidProviderBackendDelegate delegate_;
 196   scoped_refptr<HistoryBackend> history_backend_;
 197   HistoryDatabase history_db_;
 198   ThumbnailDatabase thumbnail_db_;
 199   base::ScopedTempDir temp_dir_;
 200   base::FilePath android_cache_db_name_;
 201   base::FilePath history_db_name_;
 202   base::FilePath thumbnail_db_name_;
 203
 204   TestingProfileManager profile_manager_;
 205   BookmarkModel* bookmark_model_;
 206   base::MessageLoopForUI message_loop_;
 207   content::TestBrowserThread ui_thread_;
 208   content::TestBrowserThread file_thread_;
 209   ChromeHistoryClient* history_client_;
 210
 211   DISALLOW_COPY_AND_ASSIGN(AndroidProviderBackendTest);
 212 };
 213
 214 TEST_F(AndroidProviderBackendTest, UpdateTables) {
 215   GURL url1("http://www.cnn.com");
 216   URLID url_id1 = 0;
 217   std::vector<VisitInfo> visits1;
 218   Time last_visited1 = Time::Now() - TimeDelta::FromDays(1);
 219   Time created1 = last_visited1 - TimeDelta::FromDays(20);
 220   visits1.push_back(VisitInfo(created1, content::PAGE_TRANSITION_LINK));
 221   visits1.push_back(VisitInfo(last_visited1 - TimeDelta::FromDays(1),
 222                               content::PAGE_TRANSITION_LINK));
 223   visits1.push_back(VisitInfo(last_visited1, content::PAGE_TRANSITION_LINK));
 224
 225   GURL url2("http://www.example.com");
 226   URLID url_id2 = 0;
 227   std::vector<VisitInfo> visits2;
 228   Time last_visited2 = Time::Now();
 229   Time created2 = last_visited2 - TimeDelta::FromDays(10);
 230   visits2.push_back(VisitInfo(created2, content::PAGE_TRANSITION_LINK));
 231   visits2.push_back(VisitInfo(last_visited2 - TimeDelta::FromDays(5),
 232                               content::PAGE_TRANSITION_LINK));
 233   visits2.push_back(VisitInfo(last_visited2, content::PAGE_TRANSITION_LINK));
 234
 235   // Add a bookmark which is not in the history.
 236   GURL url3("http://www.bookmark.com");
 237   base::string16 title3(UTF8ToUTF16("bookmark"));
 238   ASSERT_TRUE(bookmark_model_->AddURL(bookmark_model_->bookmark_bar_node(), 0,
 239                                       title3, url3));
 240   // Only use the HistoryBackend to generate the test data.
 241   // HistoryBackend will shutdown after that.
 242   {
 243   scoped_refptr<HistoryBackend> history_backend;
 244   history_backend = new HistoryBackend(
 245       temp_dir_.path(), new AndroidProviderBackendDelegate(), history_client_);
 246   history_backend->Init(std::string(), false);
 247   history_backend->AddVisits(url1, visits1, history::SOURCE_SYNCED);
 248   history_backend->AddVisits(url2, visits2, history::SOURCE_SYNCED);
 249   URLRow url_row;
 250
 251   ASSERT_TRUE(history_backend->GetURL(url1, &url_row));
 252   url_id1 = url_row.id();
 253   ASSERT_TRUE(history_backend->GetURL(url2, &url_row));
 254   url_id2 = url_row.id();
 255
 256   // Set favicon to url2.
 257   std::vector<unsigned char> data;
 258   data.push_back('1');
 259   favicon_base::FaviconRawBitmapData bitmap_data_element;
 260   bitmap_data_element.bitmap_data = new base::RefCountedBytes(data);
 261   bitmap_data_element.pixel_size = gfx::Size();
 262   bitmap_data_element.icon_url = GURL();
 263   std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
 264   favicon_bitmap_data.push_back(bitmap_data_element);
 265
 266   history_backend->SetFavicons(
 267       url2, favicon_base::FAVICON, favicon_bitmap_data);
 268   history_backend->Closing();
 269   }
 270
 271   // The history_db_name and thumbnail_db_name files should be created by
 272   // HistoryBackend. We need to open the same database files.
 273   ASSERT_TRUE(base::PathExists(history_db_name_));
 274   ASSERT_TRUE(base::PathExists(thumbnail_db_name_));
 275
 276   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
 277   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
 278   // Set url1 as bookmark.
 279   AddBookmark(url1);
 280   scoped_ptr<AndroidProviderBackend> backend(
 281       new AndroidProviderBackend(android_cache_db_name_,
 282                                  &history_db_,
 283                                  &thumbnail_db_,
 284                                  history_client_,
 285                                  &delegate_));
 286
 287   ASSERT_TRUE(backend->EnsureInitializedAndUpdated());
 288
 289   // First verify that the bookmark which was not in the history has been added
 290   // to history database.
 291   URLRow url_row;
 292   ASSERT_TRUE(history_db_.GetRowForURL(url3, &url_row));
 293   URLID url_id3 = url_row.id();
 294   ASSERT_EQ(url3, url_row.url());
 295   ASSERT_EQ(title3, url_row.title());
 296
 297   std::vector<AndroidURLRow> android_url_rows;
 298   ASSERT_TRUE(GetAndroidURLsRows(&android_url_rows, backend.get()));
 299   ASSERT_EQ(3u, android_url_rows.size());
 300   std::vector<AndroidURLRow>::iterator i = android_url_rows.begin();
 301   EXPECT_EQ(url_id1, i->url_id);
 302   EXPECT_EQ(url1.spec(), i->raw_url);
 303   i++;
 304   EXPECT_EQ(url_id2, i->url_id);
 305   EXPECT_EQ(url2.spec(), i->raw_url);
 306   i++;
 307   EXPECT_EQ(url_id3, i->url_id);
 308   EXPECT_EQ(url3.spec(), i->raw_url);
 309
 310   std::vector<BookmarkCacheRow> bookmark_cache_rows;
 311   ASSERT_TRUE(GetBookmarkCacheRows(&bookmark_cache_rows, backend.get()));
 312   ASSERT_EQ(3u, bookmark_cache_rows.size());
 313   std::vector<BookmarkCacheRow>::const_iterator j = bookmark_cache_rows.begin();
 314   EXPECT_EQ(url_id1, j->url_id_);
 315   EXPECT_EQ(ToDatabaseTime(last_visited1), ToDatabaseTime(j->last_visit_time_));
 316   EXPECT_EQ(ToDatabaseTime(created1), ToDatabaseTime(j->create_time_));
 317   EXPECT_EQ(0, j->favicon_id_);
 318   EXPECT_TRUE(j->bookmark_);
 319   j++;
 320   EXPECT_EQ(url_id2, j->url_id_);
 321   EXPECT_EQ(ToDatabaseTime(last_visited2), ToDatabaseTime(j->last_visit_time_));
 322   EXPECT_EQ(ToDatabaseTime(created2), ToDatabaseTime(j->create_time_));
 323   EXPECT_NE(0, j->favicon_id_);
 324   EXPECT_FALSE(j->bookmark_);
 325
 326   // Delete url2 from database.
 327   ASSERT_TRUE(history_db_.DeleteURLRow(url_id2));
 328   VisitVector visit_rows;
 329   ASSERT_TRUE(history_db_.GetMostRecentVisitsForURL(url_id2, 10,
 330                                                     &visit_rows));
 331   ASSERT_EQ(3u, visit_rows.size());
 332   for (VisitVector::const_iterator v = visit_rows.begin();
 333        v != visit_rows.end(); v++)
 334     history_db_.DeleteVisit(*v);
 335
 336   backend->UpdateTables();
 337
 338   android_url_rows.clear();
 339   ASSERT_TRUE(GetAndroidURLsRows(&android_url_rows, backend.get()));
 340   ASSERT_EQ(2u, android_url_rows.size());
 341   i = android_url_rows.begin();
 342   EXPECT_EQ(url_id1, i->url_id);
 343   EXPECT_EQ(url1.spec(), i->raw_url);
 344   ++i;
 345   EXPECT_EQ(url_id3, i->url_id);
 346   EXPECT_EQ(url3.spec(), i->raw_url);
 347
 348   bookmark_cache_rows.clear();
 349   ASSERT_TRUE(GetBookmarkCacheRows(&bookmark_cache_rows, backend.get()));
 350   ASSERT_EQ(2u, bookmark_cache_rows.size());
 351   j = bookmark_cache_rows.begin();
 352   EXPECT_EQ(url_id1, j->url_id_);
 353   EXPECT_EQ(ToDatabaseTime(last_visited1), ToDatabaseTime(j->last_visit_time_));
 354   EXPECT_EQ(ToDatabaseTime(created1), ToDatabaseTime(j->create_time_));
 355   EXPECT_EQ(0, j->favicon_id_);
 356   EXPECT_TRUE(j->bookmark_);
 357   ++j;
 358   EXPECT_EQ(url_id3, j->url_id_);
 359   EXPECT_EQ(base::Time::UnixEpoch(), j->last_visit_time_);
 360   EXPECT_EQ(base::Time::UnixEpoch(), j->create_time_);
 361   EXPECT_EQ(0, j->favicon_id_);
 362   EXPECT_TRUE(j->bookmark_);
 363 }
 364
 365 TEST_F(AndroidProviderBackendTest, QueryHistoryAndBookmarks) {
 366   GURL url1("http://www.cnn.com");
 367   URLID url_id1 = 0;
 368   const base::string16 title1(UTF8ToUTF16("cnn"));
 369   std::vector<VisitInfo> visits1;
 370   Time last_visited1 = Time::Now() - TimeDelta::FromDays(1);
 371   Time created1 = last_visited1 - TimeDelta::FromDays(20);
 372   visits1.push_back(VisitInfo(created1, content::PAGE_TRANSITION_LINK));
 373   visits1.push_back(VisitInfo(last_visited1 - TimeDelta::FromDays(1),
 374                               content::PAGE_TRANSITION_LINK));
 375   visits1.push_back(VisitInfo(last_visited1, content::PAGE_TRANSITION_LINK));
 376
 377   GURL url2("http://www.example.com");
 378   URLID url_id2 = 0;
 379   std::vector<VisitInfo> visits2;
 380   const base::string16 title2(UTF8ToUTF16("example"));
 381   Time last_visited2 = Time::Now();
 382   Time created2 = last_visited2 - TimeDelta::FromDays(10);
 383   visits2.push_back(VisitInfo(created2, content::PAGE_TRANSITION_LINK));
 384   visits2.push_back(VisitInfo(last_visited2 - TimeDelta::FromDays(5),
 385                               content::PAGE_TRANSITION_LINK));
 386   visits2.push_back(VisitInfo(last_visited2, content::PAGE_TRANSITION_LINK));
 387
 388   // Only use the HistoryBackend to generate the test data.
 389   // HistoryBackend will shutdown after that.
 390   {
 391   scoped_refptr<HistoryBackend> history_backend;
 392   history_backend = new HistoryBackend(
 393       temp_dir_.path(), new AndroidProviderBackendDelegate(), history_client_);
 394   history_backend->Init(std::string(), false);
 395   history_backend->AddVisits(url1, visits1, history::SOURCE_SYNCED);
 396   history_backend->AddVisits(url2, visits2, history::SOURCE_SYNCED);
 397   URLRow url_row;
 398
 399   ASSERT_TRUE(history_backend->GetURL(url1, &url_row));
 400   url_id1 = url_row.id();
 401   url_row.set_title(title1);
 402   ASSERT_TRUE(history_backend->UpdateURL(url_id1, url_row));
 403
 404   ASSERT_TRUE(history_backend->GetURL(url2, &url_row));
 405   url_id2 = url_row.id();
 406   url_row.set_title(title2);
 407   ASSERT_TRUE(history_backend->UpdateURL(url_id2, url_row));
 408
 409   // Set favicon to url2.
 410   std::vector<unsigned char> data;
 411   data.push_back('1');
 412   favicon_base::FaviconRawBitmapData bitmap_data_element;
 413   bitmap_data_element.bitmap_data = new base::RefCountedBytes(data);
 414   bitmap_data_element.pixel_size = gfx::Size();
 415   bitmap_data_element.icon_url = GURL();
 416   std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
 417   favicon_bitmap_data.push_back(bitmap_data_element);
 418
 419   history_backend->SetFavicons(
 420       url2, favicon_base::FAVICON, favicon_bitmap_data);
 421   history_backend->Closing();
 422   }
 423
 424   // The history_db_name and thumbnail_db_name files should be created by
 425   // HistoryBackend. We need to open the same database files.
 426   ASSERT_TRUE(base::PathExists(history_db_name_));
 427   ASSERT_TRUE(base::PathExists(thumbnail_db_name_));
 428
 429   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
 430   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
 431   // Set url1 as bookmark.
 432   AddBookmark(url1);
 433
 434   scoped_ptr<AndroidProviderBackend> backend(
 435       new AndroidProviderBackend(android_cache_db_name_,
 436                                  &history_db_,
 437                                  &thumbnail_db_,
 438                                  history_client_,
 439                                  &delegate_));
 440
 441   std::vector<HistoryAndBookmarkRow::ColumnID> projections;
 442
 443   projections.push_back(HistoryAndBookmarkRow::ID);
 444   projections.push_back(HistoryAndBookmarkRow::URL);
 445   projections.push_back(HistoryAndBookmarkRow::TITLE);
 446   projections.push_back(HistoryAndBookmarkRow::CREATED);
 447   projections.push_back(HistoryAndBookmarkRow::LAST_VISIT_TIME);
 448   projections.push_back(HistoryAndBookmarkRow::VISIT_COUNT);
 449   projections.push_back(HistoryAndBookmarkRow::FAVICON);
 450   projections.push_back(HistoryAndBookmarkRow::BOOKMARK);
 451
 452   scoped_ptr<AndroidStatement> statement(backend->QueryHistoryAndBookmarks(
 453       projections, std::string(), std::vector<base::string16>(),
 454       std::string("url ASC")));
 455   ASSERT_TRUE(statement->statement()->Step());
 456   ASSERT_EQ(url1, GURL(statement->statement()->ColumnString(1)));
 457   EXPECT_EQ(title1, statement->statement()->ColumnString16(2));
 458   EXPECT_EQ(ToDatabaseTime(created1),
 459             statement->statement()->ColumnInt64(3));
 460   EXPECT_EQ(ToDatabaseTime(last_visited1),
 461             statement->statement()->ColumnInt64(4));
 462   EXPECT_EQ(3, statement->statement()->ColumnInt(5));
 463   EXPECT_EQ(6, statement->favicon_index());
 464   // No favicon.
 465   EXPECT_EQ(0, statement->statement()->ColumnByteLength(6));
 466   EXPECT_TRUE(statement->statement()->ColumnBool(7));
 467
 468   ASSERT_TRUE(statement->statement()->Step());
 469   EXPECT_EQ(title2, statement->statement()->ColumnString16(2));
 470   ASSERT_EQ(url2, GURL(statement->statement()->ColumnString(1)));
 471   EXPECT_EQ(ToDatabaseTime(created2),
 472             statement->statement()->ColumnInt64(3));
 473   EXPECT_EQ(ToDatabaseTime(last_visited2),
 474             statement->statement()->ColumnInt64(4));
 475   EXPECT_EQ(3, statement->statement()->ColumnInt(5));
 476   std::vector<unsigned char> favicon2;
 477   EXPECT_EQ(6, statement->favicon_index());
 478   // Has favicon.
 479   EXPECT_NE(0, statement->statement()->ColumnByteLength(6));
 480   EXPECT_FALSE(statement->statement()->ColumnBool(7));
 481
 482   // No more row.
 483   EXPECT_FALSE(statement->statement()->Step());
 484
 485   // Query by bookmark
 486   statement.reset(backend->QueryHistoryAndBookmarks(projections, "bookmark=1",
 487       std::vector<base::string16>(), std::string("url ASC")));
 488   // Only URL1 is returned.
 489   ASSERT_TRUE(statement->statement()->Step());
 490   ASSERT_EQ(url1, GURL(statement->statement()->ColumnString(1)));
 491   EXPECT_FALSE(statement->statement()->Step());
 492
 493   statement.reset(backend->QueryHistoryAndBookmarks(projections, "bookmark=0",
 494       std::vector<base::string16>(), std::string("url ASC")));
 495   // Only URL2 is returned.
 496   ASSERT_TRUE(statement->statement()->Step());
 497   ASSERT_EQ(url2, GURL(statement->statement()->ColumnString(1)));
 498   EXPECT_FALSE(statement->statement()->Step());
 499 }
 500
 501 TEST_F(AndroidProviderBackendTest, InsertHistoryAndBookmark) {
 502   HistoryAndBookmarkRow row1;
 503   row1.set_raw_url("cnn.com");
 504   row1.set_url(GURL("http://cnn.com"));
 505   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
 506   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
 507   row1.set_visit_count(10);
 508   row1.set_is_bookmark(true);
 509   row1.set_title(UTF8ToUTF16("cnn"));
 510
 511   HistoryAndBookmarkRow row2;
 512   row2.set_raw_url("http://www.example.com");
 513   row2.set_url(GURL("http://www.example.com"));
 514   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
 515   row2.set_is_bookmark(false);
 516   row2.set_title(UTF8ToUTF16("example"));
 517   std::vector<unsigned char> data;
 518   data.push_back('1');
 519   row2.set_favicon(base::RefCountedBytes::TakeVector(&data));
 520
 521   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
 522   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
 523   scoped_ptr<AndroidProviderBackend> backend(
 524       new AndroidProviderBackend(android_cache_db_name_,
 525                                  &history_db_,
 526                                  &thumbnail_db_,
 527                                  history_client_,
 528                                  &delegate_));
 529
 530   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row1));
 531   EXPECT_FALSE(delegate_.deleted_details());
 532   ASSERT_TRUE(delegate_.modified_details());
 533   ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
 534   EXPECT_EQ(row1.url(), delegate_.modified_details()->changed_urls[0].url());
 535   EXPECT_EQ(row1.last_visit_time(),
 536             delegate_.modified_details()->changed_urls[0].last_visit());
 537   EXPECT_EQ(row1.visit_count(),
 538             delegate_.modified_details()->changed_urls[0].visit_count());
 539   EXPECT_EQ(row1.title(),
 540             delegate_.modified_details()->changed_urls[0].title());
 541   EXPECT_FALSE(delegate_.favicon_details());
 542   content::RunAllPendingInMessageLoop();
 543   ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
 544   const BookmarkNode* child = bookmark_model_->mobile_node()->GetChild(0);
 545   ASSERT_TRUE(child);
 546   EXPECT_EQ(row1.title(), child->GetTitle());
 547   EXPECT_EQ(row1.url(), child->url());
 548
 549   delegate_.ResetDetails();
 550   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row2));
 551   EXPECT_FALSE(delegate_.deleted_details());
 552   ASSERT_TRUE(delegate_.modified_details());
 553   ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
 554   EXPECT_EQ(row2.url(), delegate_.modified_details()->changed_urls[0].url());
 555   EXPECT_EQ(row2.last_visit_time(),
 556             delegate_.modified_details()->changed_urls[0].last_visit());
 557   EXPECT_EQ(row2.title(),
 558             delegate_.modified_details()->changed_urls[0].title());
 559   ASSERT_TRUE(delegate_.favicon_details());
 560   ASSERT_EQ(1u, delegate_.favicon_details()->urls.size());
 561   ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
 562               delegate_.favicon_details()->urls.find(row2.url()));
 563
 564   std::vector<HistoryAndBookmarkRow::ColumnID> projections;
 565   projections.push_back(HistoryAndBookmarkRow::ID);
 566   projections.push_back(HistoryAndBookmarkRow::URL);
 567   projections.push_back(HistoryAndBookmarkRow::TITLE);
 568   projections.push_back(HistoryAndBookmarkRow::CREATED);
 569   projections.push_back(HistoryAndBookmarkRow::LAST_VISIT_TIME);
 570   projections.push_back(HistoryAndBookmarkRow::VISIT_COUNT);
 571   projections.push_back(HistoryAndBookmarkRow::FAVICON);
 572   projections.push_back(HistoryAndBookmarkRow::BOOKMARK);
 573
 574   scoped_ptr<AndroidStatement> statement(backend->QueryHistoryAndBookmarks(
 575       projections, std::string(), std::vector<base::string16>(),
 576       std::string("url ASC")));
 577   ASSERT_TRUE(statement->statement()->Step());
 578   ASSERT_EQ(row1.raw_url(), statement->statement()->ColumnString(1));
 579   EXPECT_EQ(row1.title(), statement->statement()->ColumnString16(2));
 580   EXPECT_EQ(ToDatabaseTime(row1.created()),
 581             statement->statement()->ColumnInt64(3));
 582   EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
 583             statement->statement()->ColumnInt64(4));
 584   EXPECT_EQ(row1.visit_count(), statement->statement()->ColumnInt(5));
 585   EXPECT_EQ(6, statement->favicon_index());
 586   // No favicon.
 587   EXPECT_EQ(0, statement->statement()->ColumnByteLength(6));
 588
 589   // TODO: Find a way to test the bookmark was added in BookmarkModel.
 590   // The bookmark was added in UI thread, there is no good way to test it.
 591   EXPECT_TRUE(statement->statement()->ColumnBool(7));
 592
 593   ASSERT_TRUE(statement->statement()->Step());
 594   EXPECT_EQ(row2.title(), statement->statement()->ColumnString16(2));
 595   EXPECT_EQ(row2.url(), GURL(statement->statement()->ColumnString(1)));
 596   EXPECT_EQ(ToDatabaseTime(row2.last_visit_time()),
 597             statement->statement()->ColumnInt64(3));
 598   EXPECT_EQ(ToDatabaseTime(row2.last_visit_time()),
 599             statement->statement()->ColumnInt64(4));
 600   EXPECT_EQ(1, statement->statement()->ColumnInt(5));
 601   EXPECT_EQ(6, statement->favicon_index());
 602   // Has favicon.
 603   EXPECT_NE(0, statement->statement()->ColumnByteLength(6));
 604   // TODO: Find a way to test the bookmark was added in BookmarkModel.
 605   // The bookmark was added in UI thread, there is no good way to test it.
 606   EXPECT_FALSE(statement->statement()->ColumnBool(7));
 607
 608   // No more row.
 609   EXPECT_FALSE(statement->statement()->Step());
 610 }
 611
 612 TEST_F(AndroidProviderBackendTest, DeleteHistoryAndBookmarks) {
 613   HistoryAndBookmarkRow row1;
 614   row1.set_raw_url("cnn.com");
 615   row1.set_url(GURL("http://cnn.com"));
 616   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
 617   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
 618   row1.set_visit_count(10);
 619   row1.set_is_bookmark(true);
 620   row1.set_title(UTF8ToUTF16("cnn"));
 621
 622   HistoryAndBookmarkRow row2;
 623   row2.set_raw_url("http://www.example.com");
 624   row2.set_url(GURL("http://www.example.com"));
 625   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
 626   row2.set_is_bookmark(false);
 627   row2.set_title(UTF8ToUTF16("example"));
 628   std::vector<unsigned char> data;
 629   data.push_back('1');
 630   row2.set_favicon(base::RefCountedBytes::TakeVector(&data));
 631
 632   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
 633   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
 634
 635   scoped_ptr<AndroidProviderBackend> backend(
 636       new AndroidProviderBackend(android_cache_db_name_,
 637                                  &history_db_,
 638                                  &thumbnail_db_,
 639                                  history_client_,
 640                                  &delegate_));
 641
 642   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row1));
 643   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row2));
 644   // Verify the row1 has been added in bookmark model.
 645   content::RunAllPendingInMessageLoop();
 646   ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
 647   const BookmarkNode* child = bookmark_model_->mobile_node()->GetChild(0);
 648   ASSERT_TRUE(child);
 649   EXPECT_EQ(row1.title(), child->GetTitle());
 650   EXPECT_EQ(row1.url(), child->url());
 651
 652   // Delete the row1.
 653   std::vector<base::string16> args;
 654   int deleted_count = 0;
 655   delegate_.ResetDetails();
 656   ASSERT_TRUE(backend->DeleteHistoryAndBookmarks("Favicon IS NULL", args,
 657                                                  &deleted_count));
 658   EXPECT_EQ(1, deleted_count);
 659   // Verify the row1 was removed from bookmark model.
 660   content::RunAllPendingInMessageLoop();
 661   ASSERT_EQ(0, bookmark_model_->mobile_node()->child_count());
 662
 663   // Verify notifications
 664   ASSERT_TRUE(delegate_.deleted_details());
 665   EXPECT_FALSE(delegate_.modified_details());
 666   EXPECT_EQ(1u, delegate_.deleted_details()->rows.size());
 667   EXPECT_EQ(row1.url(), delegate_.deleted_details()->rows[0].url());
 668   EXPECT_EQ(row1.last_visit_time(),
 669             delegate_.deleted_details()->rows[0].last_visit());
 670   EXPECT_EQ(row1.title(),
 671             delegate_.deleted_details()->rows[0].title());
 672   EXPECT_FALSE(delegate_.favicon_details());
 673
 674   std::vector<HistoryAndBookmarkRow::ColumnID> projections;
 675   projections.push_back(HistoryAndBookmarkRow::ID);
 676   projections.push_back(HistoryAndBookmarkRow::URL);
 677   projections.push_back(HistoryAndBookmarkRow::TITLE);
 678   projections.push_back(HistoryAndBookmarkRow::CREATED);
 679   projections.push_back(HistoryAndBookmarkRow::LAST_VISIT_TIME);
 680   projections.push_back(HistoryAndBookmarkRow::VISIT_COUNT);
 681   projections.push_back(HistoryAndBookmarkRow::FAVICON);
 682   projections.push_back(HistoryAndBookmarkRow::BOOKMARK);
 683
 684   scoped_ptr<AndroidStatement> statement(backend->QueryHistoryAndBookmarks(
 685       projections, std::string(), std::vector<base::string16>(),
 686       std::string("url ASC")));
 687   ASSERT_TRUE(statement->statement()->Step());
 688
 689   EXPECT_EQ(row2.title(), statement->statement()->ColumnString16(2));
 690   EXPECT_EQ(row2.url(), GURL(statement->statement()->ColumnString(1)));
 691   EXPECT_EQ(ToDatabaseTime(row2.last_visit_time()),
 692             statement->statement()->ColumnInt64(3));
 693   EXPECT_EQ(ToDatabaseTime(row2.last_visit_time()),
 694             statement->statement()->ColumnInt64(4));
 695   EXPECT_EQ(1, statement->statement()->ColumnInt(5));
 696   EXPECT_EQ(6, statement->favicon_index());
 697   // Has favicon.
 698   EXPECT_NE(0, statement->statement()->ColumnByteLength(6));
 699   // TODO: Find a way to test the bookmark was added in BookmarkModel.
 700   // The bookmark was added in UI thread, there is no good way to test it.
 701   EXPECT_FALSE(statement->statement()->ColumnBool(7));
 702   // No more row.
 703   EXPECT_FALSE(statement->statement()->Step());
 704
 705   deleted_count = 0;
 706   // Delete row2.
 707   delegate_.ResetDetails();
 708   ASSERT_TRUE(backend->DeleteHistoryAndBookmarks("bookmark = 0",
 709                   std::vector<base::string16>(), &deleted_count));
 710   // Verify notifications
 711   ASSERT_TRUE(delegate_.deleted_details());
 712   EXPECT_FALSE(delegate_.modified_details());
 713   EXPECT_EQ(1u, delegate_.deleted_details()->rows.size());
 714   EXPECT_EQ(row2.url(), delegate_.deleted_details()->rows[0].url());
 715   EXPECT_EQ(row2.last_visit_time(),
 716             delegate_.deleted_details()->rows[0].last_visit());
 717   EXPECT_EQ(row2.title(),
 718             delegate_.deleted_details()->rows[0].title());
 719   ASSERT_TRUE(delegate_.favicon_details());
 720   ASSERT_EQ(1u, delegate_.favicon_details()->urls.size());
 721   ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
 722               delegate_.favicon_details()->urls.find(row2.url()));
 723
 724   ASSERT_EQ(1, deleted_count);
 725   scoped_ptr<AndroidStatement> statement1(backend->QueryHistoryAndBookmarks(
 726       projections, std::string(), std::vector<base::string16>(),
 727       std::string("url ASC")));
 728   ASSERT_FALSE(statement1->statement()->Step());
 729 }
 730
 731 TEST_F(AndroidProviderBackendTest, IsValidHistoryAndBookmarkRow) {
 732   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
 733   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
 734   scoped_ptr<AndroidProviderBackend> backend(
 735       new AndroidProviderBackend(android_cache_db_name_,
 736                                  &history_db_,
 737                                  &thumbnail_db_,
 738                                  history_client_,
 739                                  &delegate_));
 740
 741   // The created time and last visit time are too close to have required visit
 742   // count.
 743   HistoryAndBookmarkRow row1;
 744   row1.set_raw_url("cnn.com");
 745   row1.set_url(GURL("http://cnn.com"));
 746   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
 747   row1.set_created(Time::FromInternalValue(
 748       row1.last_visit_time().ToInternalValue() - 1));
 749   row1.set_visit_count(10);
 750   row1.set_is_bookmark(true);
 751   row1.set_title(UTF8ToUTF16("cnn"));
 752   EXPECT_FALSE(backend->InsertHistoryAndBookmark(row1));
 753
 754   // Have different created time and last visit time, but only have 1 visit
 755   // count.
 756   HistoryAndBookmarkRow row2;
 757   row2.set_raw_url("http://www.example.com");
 758   row2.set_url(GURL("http://www.example.com"));
 759   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
 760   row2.set_created(Time::Now() - TimeDelta::FromDays(11));
 761   row2.set_visit_count(1);
 762   EXPECT_FALSE(backend->InsertHistoryAndBookmark(row2));
 763
 764   // Have created time in the future.
 765   HistoryAndBookmarkRow row3;
 766   row3.set_raw_url("http://www.example.com");
 767   row3.set_url(GURL("http://www.example.com"));
 768   row3.set_created(Time::Now() + TimeDelta::FromDays(11));
 769   EXPECT_FALSE(backend->InsertHistoryAndBookmark(row3));
 770
 771   // Have last vist time in the future.
 772   HistoryAndBookmarkRow row4;
 773   row4.set_raw_url("http://www.example.com");
 774   row4.set_url(GURL("http://www.example.com"));
 775   row4.set_last_visit_time(Time::Now() + TimeDelta::FromDays(11));
 776   EXPECT_FALSE(backend->InsertHistoryAndBookmark(row4));
 777
 778   // Created time is larger than last visit time.
 779   HistoryAndBookmarkRow row5;
 780   row5.set_raw_url("http://www.example.com");
 781   row5.set_url(GURL("http://www.example.com"));
 782   row5.set_last_visit_time(Time::Now());
 783   row5.set_created(Time::Now() + TimeDelta::FromDays(11));
 784   EXPECT_FALSE(backend->InsertHistoryAndBookmark(row5));
 785
 786   // Visit count is zero, and last visit time is not zero.
 787   HistoryAndBookmarkRow row6;
 788   row6.set_raw_url("http://www.example.com");
 789   row6.set_url(GURL("http://www.example.com"));
 790   row6.set_visit_count(0);
 791   row6.set_last_visit_time(Time::Now());
 792   row6.set_created(Time::Now() - TimeDelta::FromDays(1));
 793   EXPECT_FALSE(backend->InsertHistoryAndBookmark(row6));
 794
 795   // Visit count is zero, and create time is not zero.
 796   HistoryAndBookmarkRow row7;
 797   row7.set_raw_url("http://www.example.com");
 798   row7.set_url(GURL("http://www.example.com"));
 799   row7.set_visit_count(0);
 800   row7.set_last_visit_time(Time::Now());
 801   row7.set_created(Time::UnixEpoch());
 802   EXPECT_TRUE(backend->InsertHistoryAndBookmark(row7));
 803 }
 804
 805 TEST_F(AndroidProviderBackendTest, UpdateURL) {
 806   HistoryAndBookmarkRow row1;
 807   row1.set_raw_url("cnn.com");
 808   row1.set_url(GURL("http://cnn.com"));
 809   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
 810   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
 811   row1.set_visit_count(10);
 812   row1.set_is_bookmark(true);
 813   row1.set_title(UTF8ToUTF16("cnn"));
 814
 815   HistoryAndBookmarkRow row2;
 816   row2.set_raw_url("http://www.example.com");
 817   row2.set_url(GURL("http://www.example.com"));
 818   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
 819   row2.set_is_bookmark(false);
 820   row2.set_title(UTF8ToUTF16("example"));
 821   std::vector<unsigned char> data;
 822   data.push_back('1');
 823   row2.set_favicon(base::RefCountedBytes::TakeVector(&data));
 824
 825   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
 826   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
 827   scoped_ptr<AndroidProviderBackend> backend(
 828       new AndroidProviderBackend(android_cache_db_name_,
 829                                  &history_db_,
 830                                  &thumbnail_db_,
 831                                  history_client_,
 832                                  &delegate_));
 833
 834   AndroidURLID id1 = backend->InsertHistoryAndBookmark(row1);
 835   ASSERT_TRUE(id1);
 836   AndroidURLID id2 = backend->InsertHistoryAndBookmark(row2);
 837   ASSERT_TRUE(id2);
 838
 839   // Verify the row1 has been added in bookmark model.
 840   content::RunAllPendingInMessageLoop();
 841   ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
 842   const BookmarkNode* child = bookmark_model_->mobile_node()->GetChild(0);
 843   ASSERT_TRUE(child);
 844   EXPECT_EQ(row1.title(), child->GetTitle());
 845   EXPECT_EQ(row1.url(), child->url());
 846
 847   // Make sure the url has correctly insertted.
 848   URLID url_id1 = history_db_.GetRowForURL(row1.url(), NULL);
 849   ASSERT_TRUE(url_id1);
 850   URLID url_id2 = history_db_.GetRowForURL(row2.url(), NULL);
 851   ASSERT_TRUE(url_id2);
 852
 853   // Make sure we have the correct visit rows in visit table.
 854   VisitVector visits;
 855   ASSERT_TRUE(history_db_.GetVisitsForURL(url_id1, &visits));
 856   ASSERT_EQ(10u, visits.size());
 857   visits.clear();
 858   ASSERT_TRUE(history_db_.GetVisitsForURL(url_id2, &visits));
 859   ASSERT_EQ(1u, visits.size());
 860
 861   int update_count;
 862   std::vector<base::string16> update_args;
 863   // Try to update the mutiple rows with the same URL, this should failed.
 864   HistoryAndBookmarkRow update_row1;
 865   update_row1.set_raw_url("newwebiste.com");
 866   update_row1.set_url(GURL("http://newwebsite.com"));
 867   update_args.clear();
 868   ASSERT_FALSE(backend->UpdateHistoryAndBookmarks(update_row1, std::string(),
 869                                                   update_args, &update_count));
 870
 871   // Only update one URL.
 872   update_args.clear();
 873   update_args.push_back(UTF8ToUTF16(row1.raw_url()));
 874   delegate_.ResetDetails();
 875   ASSERT_TRUE(backend->UpdateHistoryAndBookmarks(update_row1, "url = ?",
 876                                                  update_args, &update_count));
 877   // Verify notifications, Update involves insert and delete URLS.
 878   ASSERT_TRUE(delegate_.deleted_details());
 879   EXPECT_EQ(1u, delegate_.deleted_details()->rows.size());
 880   EXPECT_EQ(row1.url(), delegate_.deleted_details()->rows[0].url());
 881   EXPECT_EQ(row1.last_visit_time(),
 882             delegate_.deleted_details()->rows[0].last_visit());
 883   EXPECT_EQ(row1.title(),
 884             delegate_.deleted_details()->rows[0].title());
 885   ASSERT_TRUE(delegate_.modified_details());
 886   ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
 887   EXPECT_EQ(update_row1.url(),
 888             delegate_.modified_details()->changed_urls[0].url());
 889   EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
 890             ToDatabaseTime(
 891                 delegate_.modified_details()->changed_urls[0].last_visit()));
 892   EXPECT_EQ(row1.title(),
 893             delegate_.modified_details()->changed_urls[0].title());
 894   EXPECT_FALSE(delegate_.favicon_details());
 895
 896   EXPECT_EQ(1, update_count);
 897   // We shouldn't find orignal url anymore.
 898   EXPECT_FALSE(history_db_.GetRowForURL(row1.url(), NULL));
 899   visits.clear();
 900   EXPECT_TRUE(history_db_.GetVisitsForURL(url_id1, &visits));
 901   EXPECT_EQ(0u, visits.size());
 902   // Verify new URL.
 903   URLRow new_row;
 904   EXPECT_TRUE(history_db_.GetRowForURL(update_row1.url(), &new_row));
 905   EXPECT_EQ(10, new_row.visit_count());
 906   EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
 907             ToDatabaseTime(new_row.last_visit()));
 908   visits.clear();
 909   EXPECT_TRUE(history_db_.GetVisitsForURL(new_row.id(), &visits));
 910   EXPECT_EQ(10u, visits.size());
 911   AndroidURLRow android_url_row1;
 912   ASSERT_TRUE(history_db_.GetAndroidURLRow(new_row.id(), &android_url_row1));
 913   // Android URL ID shouldn't change.
 914   EXPECT_EQ(id1, android_url_row1.id);
 915
 916   // Verify the bookmark model was updated.
 917   content::RunAllPendingInMessageLoop();
 918   ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
 919   const BookmarkNode* child1 = bookmark_model_->mobile_node()->GetChild(0);
 920   ASSERT_TRUE(child1);
 921   EXPECT_EQ(row1.title(), child1->GetTitle());
 922   EXPECT_EQ(update_row1.url(), child1->url());
 923
 924   // Update the URL with visit count, created time, and last visit time.
 925   HistoryAndBookmarkRow update_row2;
 926   update_row2.set_raw_url("somethingelse.com");
 927   update_row2.set_url(GURL("http://somethingelse.com"));
 928   update_row2.set_last_visit_time(Time::Now());
 929   update_row2.set_created(Time::Now() - TimeDelta::FromDays(20));
 930   update_row2.set_visit_count(10);
 931
 932   update_args.clear();
 933   update_args.push_back(UTF8ToUTF16(row2.raw_url()));
 934   delegate_.ResetDetails();
 935   ASSERT_TRUE(backend->UpdateHistoryAndBookmarks(update_row2, "url = ?",
 936                                                  update_args, &update_count));
 937   // Verify notifications, Update involves insert and delete URLS.
 938   ASSERT_TRUE(delegate_.deleted_details());
 939   EXPECT_EQ(1u, delegate_.deleted_details()->rows.size());
 940   EXPECT_EQ(row2.url(), delegate_.deleted_details()->rows[0].url());
 941   EXPECT_EQ(row2.last_visit_time(),
 942             delegate_.deleted_details()->rows[0].last_visit());
 943   EXPECT_EQ(row2.title(),
 944             delegate_.deleted_details()->rows[0].title());
 945   ASSERT_TRUE(delegate_.modified_details());
 946   ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
 947   EXPECT_EQ(update_row2.url(),
 948             delegate_.modified_details()->changed_urls[0].url());
 949   EXPECT_EQ(ToDatabaseTime(update_row2.last_visit_time()),
 950             ToDatabaseTime(
 951                 delegate_.modified_details()->changed_urls[0].last_visit()));
 952   EXPECT_EQ(update_row2.visit_count(),
 953             delegate_.modified_details()->changed_urls[0].visit_count());
 954   ASSERT_TRUE(delegate_.favicon_details());
 955   ASSERT_EQ(2u, delegate_.favicon_details()->urls.size());
 956   ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
 957               delegate_.favicon_details()->urls.find(row2.url()));
 958   ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
 959               delegate_.favicon_details()->urls.find(update_row2.url()));
 960
 961   EXPECT_EQ(1, update_count);
 962   // We shouldn't find orignal url anymore.
 963   EXPECT_FALSE(history_db_.GetRowForURL(row2.url(), NULL));
 964   visits.clear();
 965   EXPECT_TRUE(history_db_.GetVisitsForURL(url_id2, &visits));
 966   EXPECT_EQ(0u, visits.size());
 967
 968   // Verify new URL.
 969   URLRow new_row2;
 970   ASSERT_TRUE(history_db_.GetRowForURL(update_row2.url(), &new_row2));
 971   EXPECT_EQ(10, new_row2.visit_count());
 972   EXPECT_EQ(update_row2.last_visit_time(), new_row2.last_visit());
 973   visits.clear();
 974   EXPECT_TRUE(history_db_.GetVisitsForURL(new_row2.id(), &visits));
 975   EXPECT_EQ(10u, visits.size());
 976   AndroidURLRow android_url_row2;
 977   ASSERT_TRUE(history_db_.GetAndroidURLRow(new_row2.id(), &android_url_row2));
 978   // Android URL ID shouldn't change.
 979   EXPECT_EQ(id2, android_url_row2.id);
 980
 981   ASSERT_TRUE(history_db_.GetVisitsForURL(new_row2.id(), &visits));
 982   ASSERT_EQ(10u, visits.size());
 983   EXPECT_EQ(update_row2.created(), visits[0].visit_time);
 984   EXPECT_EQ(update_row2.last_visit_time(), visits[9].visit_time);
 985 }
 986
 987 TEST_F(AndroidProviderBackendTest, UpdateVisitCount) {
 988   HistoryAndBookmarkRow row1;
 989   row1.set_raw_url("cnn.com");
 990   row1.set_url(GURL("http://cnn.com"));
 991   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
 992   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
 993   row1.set_visit_count(10);
 994   row1.set_is_bookmark(true);
 995   row1.set_title(UTF8ToUTF16("cnn"));
 996
 997   HistoryAndBookmarkRow row2;
 998   row2.set_raw_url("http://www.example.com");
 999   row2.set_url(GURL("http://www.example.com"));
1000   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
1001   row2.set_is_bookmark(false);
1002   row2.set_title(UTF8ToUTF16("example"));
1003   std::vector<unsigned char> data;
1004   data.push_back('1');
1005   row2.set_favicon(base::RefCountedBytes::TakeVector(&data));
1006
1007   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1008   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1009   scoped_ptr<AndroidProviderBackend> backend(
1010       new AndroidProviderBackend(android_cache_db_name_,
1011                                  &history_db_,
1012                                  &thumbnail_db_,
1013                                  history_client_,
1014                                  &delegate_));
1015
1016   AndroidURLID id1 = backend->InsertHistoryAndBookmark(row1);
1017   ASSERT_TRUE(id1);
1018   AndroidURLID id2 = backend->InsertHistoryAndBookmark(row2);
1019   ASSERT_TRUE(id2);
1020
1021   int update_count;
1022   std::vector<base::string16> update_args;
1023   // Update the visit_count to a value less than current one.
1024   HistoryAndBookmarkRow update_row1;
1025   update_row1.set_visit_count(5);
1026   update_args.push_back(UTF8ToUTF16(row1.raw_url()));
1027   delegate_.ResetDetails();
1028   ASSERT_TRUE(backend->UpdateHistoryAndBookmarks(update_row1, "url = ?",
1029                                                  update_args, &update_count));
1030   // Verify notifications, Update involves modified URL.
1031   EXPECT_FALSE(delegate_.deleted_details());
1032   ASSERT_TRUE(delegate_.modified_details());
1033   ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
1034   EXPECT_EQ(row1.url(),
1035             delegate_.modified_details()->changed_urls[0].url());
1036   EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
1037             ToDatabaseTime(
1038                 delegate_.modified_details()->changed_urls[0].last_visit()));
1039   EXPECT_EQ(update_row1.visit_count(),
1040             delegate_.modified_details()->changed_urls[0].visit_count());
1041   EXPECT_FALSE(delegate_.favicon_details());
1042
1043   // All visits should be removed, and 5 new visit insertted.
1044   URLRow new_row1;
1045   ASSERT_TRUE(history_db_.GetRowForURL(row1.url(), &new_row1));
1046   EXPECT_EQ(5, new_row1.visit_count());
1047   VisitVector visits;
1048   ASSERT_TRUE(history_db_.GetVisitsForURL(new_row1.id(), &visits));
1049   ASSERT_EQ(5u, visits.size());
1050   EXPECT_EQ(row1.last_visit_time(), visits[4].visit_time);
1051   EXPECT_GT(row1.last_visit_time(), visits[0].visit_time);
1052
1053   // Update the visit_count to a value equal to current one.
1054   HistoryAndBookmarkRow update_row2;
1055   update_row2.set_visit_count(1);
1056   update_args.clear();
1057   update_args.push_back(UTF8ToUTF16(row2.raw_url()));
1058   ASSERT_TRUE(backend->UpdateHistoryAndBookmarks(update_row2, "url = ?",
1059                                                  update_args, &update_count));
1060   // All shouldn't have any change.
1061   URLRow new_row2;
1062   ASSERT_TRUE(history_db_.GetRowForURL(row2.url(), &new_row2));
1063   EXPECT_EQ(1, new_row2.visit_count());
1064
1065   ASSERT_TRUE(history_db_.GetVisitsForURL(new_row2.id(), &visits));
1066   ASSERT_EQ(1u, visits.size());
1067   EXPECT_EQ(row2.last_visit_time(), visits[0].visit_time);
1068 }
1069
1070 TEST_F(AndroidProviderBackendTest, UpdateLastVisitTime) {
1071   HistoryAndBookmarkRow row1;
1072   row1.set_raw_url("cnn.com");
1073   row1.set_url(GURL("http://cnn.com"));
1074   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1075   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
1076   row1.set_visit_count(10);
1077   row1.set_is_bookmark(true);
1078   row1.set_title(UTF8ToUTF16("cnn"));
1079
1080   HistoryAndBookmarkRow row2;
1081   row2.set_raw_url("http://www.example.com");
1082   row2.set_url(GURL("http://www.example.com"));
1083   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
1084   row2.set_is_bookmark(false);
1085   row2.set_title(UTF8ToUTF16("example"));
1086   std::vector<unsigned char> data;
1087   data.push_back('1');
1088   row2.set_favicon(base::RefCountedBytes::TakeVector(&data));
1089
1090   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1091   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1092   scoped_ptr<AndroidProviderBackend> backend(
1093       new AndroidProviderBackend(android_cache_db_name_,
1094                                  &history_db_,
1095                                  &thumbnail_db_,
1096                                  history_client_,
1097                                  &delegate_));
1098
1099   AndroidURLID id1 = backend->InsertHistoryAndBookmark(row1);
1100   ASSERT_TRUE(id1);
1101   AndroidURLID id2 = backend->InsertHistoryAndBookmark(row2);
1102   ASSERT_TRUE(id2);
1103
1104   int update_count;
1105   std::vector<base::string16> update_args;
1106   // Update the last visit time to a value greater than current one.
1107   HistoryAndBookmarkRow update_row1;
1108   update_row1.set_last_visit_time(Time::Now());
1109   update_args.push_back(UTF8ToUTF16(row1.raw_url()));
1110   delegate_.ResetDetails();
1111   ASSERT_TRUE(backend->UpdateHistoryAndBookmarks(update_row1, "url = ?",
1112                                                  update_args, &update_count));
1113   // Verify notifications, Update involves modified URL.
1114   EXPECT_FALSE(delegate_.deleted_details());
1115   ASSERT_TRUE(delegate_.modified_details());
1116   ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
1117   EXPECT_EQ(row1.url(),
1118             delegate_.modified_details()->changed_urls[0].url());
1119   EXPECT_EQ(ToDatabaseTime(update_row1.last_visit_time()),
1120             ToDatabaseTime(
1121                 delegate_.modified_details()->changed_urls[0].last_visit()));
1122   EXPECT_FALSE(delegate_.favicon_details());
1123
1124   URLRow new_row1;
1125   ASSERT_TRUE(history_db_.GetRowForURL(row1.url(), &new_row1));
1126   EXPECT_EQ(11, new_row1.visit_count());
1127   EXPECT_EQ(update_row1.last_visit_time(), new_row1.last_visit());
1128   VisitVector visits;
1129   ASSERT_TRUE(history_db_.GetVisitsForURL(new_row1.id(), &visits));
1130   // 1 new visit insertted.
1131   ASSERT_EQ(11u, visits.size());
1132   EXPECT_EQ(update_row1.last_visit_time(), visits[10].visit_time);
1133   EXPECT_EQ(row1.last_visit_time(), visits[9].visit_time);
1134
1135   // Update the visit_tim to a value less than to current one.
1136   HistoryAndBookmarkRow update_row2;
1137   update_row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1138   update_args.clear();
1139   update_args.push_back(UTF8ToUTF16(row1.raw_url()));
1140   ASSERT_FALSE(backend->UpdateHistoryAndBookmarks(update_row2, "url = ?",
1141                                                   update_args, &update_count));
1142 }
1143
1144 TEST_F(AndroidProviderBackendTest, UpdateFavicon) {
1145   HistoryAndBookmarkRow row1;
1146   row1.set_raw_url("cnn.com");
1147   row1.set_url(GURL("http://cnn.com"));
1148   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1149   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
1150   row1.set_visit_count(10);
1151   row1.set_is_bookmark(true);
1152   row1.set_title(UTF8ToUTF16("cnn"));
1153
1154   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1155   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1156   scoped_ptr<AndroidProviderBackend> backend(
1157       new AndroidProviderBackend(android_cache_db_name_,
1158                                  &history_db_,
1159                                  &thumbnail_db_,
1160                                  history_client_,
1161                                  &delegate_));
1162
1163   AndroidURLID id1 = backend->InsertHistoryAndBookmark(row1);
1164   ASSERT_TRUE(id1);
1165
1166   int update_count;
1167   std::vector<base::string16> update_args;
1168   // Update the last visit time to a value greater than current one.
1169   HistoryAndBookmarkRow update_row1;
1170
1171   // Set favicon.
1172   std::vector<unsigned char> data;
1173   data.push_back('1');
1174   update_row1.set_favicon(base::RefCountedBytes::TakeVector(&data));
1175   update_args.push_back(UTF8ToUTF16(row1.raw_url()));
1176   delegate_.ResetDetails();
1177   ASSERT_TRUE(backend->UpdateHistoryAndBookmarks(update_row1, "url = ?",
1178                                                  update_args, &update_count));
1179   // Verify notifications.
1180   EXPECT_FALSE(delegate_.deleted_details());
1181   EXPECT_FALSE(delegate_.modified_details());
1182   ASSERT_TRUE(delegate_.favicon_details());
1183   ASSERT_EQ(1u, delegate_.favicon_details()->urls.size());
1184   ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
1185               delegate_.favicon_details()->urls.find(row1.url()));
1186
1187   std::vector<IconMapping> icon_mappings;
1188   EXPECT_TRUE(thumbnail_db_.GetIconMappingsForPageURL(
1189       row1.url(), favicon_base::FAVICON, &icon_mappings));
1190   EXPECT_EQ(1u, icon_mappings.size());
1191   std::vector<FaviconBitmap> favicon_bitmaps;
1192   EXPECT_TRUE(thumbnail_db_.GetFaviconBitmaps(icon_mappings[0].icon_id,
1193                                               &favicon_bitmaps));
1194   EXPECT_EQ(1u, favicon_bitmaps.size());
1195   EXPECT_TRUE(favicon_bitmaps[0].bitmap_data.get());
1196   EXPECT_EQ(1u, favicon_bitmaps[0].bitmap_data->size());
1197   EXPECT_EQ('1', *favicon_bitmaps[0].bitmap_data->front());
1198
1199   // Remove favicon.
1200   HistoryAndBookmarkRow update_row2;
1201
1202   // Set favicon.
1203   update_row1.set_favicon(new base::RefCountedBytes());
1204   update_args.clear();
1205   update_args.push_back(UTF8ToUTF16(row1.raw_url()));
1206   delegate_.ResetDetails();
1207   ASSERT_TRUE(backend->UpdateHistoryAndBookmarks(update_row1, "url = ?",
1208                                                  update_args, &update_count));
1209   // Verify notifications.
1210   EXPECT_FALSE(delegate_.deleted_details());
1211   EXPECT_FALSE(delegate_.modified_details());
1212   ASSERT_TRUE(delegate_.favicon_details());
1213   ASSERT_EQ(1u, delegate_.favicon_details()->urls.size());
1214   ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
1215               delegate_.favicon_details()->urls.find(row1.url()));
1216
1217   EXPECT_FALSE(thumbnail_db_.GetIconMappingsForPageURL(
1218       row1.url(), favicon_base::FAVICON, NULL));
1219 }
1220
1221 TEST_F(AndroidProviderBackendTest, UpdateSearchTermTable) {
1222   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1223   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1224   scoped_ptr<AndroidProviderBackend> backend(
1225       new AndroidProviderBackend(android_cache_db_name_,
1226                                  &history_db_,
1227                                  &thumbnail_db_,
1228                                  history_client_,
1229                                  &delegate_));
1230   // Insert a keyword search item to verify if the update succeeds.
1231   HistoryAndBookmarkRow row1;
1232   row1.set_raw_url("cnn.com");
1233   row1.set_url(GURL("http://cnn.com"));
1234   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1235   row1.set_title(UTF8ToUTF16("cnn"));
1236   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row1));
1237   base::string16 term = UTF8ToUTF16("Search term 1");
1238   URLID url_id = history_db_.GetRowForURL(row1.url(), NULL);
1239   ASSERT_TRUE(url_id);
1240   ASSERT_TRUE(history_db_.SetKeywordSearchTermsForURL(url_id, 1, term));
1241   ASSERT_TRUE(backend->UpdateSearchTermTable());
1242   SearchTermRow keyword_cache;
1243   SearchTermID id = history_db_.GetSearchTerm(term, &keyword_cache);
1244   ASSERT_TRUE(id);
1245   EXPECT_EQ(term, keyword_cache.term);
1246   EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
1247             ToDatabaseTime(keyword_cache.last_visit_time));
1248
1249   // Add another row.
1250   HistoryAndBookmarkRow row2;
1251   row2.set_raw_url("google.com");
1252   row2.set_url(GURL("http://google.com"));
1253   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(2));
1254   row2.set_title(UTF8ToUTF16("cnn"));
1255   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row2));
1256   url_id = history_db_.GetRowForURL(row2.url(), NULL);
1257   ASSERT_TRUE(url_id);
1258   base::string16 term2 = UTF8ToUTF16("Search term 2");
1259   ASSERT_TRUE(history_db_.SetKeywordSearchTermsForURL(url_id, 1, term2));
1260   ASSERT_TRUE(backend->UpdateSearchTermTable());
1261   SearchTermID search_id1 = history_db_.GetSearchTerm(term,
1262                                                            &keyword_cache);
1263   // The id shouldn't changed.
1264   ASSERT_EQ(id, search_id1);
1265   EXPECT_EQ(term, keyword_cache.term);
1266   EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
1267             ToDatabaseTime(keyword_cache.last_visit_time));
1268   // Verify the row just inserted.
1269   SearchTermID id2 = history_db_.GetSearchTerm(term2, &keyword_cache);
1270   ASSERT_TRUE(id2);
1271   EXPECT_EQ(term2, keyword_cache.term);
1272   EXPECT_EQ(ToDatabaseTime(row2.last_visit_time()),
1273             ToDatabaseTime(keyword_cache.last_visit_time));
1274
1275   // Add 3rd row and associate it with term.
1276   HistoryAndBookmarkRow row3;
1277   row3.set_raw_url("search.com");
1278   row3.set_url(GURL("http://search.com"));
1279   row3.set_last_visit_time(Time::Now());
1280   row3.set_title(UTF8ToUTF16("search"));
1281   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row3));
1282   url_id = history_db_.GetRowForURL(row3.url(), NULL);
1283   ASSERT_TRUE(url_id);
1284   ASSERT_TRUE(history_db_.SetKeywordSearchTermsForURL(url_id, 1, term));
1285   ASSERT_TRUE(backend->UpdateSearchTermTable());
1286   // Verify id not changed and last_visit_time updated.
1287   ASSERT_EQ(search_id1, history_db_.GetSearchTerm(term, &keyword_cache));
1288   EXPECT_EQ(ToDatabaseTime(row3.last_visit_time()),
1289             ToDatabaseTime(keyword_cache.last_visit_time));
1290   // The id of term2 wasn't changed.
1291   EXPECT_EQ(id2, history_db_.GetSearchTerm(term2, NULL));
1292
1293   // Remove the term.
1294   ASSERT_TRUE(history_db_.DeleteKeywordSearchTerm(term));
1295   ASSERT_TRUE(backend->UpdateSearchTermTable());
1296   // The cache of term should removed.
1297   ASSERT_FALSE(history_db_.GetSearchTerm(term, NULL));
1298   // The id of term2 wasn't changed.
1299   EXPECT_EQ(id2, history_db_.GetSearchTerm(term2, NULL));
1300 }
1301
1302 TEST_F(AndroidProviderBackendTest, QuerySearchTerms) {
1303   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1304   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1305   scoped_ptr<AndroidProviderBackend> backend(
1306       new AndroidProviderBackend(android_cache_db_name_,
1307                                  &history_db_,
1308                                  &thumbnail_db_,
1309                                  history_client_,
1310                                  &delegate_));
1311   // Insert a keyword search item to verify if we can find it.
1312   HistoryAndBookmarkRow row1;
1313   row1.set_raw_url("cnn.com");
1314   row1.set_url(GURL("http://cnn.com"));
1315   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1316   row1.set_title(UTF8ToUTF16("cnn"));
1317   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row1));
1318   base::string16 term = UTF8ToUTF16("Search term 1");
1319   URLID url_id = history_db_.GetRowForURL(row1.url(), NULL);
1320   ASSERT_TRUE(url_id);
1321   ASSERT_TRUE(history_db_.SetKeywordSearchTermsForURL(url_id, 1, term));
1322
1323   std::vector<SearchRow::ColumnID> projections;
1324   projections.push_back(SearchRow::ID);
1325   projections.push_back(SearchRow::SEARCH_TERM);
1326   projections.push_back(SearchRow::SEARCH_TIME);
1327   scoped_ptr<AndroidStatement> statement(backend->QuerySearchTerms(
1328       projections, std::string(), std::vector<base::string16>(),
1329       std::string()));
1330   ASSERT_TRUE(statement.get());
1331   ASSERT_TRUE(statement->statement()->Step());
1332   EXPECT_TRUE(statement->statement()->ColumnInt64(0));
1333   EXPECT_EQ(term, statement->statement()->ColumnString16(1));
1334   EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
1335             statement->statement()->ColumnInt64(2));
1336   EXPECT_FALSE(statement->statement()->Step());
1337 }
1338
1339 TEST_F(AndroidProviderBackendTest, UpdateSearchTerms) {
1340   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1341   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1342   scoped_ptr<AndroidProviderBackend> backend(
1343       new AndroidProviderBackend(android_cache_db_name_,
1344                                  &history_db_,
1345                                  &thumbnail_db_,
1346                                  history_client_,
1347                                  &delegate_));
1348   // Insert a keyword.
1349   HistoryAndBookmarkRow row1;
1350   row1.set_raw_url("cnn.com");
1351   row1.set_url(GURL("http://cnn.com"));
1352   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1353   row1.set_title(UTF8ToUTF16("cnn"));
1354   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row1));
1355   base::string16 term = UTF8ToUTF16("Search term 1");
1356   URLID url_id = history_db_.GetRowForURL(row1.url(), NULL);
1357   ASSERT_TRUE(url_id);
1358   ASSERT_TRUE(history_db_.SetKeywordSearchTermsForURL(url_id, 1, term));
1359
1360   // Get the SearchTermID of the row we just inserted.
1361   std::vector<SearchRow::ColumnID> projections;
1362   projections.push_back(SearchRow::ID);
1363   projections.push_back(SearchRow::SEARCH_TIME);
1364   projections.push_back(SearchRow::SEARCH_TERM);
1365   std::vector<base::string16> args;
1366   args.push_back(term);
1367   scoped_ptr<AndroidStatement> statement(backend->QuerySearchTerms(
1368       projections, "search = ?", args, std::string()));
1369   ASSERT_TRUE(statement.get());
1370   ASSERT_TRUE(statement->statement()->Step());
1371   SearchTermID id = statement->statement()->ColumnInt64(0);
1372   ASSERT_TRUE(id);
1373   EXPECT_FALSE(statement->statement()->Step());
1374
1375   // Update the search term and time.
1376   base::string16 update_term = UTF8ToUTF16("Update search term");
1377   args.clear();
1378   args.push_back(term);
1379   SearchRow search_row;
1380   search_row.set_search_term(update_term);
1381   search_row.set_url(GURL("http://google.com"));
1382   search_row.set_template_url_id(1);
1383   search_row.set_search_time(Time::Now() - TimeDelta::FromHours(1));
1384   int update_count = 0;
1385   ASSERT_TRUE(backend->UpdateSearchTerms(search_row, "search = ?", args,
1386                                          &update_count));
1387   EXPECT_EQ(1, update_count);
1388
1389   // Verify if the search term updated.
1390   // The origin term should be removed.
1391   std::vector<KeywordSearchTermRow> rows;
1392   ASSERT_TRUE(history_db_.GetKeywordSearchTermRows(term, &rows));
1393   EXPECT_TRUE(rows.empty());
1394   // The new term should be inserted.
1395   ASSERT_TRUE(history_db_.GetKeywordSearchTermRows(update_term, &rows));
1396   ASSERT_EQ(1u, rows.size());
1397   // The history of urls shouldn't be removed.
1398   ASSERT_TRUE(history_db_.GetRowForURL(row1.url(), NULL));
1399   // The new URL is inserted.
1400   ASSERT_TRUE(history_db_.GetRowForURL(search_row.url(), NULL));
1401
1402   // Verfiy the AndoridSearchID isn't changed.
1403   args.clear();
1404   args.push_back(update_term);
1405   statement.reset(backend->QuerySearchTerms(projections, "search = ?", args,
1406                                             std::string()));
1407   ASSERT_TRUE(statement.get());
1408   ASSERT_TRUE(statement->statement()->Step());
1409   // The id didn't change.
1410   EXPECT_EQ(id, statement->statement()->ColumnInt64(0));
1411   // The search time was updated.
1412   EXPECT_EQ(ToDatabaseTime(search_row.search_time()),
1413             statement->statement()->ColumnInt64(1));
1414   // The search term was updated.
1415   EXPECT_EQ(update_term, statement->statement()->ColumnString16(2));
1416   EXPECT_FALSE(statement->statement()->Step());
1417
1418   // Only update the search time.
1419   SearchRow update_time;
1420   update_time.set_search_time(Time::Now());
1421   // Update it by id.
1422   args.clear();
1423   std::ostringstream oss;
1424   oss << id;
1425   args.push_back(UTF8ToUTF16(oss.str()));
1426   update_count = 0;
1427   ASSERT_TRUE(backend->UpdateSearchTerms(update_time, "_id = ?", args,
1428                                          &update_count));
1429   EXPECT_EQ(1, update_count);
1430
1431   // Verify the update.
1432   statement.reset(backend->QuerySearchTerms(projections, "_id = ?", args,
1433                                             std::string()));
1434   ASSERT_TRUE(statement.get());
1435   ASSERT_TRUE(statement->statement()->Step());
1436   // The id didn't change.
1437   EXPECT_EQ(id, statement->statement()->ColumnInt64(0));
1438   // The search time was updated.
1439   EXPECT_EQ(ToDatabaseTime(update_time.search_time()),
1440             statement->statement()->ColumnInt64(1));
1441   // The search term didn't change.
1442   EXPECT_EQ(update_term, statement->statement()->ColumnString16(2));
1443   EXPECT_FALSE(statement->statement()->Step());
1444 }
1445
1446 TEST_F(AndroidProviderBackendTest, DeleteSearchTerms) {
1447   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1448   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1449   scoped_ptr<AndroidProviderBackend> backend(
1450       new AndroidProviderBackend(android_cache_db_name_,
1451                                  &history_db_,
1452                                  &thumbnail_db_,
1453                                  history_client_,
1454                                  &delegate_));
1455   // Insert a keyword.
1456   HistoryAndBookmarkRow row1;
1457   row1.set_raw_url("cnn.com");
1458   row1.set_url(GURL("http://cnn.com"));
1459   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1460   row1.set_title(UTF8ToUTF16("cnn"));
1461   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row1));
1462   base::string16 term = UTF8ToUTF16("Search term 1");
1463   URLID url_id = history_db_.GetRowForURL(row1.url(), NULL);
1464   ASSERT_TRUE(url_id);
1465   ASSERT_TRUE(history_db_.SetKeywordSearchTermsForURL(url_id, 1, term));
1466
1467   // Get the SearchTermID of the row we just inserted.
1468   std::vector<SearchRow::ColumnID> projections;
1469   projections.push_back(SearchRow::ID);
1470   projections.push_back(SearchRow::SEARCH_TIME);
1471   projections.push_back(SearchRow::SEARCH_TERM);
1472   std::vector<base::string16> args;
1473   args.push_back(term);
1474   scoped_ptr<AndroidStatement> statement(backend->QuerySearchTerms(
1475       projections, "search = ?", args, std::string()));
1476   ASSERT_TRUE(statement.get());
1477   ASSERT_TRUE(statement->statement()->Step());
1478   SearchTermID id1 = statement->statement()->ColumnInt64(0);
1479   ASSERT_TRUE(id1);
1480   EXPECT_FALSE(statement->statement()->Step());
1481
1482   // Insert a keyword.
1483   HistoryAndBookmarkRow row2;
1484   row2.set_raw_url("google.com");
1485   row2.set_url(GURL("http://google.com"));
1486   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1487   row2.set_title(UTF8ToUTF16("google"));
1488   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row2));
1489   base::string16 term2 = UTF8ToUTF16("Search term 2");
1490   URLID url_id2 = history_db_.GetRowForURL(row2.url(), NULL);
1491   ASSERT_TRUE(url_id2);
1492   ASSERT_TRUE(history_db_.SetKeywordSearchTermsForURL(url_id2, 1, term2));
1493
1494   // Get the SearchTermID of the row we just inserted.
1495   projections.clear();
1496   projections.push_back(SearchRow::ID);
1497   projections.push_back(SearchRow::SEARCH_TIME);
1498   projections.push_back(SearchRow::SEARCH_TERM);
1499   args.clear();
1500   args.push_back(term2);
1501   statement.reset(backend->QuerySearchTerms(projections, "search = ?", args,
1502                                             std::string()));
1503   ASSERT_TRUE(statement.get());
1504   ASSERT_TRUE(statement->statement()->Step());
1505   SearchTermID id2 = statement->statement()->ColumnInt64(0);
1506   ASSERT_TRUE(id2);
1507   EXPECT_FALSE(statement->statement()->Step());
1508
1509   // Delete the first one.
1510   args.clear();
1511   args.push_back(term);
1512   int deleted_count = 0;
1513   ASSERT_TRUE(backend->DeleteSearchTerms("search = ?", args, &deleted_count));
1514   EXPECT_EQ(1, deleted_count);
1515   std::vector<KeywordSearchTermRow> rows;
1516   ASSERT_TRUE(history_db_.GetKeywordSearchTermRows(term, &rows));
1517   EXPECT_TRUE(rows.empty());
1518   // Verify we can't get the first term.
1519   args.clear();
1520   std::ostringstream oss;
1521   oss << id1;
1522   args.push_back(UTF8ToUTF16(oss.str()));
1523   statement.reset(backend->QuerySearchTerms(projections, "_id = ?", args,
1524                                             std::string()));
1525   ASSERT_TRUE(statement.get());
1526   EXPECT_FALSE(statement->statement()->Step());
1527
1528   // The second one is still there.
1529   args.clear();
1530   std::ostringstream oss1;
1531   oss1 << id2;
1532   args.push_back(UTF8ToUTF16(oss1.str()));
1533   statement.reset(backend->QuerySearchTerms(projections, "_id = ?", args,
1534                                             std::string()));
1535   ASSERT_TRUE(statement.get());
1536   EXPECT_TRUE(statement->statement()->Step());
1537   EXPECT_EQ(id2, statement->statement()->ColumnInt64(0));
1538   EXPECT_FALSE(statement->statement()->Step());
1539
1540   // Remove all search terms in no condition.
1541   deleted_count = 0;
1542   args.clear();
1543   ASSERT_TRUE(backend->DeleteSearchTerms(std::string(), args, &deleted_count));
1544   EXPECT_EQ(1, deleted_count);
1545
1546   // Verify the second one was removed.
1547   args.clear();
1548   args.push_back(UTF8ToUTF16(oss1.str()));
1549   statement.reset(backend->QuerySearchTerms(projections, "_id = ?", args,
1550                                             std::string()));
1551   ASSERT_TRUE(statement.get());
1552   EXPECT_FALSE(statement->statement()->Step());
1553 }
1554
1555 TEST_F(AndroidProviderBackendTest, InsertSearchTerm) {
1556   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1557   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1558   scoped_ptr<AndroidProviderBackend> backend(
1559       new AndroidProviderBackend(android_cache_db_name_,
1560                                  &history_db_,
1561                                  &thumbnail_db_,
1562                                  history_client_,
1563                                  &delegate_));
1564   SearchRow search_row;
1565   search_row.set_search_term(UTF8ToUTF16("google"));
1566   search_row.set_url(GURL("http://google.com"));
1567   search_row.set_template_url_id(1);
1568   search_row.set_search_time(Time::Now() - TimeDelta::FromHours(1));
1569
1570   SearchTermID id = backend->InsertSearchTerm(search_row);
1571   ASSERT_TRUE(id);
1572
1573   std::vector<SearchRow::ColumnID> projections;
1574   projections.push_back(SearchRow::ID);
1575   projections.push_back(SearchRow::SEARCH_TIME);
1576   projections.push_back(SearchRow::SEARCH_TERM);
1577   std::vector<base::string16> args;
1578   std::ostringstream oss;
1579   oss << id;
1580   args.push_back(UTF8ToUTF16(oss.str()));
1581   scoped_ptr<AndroidStatement> statement(backend->QuerySearchTerms(
1582       projections, "_id = ?", args, std::string()));
1583   ASSERT_TRUE(statement.get());
1584   ASSERT_TRUE(statement->statement()->Step());
1585   EXPECT_EQ(id, statement->statement()->ColumnInt64(0));
1586   EXPECT_EQ(ToDatabaseTime(search_row.search_time()),
1587             statement->statement()->ColumnInt64(1));
1588   EXPECT_EQ(search_row.search_term(),
1589             statement->statement()->ColumnString16(2));
1590   EXPECT_FALSE(statement->statement()->Step());
1591 }
1592
1593 TEST_F(AndroidProviderBackendTest, DeleteHistory) {
1594   HistoryAndBookmarkRow row1;
1595   row1.set_raw_url("cnn.com");
1596   row1.set_url(GURL("http://cnn.com"));
1597   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1598   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
1599   row1.set_visit_count(10);
1600   row1.set_is_bookmark(true);
1601   row1.set_title(UTF8ToUTF16("cnn"));
1602
1603   HistoryAndBookmarkRow row2;
1604   row2.set_raw_url("http://www.example.com");
1605   row2.set_url(GURL("http://www.example.com"));
1606   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
1607   row2.set_is_bookmark(false);
1608   row2.set_title(UTF8ToUTF16("example"));
1609   std::vector<unsigned char> data;
1610   data.push_back('1');
1611   row2.set_favicon(base::RefCountedBytes::TakeVector(&data));
1612
1613   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1614   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1615   scoped_ptr<AndroidProviderBackend> backend(
1616       new AndroidProviderBackend(android_cache_db_name_,
1617                                  &history_db_,
1618                                  &thumbnail_db_,
1619                                  history_client_,
1620                                  &delegate_));
1621
1622   AndroidURLID id1 = backend->InsertHistoryAndBookmark(row1);
1623   ASSERT_TRUE(id1);
1624   AndroidURLID id2 = backend->InsertHistoryAndBookmark(row2);
1625   ASSERT_TRUE(id2);
1626
1627   // Verify the row1 has been added in bookmark model.
1628   content::RunAllPendingInMessageLoop();
1629   ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
1630   const BookmarkNode* child = bookmark_model_->mobile_node()->GetChild(0);
1631   ASSERT_TRUE(child);
1632   EXPECT_EQ(row1.title(), child->GetTitle());
1633   EXPECT_EQ(row1.url(), child->url());
1634
1635   // Delete history
1636   int deleted_count = 0;
1637   ASSERT_TRUE(backend->DeleteHistory(std::string(),
1638                                      std::vector<base::string16>(),
1639                                      &deleted_count));
1640   EXPECT_EQ(2, deleted_count);
1641   // The row2 was deleted.
1642   EXPECT_FALSE(history_db_.GetRowForURL(row2.url(), NULL));
1643   // Still find the row1.
1644   URLRow url_row;
1645   ASSERT_TRUE(history_db_.GetRowForURL(row1.url(), &url_row));
1646   // The visit_count was reset.
1647   EXPECT_EQ(0, url_row.visit_count());
1648   EXPECT_EQ(Time::UnixEpoch(), url_row.last_visit());
1649
1650   // Verify the row1 is still in bookmark model.
1651   content::RunAllPendingInMessageLoop();
1652   ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
1653   const BookmarkNode* child1 = bookmark_model_->mobile_node()->GetChild(0);
1654   ASSERT_TRUE(child1);
1655   EXPECT_EQ(row1.title(), child1->GetTitle());
1656   EXPECT_EQ(row1.url(), child1->url());
1657
1658   // Verify notification
1659   ASSERT_TRUE(delegate_.deleted_details());
1660   ASSERT_EQ(2u, delegate_.deleted_details()->rows.size());
1661   EXPECT_EQ(row1.url(),
1662             delegate_.modified_details()->changed_urls[0].url());
1663   EXPECT_EQ(Time::UnixEpoch(),
1664             delegate_.modified_details()->changed_urls[0].last_visit());
1665   EXPECT_EQ(1u, delegate_.favicon_details()->urls.size());
1666 }
1667
1668 TEST_F(AndroidProviderBackendTest, TestMultipleNestingTransaction) {
1669   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1670   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1671   scoped_ptr<AndroidProviderBackend> backend(
1672       new AndroidProviderBackend(android_cache_db_name_,
1673                                  &history_db_,
1674                                  &thumbnail_db_,
1675                                  history_client_,
1676                                  &delegate_));
1677
1678   // Create the nested transactions.
1679   history_db_.BeginTransaction();
1680   history_db_.BeginTransaction();
1681   history_db_.BeginTransaction();
1682   thumbnail_db_.BeginTransaction();
1683   thumbnail_db_.BeginTransaction();
1684   int history_transaction = history_db_.transaction_nesting();
1685   int thumbnail_transaction = thumbnail_db_.transaction_nesting();
1686
1687   // Insert a row to verify the transaction number are not changed
1688   // after a transaction commit.
1689   HistoryAndBookmarkRow row1;
1690   row1.set_raw_url("cnn.com");
1691   row1.set_url(GURL("http://cnn.com"));
1692   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1693   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
1694   row1.set_visit_count(10);
1695   row1.set_title(UTF8ToUTF16("cnn"));
1696   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row1));
1697   EXPECT_EQ(history_transaction, history_db_.transaction_nesting());
1698   EXPECT_EQ(thumbnail_transaction, thumbnail_db_.transaction_nesting());
1699
1700   // Insert the same URL, it should failed. The transaction are still same
1701   // after a rollback.
1702   ASSERT_FALSE(backend->InsertHistoryAndBookmark(row1));
1703   EXPECT_EQ(history_transaction, history_db_.transaction_nesting());
1704   EXPECT_EQ(thumbnail_transaction, thumbnail_db_.transaction_nesting());
1705
1706   // Insert another row to verify we are still fine after the previous
1707   // rollback.
1708   HistoryAndBookmarkRow row2;
1709   row2.set_raw_url("http://www.example.com");
1710   row2.set_url(GURL("http://www.example.com"));
1711   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
1712   row2.set_is_bookmark(false);
1713   row2.set_title(UTF8ToUTF16("example"));
1714   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row2));
1715   EXPECT_EQ(history_transaction, history_db_.transaction_nesting());
1716   EXPECT_EQ(thumbnail_transaction, thumbnail_db_.transaction_nesting());
1717 }
1718
1719 TEST_F(AndroidProviderBackendTest, TestAndroidCTSComplianceForZeroVisitCount) {
1720   // This is to verify the last visit time and created time are same when visit
1721   // count is 0.
1722   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1723   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1724   scoped_ptr<AndroidProviderBackend> backend(
1725       new AndroidProviderBackend(android_cache_db_name_,
1726                                  &history_db_,
1727                                  &thumbnail_db_,
1728                                  history_client_,
1729                                  &delegate_));
1730   URLRow url_row(GURL("http://www.google.com"));
1731   url_row.set_last_visit(Time::Now());
1732   url_row.set_visit_count(0);
1733   history_db_.AddURL(url_row);
1734
1735   std::vector<HistoryAndBookmarkRow::ColumnID> projections;
1736
1737   projections.push_back(HistoryAndBookmarkRow::ID);
1738   projections.push_back(HistoryAndBookmarkRow::URL);
1739   projections.push_back(HistoryAndBookmarkRow::TITLE);
1740   projections.push_back(HistoryAndBookmarkRow::CREATED);
1741   projections.push_back(HistoryAndBookmarkRow::LAST_VISIT_TIME);
1742   projections.push_back(HistoryAndBookmarkRow::VISIT_COUNT);
1743   projections.push_back(HistoryAndBookmarkRow::FAVICON);
1744   projections.push_back(HistoryAndBookmarkRow::BOOKMARK);
1745
1746   scoped_ptr<AndroidStatement> statement(backend->QueryHistoryAndBookmarks(
1747       projections, std::string(), std::vector<base::string16>(),
1748       std::string("url ASC")));
1749
1750   ASSERT_TRUE(statement->statement()->Step());
1751   EXPECT_EQ(ToDatabaseTime(url_row.last_visit()),
1752             statement->statement()->ColumnInt64(3));
1753   EXPECT_EQ(ToDatabaseTime(url_row.last_visit()),
1754             statement->statement()->ColumnInt64(4));
1755   EXPECT_EQ(url_row.visit_count(), statement->statement()->ColumnInt(5));
1756 }
1757
1758 TEST_F(AndroidProviderBackendTest, AndroidCTSComplianceFolderColumnExists) {
1759   // This is test is used to verify the 'folder' column exists, all bookmarks
1760   // returned when folder is 0 and the non bookmark rows returned when folder
1761   // is 1.
1762   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1763   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_));
1764   scoped_ptr<AndroidProviderBackend> backend(
1765       new AndroidProviderBackend(android_cache_db_name_,
1766                                  &history_db_,
1767                                  &thumbnail_db_,
1768                                  history_client_,
1769                                  &delegate_));
1770   HistoryAndBookmarkRow row1;
1771   row1.set_raw_url("cnn.com");
1772   row1.set_url(GURL("http://cnn.com"));
1773   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1774   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
1775   row1.set_visit_count(10);
1776   row1.set_is_bookmark(true);
1777   row1.set_title(UTF8ToUTF16("cnn"));
1778
1779   HistoryAndBookmarkRow row2;
1780   row2.set_raw_url("http://www.example.com");
1781   row2.set_url(GURL("http://www.example.com"));
1782   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
1783   row2.set_is_bookmark(false);
1784   row2.set_title(UTF8ToUTF16("example"));
1785   std::vector<unsigned char> data;
1786   data.push_back('1');
1787   row2.set_favicon(base::RefCountedBytes::TakeVector(&data));
1788
1789   AndroidURLID id1 = backend->InsertHistoryAndBookmark(row1);
1790   ASSERT_TRUE(id1);
1791   AndroidURLID id2 = backend->InsertHistoryAndBookmark(row2);
1792   ASSERT_TRUE(id2);
1793   content::RunAllPendingInMessageLoop();
1794
1795   // Query by folder=0, the row1 should returned.
1796   std::vector<HistoryAndBookmarkRow::ColumnID> projections;
1797
1798   projections.push_back(HistoryAndBookmarkRow::URL);
1799
1800   scoped_ptr<AndroidStatement> statement(backend->QueryHistoryAndBookmarks(
1801       projections, std::string("folder=0"), std::vector<base::string16>(),
1802       std::string("url ASC")));
1803   ASSERT_TRUE(statement->statement()->Step());
1804   EXPECT_EQ(row1.raw_url(), statement->statement()->ColumnString(0));
1805   EXPECT_FALSE(statement->statement()->Step());
1806
1807   // Query by folder=1, the row2 should returned.
1808   statement.reset(backend->QueryHistoryAndBookmarks(
1809       projections, std::string("folder=1"), std::vector<base::string16>(),
1810       std::string("url ASC")));
1811   ASSERT_TRUE(statement->statement()->Step());
1812   EXPECT_EQ(row2.url(), GURL(statement->statement()->ColumnString(0)));
1813   EXPECT_FALSE(statement->statement()->Step());
1814 }
1815
1816 TEST_F(AndroidProviderBackendTest, QueryWithoutThumbnailDB) {
1817   GURL url1("http://www.cnn.com");
1818   URLID url_id1 = 0;
1819   const base::string16 title1(UTF8ToUTF16("cnn"));
1820   std::vector<VisitInfo> visits1;
1821   Time last_visited1 = Time::Now() - TimeDelta::FromDays(1);
1822   Time created1 = last_visited1 - TimeDelta::FromDays(20);
1823   visits1.push_back(VisitInfo(created1, content::PAGE_TRANSITION_LINK));
1824   visits1.push_back(VisitInfo(last_visited1 - TimeDelta::FromDays(1),
1825                               content::PAGE_TRANSITION_LINK));
1826   visits1.push_back(VisitInfo(last_visited1, content::PAGE_TRANSITION_LINK));
1827
1828   GURL url2("http://www.example.com");
1829   URLID url_id2 = 0;
1830   std::vector<VisitInfo> visits2;
1831   const base::string16 title2(UTF8ToUTF16("example"));
1832   Time last_visited2 = Time::Now();
1833   Time created2 = last_visited2 - TimeDelta::FromDays(10);
1834   visits2.push_back(VisitInfo(created2, content::PAGE_TRANSITION_LINK));
1835   visits2.push_back(VisitInfo(last_visited2 - TimeDelta::FromDays(5),
1836                               content::PAGE_TRANSITION_LINK));
1837   visits2.push_back(VisitInfo(last_visited2, content::PAGE_TRANSITION_LINK));
1838
1839   // Only use the HistoryBackend to generate the test data.
1840   // HistoryBackend will shutdown after that.
1841   {
1842   scoped_refptr<HistoryBackend> history_backend;
1843   history_backend = new HistoryBackend(
1844       temp_dir_.path(), new AndroidProviderBackendDelegate(), history_client_);
1845   history_backend->Init(std::string(), false);
1846   history_backend->AddVisits(url1, visits1, history::SOURCE_SYNCED);
1847   history_backend->AddVisits(url2, visits2, history::SOURCE_SYNCED);
1848   URLRow url_row;
1849
1850   ASSERT_TRUE(history_backend->GetURL(url1, &url_row));
1851   url_id1 = url_row.id();
1852   url_row.set_title(title1);
1853   ASSERT_TRUE(history_backend->UpdateURL(url_id1, url_row));
1854
1855   ASSERT_TRUE(history_backend->GetURL(url2, &url_row));
1856   url_id2 = url_row.id();
1857   url_row.set_title(title2);
1858   ASSERT_TRUE(history_backend->UpdateURL(url_id2, url_row));
1859
1860   // Set favicon to url2.
1861   std::vector<unsigned char> data;
1862   data.push_back('1');
1863   favicon_base::FaviconRawBitmapData bitmap_data_element;
1864   bitmap_data_element.bitmap_data = new base::RefCountedBytes(data);
1865   bitmap_data_element.pixel_size = gfx::Size();
1866   bitmap_data_element.icon_url = GURL();
1867   std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
1868   favicon_bitmap_data.push_back(bitmap_data_element);
1869
1870   history_backend->SetFavicons(
1871       url2, favicon_base::FAVICON, favicon_bitmap_data);
1872   history_backend->Closing();
1873   }
1874
1875   // The history_db_name and thumbnail_db_name files should be created by
1876   // HistoryBackend. We need to open the same database files.
1877   ASSERT_TRUE(base::PathExists(history_db_name_));
1878   ASSERT_TRUE(base::PathExists(thumbnail_db_name_));
1879
1880   // Only creates the history database
1881   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1882
1883   // Set url1 as bookmark.
1884   AddBookmark(url1);
1885
1886   scoped_ptr<AndroidProviderBackend> backend(
1887       new AndroidProviderBackend(android_cache_db_name_,
1888                                  &history_db_,
1889                                  NULL,
1890                                  history_client_,
1891                                  &delegate_));
1892
1893   std::vector<HistoryAndBookmarkRow::ColumnID> projections;
1894
1895   projections.push_back(HistoryAndBookmarkRow::ID);
1896   projections.push_back(HistoryAndBookmarkRow::URL);
1897   projections.push_back(HistoryAndBookmarkRow::TITLE);
1898   projections.push_back(HistoryAndBookmarkRow::CREATED);
1899   projections.push_back(HistoryAndBookmarkRow::LAST_VISIT_TIME);
1900   projections.push_back(HistoryAndBookmarkRow::VISIT_COUNT);
1901   projections.push_back(HistoryAndBookmarkRow::FAVICON);
1902   projections.push_back(HistoryAndBookmarkRow::BOOKMARK);
1903
1904   scoped_ptr<AndroidStatement> statement(backend->QueryHistoryAndBookmarks(
1905       projections, std::string(), std::vector<base::string16>(),
1906       std::string("url ASC")));
1907   ASSERT_TRUE(statement->statement()->Step());
1908   ASSERT_EQ(url1, GURL(statement->statement()->ColumnString(1)));
1909   EXPECT_EQ(title1, statement->statement()->ColumnString16(2));
1910   EXPECT_EQ(ToDatabaseTime(created1),
1911             statement->statement()->ColumnInt64(3));
1912   EXPECT_EQ(ToDatabaseTime(last_visited1),
1913             statement->statement()->ColumnInt64(4));
1914   EXPECT_EQ(3, statement->statement()->ColumnInt(5));
1915   EXPECT_EQ(6, statement->favicon_index());
1916   // No favicon.
1917   EXPECT_EQ(0, statement->statement()->ColumnByteLength(6));
1918   EXPECT_TRUE(statement->statement()->ColumnBool(7));
1919
1920   ASSERT_TRUE(statement->statement()->Step());
1921   EXPECT_EQ(title2, statement->statement()->ColumnString16(2));
1922   ASSERT_EQ(url2, GURL(statement->statement()->ColumnString(1)));
1923   EXPECT_EQ(ToDatabaseTime(created2),
1924             statement->statement()->ColumnInt64(3));
1925   EXPECT_EQ(ToDatabaseTime(last_visited2),
1926             statement->statement()->ColumnInt64(4));
1927   EXPECT_EQ(3, statement->statement()->ColumnInt(5));
1928   std::vector<unsigned char> favicon2;
1929   EXPECT_EQ(6, statement->favicon_index());
1930   // No favicon because thumbnail database wasn't initialized.
1931   EXPECT_EQ(0, statement->statement()->ColumnByteLength(6));
1932   EXPECT_FALSE(statement->statement()->ColumnBool(7));
1933
1934   // No more row.
1935   EXPECT_FALSE(statement->statement()->Step());
1936 }
1937
1938 TEST_F(AndroidProviderBackendTest, InsertWithoutThumbnailDB) {
1939   HistoryAndBookmarkRow row1;
1940   row1.set_raw_url("cnn.com");
1941   row1.set_url(GURL("http://cnn.com"));
1942   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
1943   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
1944   row1.set_visit_count(10);
1945   row1.set_is_bookmark(true);
1946   row1.set_title(UTF8ToUTF16("cnn"));
1947
1948   HistoryAndBookmarkRow row2;
1949   row2.set_raw_url("http://www.example.com");
1950   row2.set_url(GURL("http://www.example.com"));
1951   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
1952   row2.set_is_bookmark(false);
1953   row2.set_title(UTF8ToUTF16("example"));
1954   std::vector<unsigned char> data;
1955   data.push_back('1');
1956   row2.set_favicon(base::RefCountedBytes::TakeVector(&data));
1957
1958   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
1959   scoped_ptr<AndroidProviderBackend> backend(
1960       new AndroidProviderBackend(android_cache_db_name_,
1961                                  &history_db_,
1962                                  NULL,
1963                                  history_client_,
1964                                  &delegate_));
1965
1966   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row1));
1967   EXPECT_FALSE(delegate_.deleted_details());
1968   ASSERT_TRUE(delegate_.modified_details());
1969   ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
1970   EXPECT_EQ(row1.url(), delegate_.modified_details()->changed_urls[0].url());
1971   EXPECT_EQ(row1.last_visit_time(),
1972             delegate_.modified_details()->changed_urls[0].last_visit());
1973   EXPECT_EQ(row1.visit_count(),
1974             delegate_.modified_details()->changed_urls[0].visit_count());
1975   EXPECT_EQ(row1.title(),
1976             delegate_.modified_details()->changed_urls[0].title());
1977   EXPECT_FALSE(delegate_.favicon_details());
1978   content::RunAllPendingInMessageLoop();
1979   ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
1980   const BookmarkNode* child = bookmark_model_->mobile_node()->GetChild(0);
1981   ASSERT_TRUE(child);
1982   EXPECT_EQ(row1.title(), child->GetTitle());
1983   EXPECT_EQ(row1.url(), child->url());
1984
1985   delegate_.ResetDetails();
1986   ASSERT_TRUE(backend->InsertHistoryAndBookmark(row2));
1987   EXPECT_FALSE(delegate_.deleted_details());
1988   ASSERT_TRUE(delegate_.modified_details());
1989   ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
1990   EXPECT_EQ(row2.url(), delegate_.modified_details()->changed_urls[0].url());
1991   EXPECT_EQ(row2.last_visit_time(),
1992             delegate_.modified_details()->changed_urls[0].last_visit());
1993   EXPECT_EQ(row2.title(),
1994             delegate_.modified_details()->changed_urls[0].title());
1995   // Favicon details is still false because thumbnail database wasn't
1996   // initialized, we ignore any changes of favicon.
1997   ASSERT_FALSE(delegate_.favicon_details());
1998 }
1999
2000 TEST_F(AndroidProviderBackendTest, DeleteWithoutThumbnailDB) {
2001   HistoryAndBookmarkRow row1;
2002   row1.set_raw_url("cnn.com");
2003   row1.set_url(GURL("http://cnn.com"));
2004   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
2005   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
2006   row1.set_visit_count(10);
2007   row1.set_is_bookmark(true);
2008   row1.set_title(UTF8ToUTF16("cnn"));
2009
2010   HistoryAndBookmarkRow row2;
2011   row2.set_raw_url("http://www.example.com");
2012   row2.set_url(GURL("http://www.example.com"));
2013   row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
2014   row2.set_is_bookmark(false);
2015   row2.set_title(UTF8ToUTF16("example"));
2016   std::vector<unsigned char> data;
2017   data.push_back('1');
2018   row2.set_favicon(base::RefCountedBytes::TakeVector(&data));
2019
2020   {
2021     HistoryDatabase history_db;
2022     ThumbnailDatabase thumbnail_db;
2023     ASSERT_EQ(sql::INIT_OK, history_db.Init(history_db_name_));
2024     ASSERT_EQ(sql::INIT_OK, thumbnail_db.Init(thumbnail_db_name_));
2025
2026     scoped_ptr<AndroidProviderBackend> backend(
2027         new AndroidProviderBackend(android_cache_db_name_,
2028                                    &history_db,
2029                                    &thumbnail_db,
2030                                    history_client_,
2031                                    &delegate_));
2032
2033     ASSERT_TRUE(backend->InsertHistoryAndBookmark(row1));
2034     ASSERT_TRUE(backend->InsertHistoryAndBookmark(row2));
2035     // Verify the row1 has been added in bookmark model.
2036     content::RunAllPendingInMessageLoop();
2037     ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
2038     const BookmarkNode* child = bookmark_model_->mobile_node()->GetChild(0);
2039     ASSERT_TRUE(child);
2040     EXPECT_EQ(row1.title(), child->GetTitle());
2041     EXPECT_EQ(row1.url(), child->url());
2042   }
2043   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
2044   scoped_ptr<AndroidProviderBackend> backend(
2045       new AndroidProviderBackend(android_cache_db_name_,
2046                                  &history_db_,
2047                                  NULL,
2048                                  history_client_,
2049                                  &delegate_));
2050
2051   // Delete all rows.
2052   std::vector<base::string16> args;
2053   int deleted_count = 0;
2054   delegate_.ResetDetails();
2055   ASSERT_TRUE(backend->DeleteHistoryAndBookmarks("Favicon IS NULL", args,
2056                                                  &deleted_count));
2057   // All rows were deleted.
2058   EXPECT_EQ(2, deleted_count);
2059   // Verify the rows was removed from bookmark model.
2060   content::RunAllPendingInMessageLoop();
2061   ASSERT_EQ(0, bookmark_model_->mobile_node()->child_count());
2062
2063   // Verify notifications
2064   ASSERT_TRUE(delegate_.deleted_details());
2065   EXPECT_FALSE(delegate_.modified_details());
2066   EXPECT_EQ(2u, delegate_.deleted_details()->rows.size());
2067   // No favicon has been deleted.
2068   EXPECT_FALSE(delegate_.favicon_details());
2069
2070   // No row exists.
2071   std::vector<HistoryAndBookmarkRow::ColumnID> projections;
2072   projections.push_back(HistoryAndBookmarkRow::ID);
2073   projections.push_back(HistoryAndBookmarkRow::URL);
2074   projections.push_back(HistoryAndBookmarkRow::TITLE);
2075   projections.push_back(HistoryAndBookmarkRow::CREATED);
2076   projections.push_back(HistoryAndBookmarkRow::LAST_VISIT_TIME);
2077   projections.push_back(HistoryAndBookmarkRow::VISIT_COUNT);
2078   projections.push_back(HistoryAndBookmarkRow::FAVICON);
2079   projections.push_back(HistoryAndBookmarkRow::BOOKMARK);
2080
2081   scoped_ptr<AndroidStatement> statement1(backend->QueryHistoryAndBookmarks(
2082       projections, std::string(), std::vector<base::string16>(),
2083       std::string("url ASC")));
2084   ASSERT_FALSE(statement1->statement()->Step());
2085 }
2086
2087 TEST_F(AndroidProviderBackendTest, UpdateFaviconWithoutThumbnail) {
2088   HistoryAndBookmarkRow row1;
2089   row1.set_raw_url("cnn.com");
2090   row1.set_url(GURL("http://cnn.com"));
2091   row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
2092   row1.set_created(Time::Now() - TimeDelta::FromDays(20));
2093   row1.set_visit_count(10);
2094   row1.set_is_bookmark(true);
2095   row1.set_title(UTF8ToUTF16("cnn"));
2096
2097   {
2098     HistoryDatabase history_db;
2099     ThumbnailDatabase thumbnail_db;
2100     ASSERT_EQ(sql::INIT_OK, history_db.Init(history_db_name_));
2101     ASSERT_EQ(sql::INIT_OK, thumbnail_db.Init(thumbnail_db_name_));
2102     scoped_ptr<AndroidProviderBackend> backend(
2103         new AndroidProviderBackend(android_cache_db_name_,
2104                                    &history_db,
2105                                    &thumbnail_db,
2106                                    history_client_,
2107                                    &delegate_));
2108
2109     AndroidURLID id1 = backend->InsertHistoryAndBookmark(row1);
2110     ASSERT_TRUE(id1);
2111   }
2112
2113   ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_));
2114   scoped_ptr<AndroidProviderBackend> backend(
2115       new AndroidProviderBackend(android_cache_db_name_,
2116                                  &history_db_,
2117                                  NULL,
2118                                  history_client_,
2119                                  &delegate_));
2120
2121   int update_count;
2122   std::vector<base::string16> update_args;
2123   // Update the last visit time to a value greater than current one.
2124   HistoryAndBookmarkRow update_row1;
2125
2126   // Set visit count.
2127   update_row1.set_visit_count(5);
2128   // Set favicon.
2129   std::vector<unsigned char> data;
2130   data.push_back('1');
2131   update_row1.set_favicon(base::RefCountedBytes::TakeVector(&data));
2132   update_args.push_back(UTF8ToUTF16(row1.raw_url()));
2133   delegate_.ResetDetails();
2134   ASSERT_TRUE(backend->UpdateHistoryAndBookmarks(update_row1, "url = ?",
2135                                                  update_args, &update_count));
2136   // Verify notifications.
2137   EXPECT_FALSE(delegate_.deleted_details());
2138   ASSERT_TRUE(delegate_.modified_details());
2139   ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
2140   // No favicon will be updated as thumbnail database is missing.
2141   EXPECT_FALSE(delegate_.favicon_details());
2142 }
2143
2144 }  // namespace history