AndroidProvider: Add history for bookmarks if it doesn't exist.

chrome/browser/history/android/android_provider_backend_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/history/android/android_provider_backend.h"
 
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 209 matching lines @@
   GURL url2("http://www.example.com");
   URLID url_id2 = 0;
   std::vector<VisitInfo> visits2;
   Time last_visited2 = Time::Now();
   Time created2 = last_visited2 - TimeDelta::FromDays(10);
   visits2.push_back(VisitInfo(created2, content::PAGE_TRANSITION_LINK));
   visits2.push_back(VisitInfo(last_visited2 - TimeDelta::FromDays(5),
                               content::PAGE_TRANSITION_LINK));
   visits2.push_back(VisitInfo(last_visited2, content::PAGE_TRANSITION_LINK));
 
+  // Add a bookmark which is not in the history.
+  GURL url3("http://www.bookmark.com");
+  string16 title3(UTF8ToUTF16("bookmark"));
+  ASSERT_TRUE(bookmark_model_->AddURL(bookmark_model_->bookmark_bar_node(), 0,
+                                      title3, url3));
   // Only use the HistoryBackend to generate the test data.
   // HistoryBackend will shutdown after that.
   {
   scoped_refptr<HistoryBackend> history_backend;
   history_backend = new HistoryBackend(temp_dir_.path(), 0,
       new AndroidProviderBackendDelegate(), bookmark_model_);
   history_backend->Init(std::string(), false);
   history_backend->AddVisits(url1, visits1, history::SOURCE_SYNCED);
   history_backend->AddVisits(url2, visits2, history::SOURCE_SYNCED);
   URLRow url_row;
@@ skipping 22 matching lines @@
   ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
                                              &history_db_));
   // Set url1 as bookmark.
   AddBookmark(url1);
   scoped_ptr<AndroidProviderBackend> backend(
       new AndroidProviderBackend(android_cache_db_name_, &history_db_,
                                  &thumbnail_db_, bookmark_model_, &delegate_));
 
   ASSERT_TRUE(backend->EnsureInitializedAndUpdated());
 
+  // First verify that the bookmark which was not in the history has been added
+  // to history database.
+  URLRow url_row;
+  ASSERT_TRUE(history_db_.GetRowForURL(url3, &url_row));
+  URLID url_id3 = url_row.id();
+  ASSERT_EQ(url3, url_row.url());
+  ASSERT_EQ(title3, url_row.title());
+
   std::vector<AndroidURLRow> android_url_rows;
   ASSERT_TRUE(GetAndroidURLsRows(&android_url_rows, backend.get()));
-  ASSERT_EQ(2u, android_url_rows.size());
+  ASSERT_EQ(3u, android_url_rows.size());
   std::vector<AndroidURLRow>::iterator i = android_url_rows.begin();
   EXPECT_EQ(url_id1, i->url_id);
   EXPECT_EQ(url1.spec(), i->raw_url);
   i++;
   EXPECT_EQ(url_id2, i->url_id);
   EXPECT_EQ(url2.spec(), i->raw_url);
+  i++;
+  EXPECT_EQ(url_id3, i->url_id);
+  EXPECT_EQ(url3.spec(), i->raw_url);
 
   std::vector<BookmarkCacheRow> bookmark_cache_rows;
   ASSERT_TRUE(GetBookmarkCacheRows(&bookmark_cache_rows, backend.get()));
-  ASSERT_EQ(2u, bookmark_cache_rows.size());
+  ASSERT_EQ(3u, bookmark_cache_rows.size());
   std::vector<BookmarkCacheRow>::const_iterator j = bookmark_cache_rows.begin();
   EXPECT_EQ(url_id1, j->url_id_);
   EXPECT_EQ(ToDatabaseTime(last_visited1), ToDatabaseTime(j->last_visit_time_));
   EXPECT_EQ(ToDatabaseTime(created1), ToDatabaseTime(j->create_time_));
   EXPECT_EQ(0, j->favicon_id_);
   EXPECT_TRUE(j->bookmark_);
   j++;
   EXPECT_EQ(url_id2, j->url_id_);
   EXPECT_EQ(ToDatabaseTime(last_visited2), ToDatabaseTime(j->last_visit_time_));
   EXPECT_EQ(ToDatabaseTime(created2), ToDatabaseTime(j->create_time_));
   EXPECT_NE(0, j->favicon_id_);
   EXPECT_FALSE(j->bookmark_);
 
   // Delete url2 from database.
   ASSERT_TRUE(history_db_.DeleteURLRow(url_id2));
   VisitVector visit_rows;
   ASSERT_TRUE(history_db_.GetMostRecentVisitsForURL(url_id2, 10,
                                                     &visit_rows));
   ASSERT_EQ(3u, visit_rows.size());
   for (VisitVector::const_iterator v = visit_rows.begin();
        v != visit_rows.end(); v++)
     history_db_.DeleteVisit(*v);
 
   backend->UpdateTables();
 
   android_url_rows.clear();
   ASSERT_TRUE(GetAndroidURLsRows(&android_url_rows, backend.get()));
-  ASSERT_EQ(1u, android_url_rows.size());
+  ASSERT_EQ(2u, android_url_rows.size());
   i = android_url_rows.begin();
   EXPECT_EQ(url_id1, i->url_id);
   EXPECT_EQ(url1.spec(), i->raw_url);
+  ++i;
+  EXPECT_EQ(url_id3, i->url_id);
+  EXPECT_EQ(url3.spec(), i->raw_url);
 
   bookmark_cache_rows.clear();
   ASSERT_TRUE(GetBookmarkCacheRows(&bookmark_cache_rows, backend.get()));
-  ASSERT_EQ(1u, bookmark_cache_rows.size());
+  ASSERT_EQ(2u, bookmark_cache_rows.size());
   j = bookmark_cache_rows.begin();
   EXPECT_EQ(url_id1, j->url_id_);
   EXPECT_EQ(ToDatabaseTime(last_visited1), ToDatabaseTime(j->last_visit_time_));
   EXPECT_EQ(ToDatabaseTime(created1), ToDatabaseTime(j->create_time_));
   EXPECT_EQ(0, j->favicon_id_);
   EXPECT_TRUE(j->bookmark_);
+  ++j;
+  EXPECT_EQ(url_id3, j->url_id_);
+  EXPECT_EQ(base::Time::UnixEpoch(), j->last_visit_time_);
+  EXPECT_EQ(base::Time::UnixEpoch(), j->create_time_);
+  EXPECT_EQ(0, j->favicon_id_);
+  EXPECT_TRUE(j->bookmark_);
 }
 
 TEST_F(AndroidProviderBackendTest, QueryHistoryAndBookmarks) {
   GURL url1("http://www.cnn.com");
   URLID url_id1 = 0;
   const string16 title1(UTF8ToUTF16("cnn"));
   std::vector<VisitInfo> visits1;
   Time last_visited1 = Time::Now() - TimeDelta::FromDays(1);
   Time created1 = last_visited1 - TimeDelta::FromDays(20);
   visits1.push_back(VisitInfo(created1, content::PAGE_TRANSITION_LINK));
@@ skipping 1390 matching lines @@
   // Query by folder=1, the row2 should returned.
   statement.reset(backend->QueryHistoryAndBookmarks(
       projections, std::string("folder=1"), std::vector<string16>(),
       std::string("url ASC")));
   ASSERT_TRUE(statement->statement()->Step());
   EXPECT_EQ(row2.url(), GURL(statement->statement()->ColumnString(0)));
   EXPECT_FALSE(statement->statement()->Step());
 }
 
 }  // namespace history