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

chrome/browser/history/android/android_provider_backend.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 "base/i18n/case_conversion.h"
 #include "chrome/browser/bookmarks/bookmark_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/browser/history/android/android_time.h"
@@ skipping 158 matching lines @@
   BroadcastNotifications(notifications);
   return true;
 }
 
 AndroidURLID AndroidProviderBackend::InsertHistoryAndBookmark(
     const HistoryAndBookmarkRow& values) {
   HistoryNotifications notifications;
 
   ScopedTransaction transaction(history_db_, thumbnail_db_);
 
-  AndroidURLID id = InsertHistoryAndBookmark(values, &notifications);
+  AndroidURLID id = InsertHistoryAndBookmark(values, &notifications, true);
   if (id) {
     transaction.Commit();
     BroadcastNotifications(notifications);
     return id;
   }
   return 0;
 }
 
 bool AndroidProviderBackend::DeleteHistoryAndBookmarks(
     const std::string& selection,
@@ skipping 160 matching lines @@
 
   if (!favicon->urls.empty())
     notifications->push_back(HistoryNotification(
         chrome::NOTIFICATION_FAVICON_CHANGED, favicon.release()));
 
   return true;
 }
 
 AndroidURLID AndroidProviderBackend::InsertHistoryAndBookmark(
     const HistoryAndBookmarkRow& values,
-    HistoryNotifications* notifications) {
+    HistoryNotifications* notifications,
+    bool ensure_initialized_and_updated) {
   if (!IsHistoryAndBookmarkRowValid(values))
     return false;
 
-  if (!EnsureInitializedAndUpdated())
+  if (ensure_initialized_and_updated && !EnsureInitializedAndUpdated())
     return 0;
 
   DCHECK(values.is_value_set_explicitly(HistoryAndBookmarkRow::URL));
   // Make a copy of values as we need change it during insert.
   HistoryAndBookmarkRow row = values;
   for (std::vector<SQLHandler*>::iterator i =
        sql_handlers_.begin(); i != sql_handlers_.end(); ++i) {
     if (!(*i)->Insert(&row))
       return 0;
   }
@@ skipping 74 matching lines @@
   for (TableIDRows::const_iterator i = ids_set.begin(); i != ids_set.end();
        ++i) {
     if (i->bookmarked) {
       AndroidURLRow android_url_row;
       if (!history_db_->GetAndroidURLRow(i->url_id, &android_url_row))
         return false;
       HistoryAndBookmarkRow row;
       row.set_raw_url(android_url_row.raw_url);
       row.set_url(i->url);
       // Set the visit time to the UnixEpoch since that's when the Android
-      // system time starts.
+      // system time starts. The Android have a CTS testcase for this.
       row.set_last_visit_time(Time::UnixEpoch());
       row.set_visit_count(0);
       // We don't want to change the bookmark model, so set_is_bookmark() is
       // not called.
       bookmarks.push_back(row);
     }
   }
 
   // Don't delete the bookmark from bookmark model when deleting the history.
   if (!DeleteHistoryInternal(ids_set, false, notifications))
     return false;
 
   for (std::vector<HistoryAndBookmarkRow>::const_iterator i = bookmarks.begin();
        i != bookmarks.end(); ++i) {
-    if (!InsertHistoryAndBookmark(*i, notifications))
+    // Don't update the tables, otherwise, the bookmarks will be added to
+    // database during UpdateBookmark(), then the insertion will fail.
+    // We can't rely on UpdateBookmark() to insert the bookmarks into history
+    // database as the raw_url will be lost.
+    if (!InsertHistoryAndBookmark(*i, notifications, false))
       return false;
   }
-
   return true;
 }
 
 AndroidStatement* AndroidProviderBackend::QuerySearchTerms(
     const std::vector<SearchRow::ColumnID>& projections,
     const std::string& selection,
     const std::vector<string16>& selection_args,
     const std::string& sort_order) {
   if (projections.empty())
     return NULL;
@@ skipping 264 matching lines @@
   std::vector<BookmarkService::URLAndTitle> bookmarks;
   bookmark_service_->GetBookmarks(&bookmarks);
 
   if (bookmarks.empty())
     return true;
 
   std::vector<URLID> url_ids;
   for (std::vector<BookmarkService::URLAndTitle>::const_iterator i =
            bookmarks.begin(); i != bookmarks.end(); ++i) {
     URLID url_id = history_db_->GetRowForURL(i->url, NULL);
-    if (url_id == 0)
-      // TODO(michaelbai): Add a row to url and android_url table as the
-      // bookmark could be added manually by user or insertted by sync.
-      continue;
-
+    if (url_id == 0) {
+      URLRow url_row(i->url);
+      url_row.set_title(i->title);
+      // Set the visit time to the UnixEpoch since that's when the Android
+      // system time starts. The Android have a CTS testcase for this.
+      url_row.set_last_visit(Time::UnixEpoch());
+      url_row.set_hidden(true);
+      url_id = history_db_->AddURL(url_row);
+      if (url_id == 0) {
+        LOG(ERROR) << "Can not add url for the new bookmark";
+        return false;
+      }
+      if (!history_db_->AddAndroidURLRow(i->url.spec(), url_id))
+        return false;
+      if (!history_db_->AddBookmarkCacheRow(Time::UnixEpoch(),
+                            Time::UnixEpoch(), url_id))
+        return false;
+    }
     url_ids.push_back(url_id);
   }
 
   return history_db_->MarkURLsAsBookmarked(url_ids);
 }
 
 bool AndroidProviderBackend::UpdateFavicon() {
   ThumbnailDatabase::IconMappingEnumerator enumerator;
   if (!thumbnail_db_->InitIconMappingEnumerator(FAVICON, &enumerator))
     return false;
@@ skipping 370 matching lines @@
       return false;
 
     if (!history_db_->SetKeywordSearchTermsForURL(bookmark_row.url_id(),
                           values.template_url_id(), values.search_term()))
       return false;
   }
   return true;
 }
 
 }  // namespace history