Completed the code path from AndroidProviderService to HistoryBackend.

chrome/browser/history/history_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/history_backend.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <vector>
@@ skipping 18 matching lines @@
 #include "chrome/browser/history/visit_filter.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/download_persistent_store_info.h"
 #include "googleurl/src/gurl.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/base/registry_controlled_domain.h"
 
+#if defined(OS_ANDROID)
+#include "chrome/browser/history/android/android_provider_backend.h"
+#endif
+
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 /* The HistoryBackend consists of a number of components:
 
     HistoryDatabase (stores past 3 months of history)
       URLDatabase (stores a list of URLs)
       DownloadDatabase (stores a list of downloads)
       VisitDatabase (stores a list of visits for the URLs)
@@ skipping 161 matching lines @@
       recent_redirects_(kMaxRedirectCount),
       backend_destroy_message_loop_(NULL),
       segment_queried_(false),
       bookmark_service_(bookmark_service) {
 }
 
 HistoryBackend::~HistoryBackend() {
   DCHECK(!scheduled_commit_) << "Deleting without cleanup";
   ReleaseDBTasks();
 
+#if defined(OS_ANDROID)
+  // Release AndroidProviderBackend before other objects.
+  android_provider_backend_.reset();
+#endif
+
   // First close the databases before optionally running the "destroy" task.
   if (db_.get()) {
     // Commit the long-running transaction.
     db_->CommitTransaction();
     db_.reset();
   }
   if (thumbnail_db_.get()) {
     thumbnail_db_->CommitTransaction();
     thumbnail_db_.reset();
   }
   if (archived_db_.get()) {
     archived_db_->CommitTransaction();
     archived_db_.reset();
   }
   if (text_database_.get()) {
     text_database_->CommitTransaction();
     text_database_.reset();
   }
 
   if (!backend_destroy_task_.is_null()) {
     // Notify an interested party (typically a unit test) that we're done.
     DCHECK(backend_destroy_message_loop_);
     backend_destroy_message_loop_->PostTask(FROM_HERE, backend_destroy_task_);
   }
+
+#if defined(OS_ANDROID)
+  file_util::Delete(GetAndroidCacheFileName(), false);
+#endif
 }
 
 void HistoryBackend::Init(const std::string& languages, bool force_fail) {
   if (!force_fail)
     InitImpl(languages);
   delegate_->DBLoaded(id_);
 }
 
 void HistoryBackend::SetOnBackendDestroyTask(MessageLoop* message_loop,
                                              const base::Closure& task) {
@@ skipping 22 matching lines @@
 }
 
 FilePath HistoryBackend::GetFaviconsFileName() const {
   return history_dir_.Append(chrome::kFaviconsFilename);
 }
 
 FilePath HistoryBackend::GetArchivedFileName() const {
   return history_dir_.Append(chrome::kArchivedHistoryFilename);
 }
 
+#if defined(OS_ANDROID)
+FilePath HistoryBackend::GetAndroidCacheFileName() const {
+  return history_dir_.Append(chrome::kAndroidCacheFilename);
+}
+#endif
+
 SegmentID HistoryBackend::GetLastSegmentID(VisitID from_visit) {
   // Set is used to detect referrer loops.  Should not happen, but can
   // if the database is corrupt.
   std::set<VisitID> visit_set;
   VisitID visit_id = from_visit;
   while (visit_id) {
     VisitRow row;
     if (!db_->GetRowForVisit(visit_id, &row))
       return 0;
     if (row.segment_id)
@@ skipping 399 matching lines @@
     archived_db_->BeginTransaction();
   if (text_database_.get())
     text_database_->BeginTransaction();
 
   // Get the first item in our database.
   db_->GetStartDate(&first_recorded_time_);
 
   // Start expiring old stuff.
   expirer_.StartArchivingOldStuff(TimeDelta::FromDays(kArchiveDaysThreshold));
 
+#if defined(OS_ANDROID)
+  if (thumbnail_db_.get()) {
+    android_provider_backend_.reset(new AndroidProviderBackend(
+        GetAndroidCacheFileName(), db_.get(), thumbnail_db_.get(),
+        bookmark_service_, delegate_.get()));
+  }
+#endif
+
   HISTOGRAM_TIMES("History.InitTime",
                   TimeTicks::Now() - beginning_time);
 }
 
 std::pair<URLID, VisitID> HistoryBackend::AddPageVisit(
     const GURL& url,
     Time time,
     VisitID referring_visit,
     content::PageTransition transition,
     VisitSource visit_source) {
@@ skipping 421 matching lines @@
   if (request->canceled())
     return;
 
   if (db_.get()) {
     db_->GetMostRecentKeywordSearchTerms(keyword_id, prefix, max_count,
                                          &(request->value));
   }
   request->ForwardResult(request->handle(), &request->value);
 }
 
+#if defined(OS_ANDROID)

[sky, 2012/04/25 15:57:25]

Move all of this into the file history_backend_android.cc

[michaelbai, 2012/04/26 05:32:48]

Done.

+
+// History and Bookmarks -------------------------------------------------------
+
+void HistoryBackend::InsertHistoryAndBookmark(
+    scoped_refptr<InsertRequest> request,
+    const HistoryAndBookmarkRow& row) {
+  if (request->canceled())
+    return;
+
+  AndroidURLID id = 0;
+  if (android_provider_backend_.get())
+    id = android_provider_backend_->InsertHistoryAndBookmark(row);
+
+  request->ForwardResult(request->handle(), id != 0, id);
+}
+
+void HistoryBackend::QueryHistoryAndBookmarks(
+    scoped_refptr<QueryRequest> request,
+    const std::vector<HistoryAndBookmarkRow::ColumnID>& projections,
+    const std::string& selection,
+    const std::vector<string16>& selection_args,
+    const std::string& sort_order) {
+  if (request->canceled())
+    return;
+
+  AndroidStatement* statement = NULL;
+  if (android_provider_backend_.get()) {
+    statement = android_provider_backend_->QueryHistoryAndBookmarks(
+        projections, selection, selection_args, sort_order);
+  }
+  request->ForwardResult(request->handle(), statement, statement);
+}
+
+void HistoryBackend::UpdateHistoryAndBookmarks(
+    scoped_refptr<UpdateRequest> request,
+    const HistoryAndBookmarkRow& row,
+    const std::string& selection,
+    const std::vector<string16>& selection_args) {
+  if (request->canceled())
+    return;
+
+  int count = 0;
+  bool result = false;
+  if (android_provider_backend_.get()) {
+    result = android_provider_backend_->UpdateHistoryAndBookmarks(row,
+        selection, selection_args, &count);
+  }
+
+  request->ForwardResult(request->handle(), result, count);
+}
+
+void HistoryBackend::DeleteHistoryAndBookmarks(
+    scoped_refptr<DeleteRequest> request,
+    const std::string& selection,
+    const std::vector<string16>& selection_args) {
+  if (request->canceled())
+    return;
+
+  int count = 0;
+  bool result = false;
+  if (android_provider_backend_.get())
+    result = android_provider_backend_->DeleteHistoryAndBookmarks(selection,
+        selection_args, &count);
+
+  request->ForwardResult(request->handle(), result, count);
+}
+
+void HistoryBackend::DeleteHistory(
+    scoped_refptr<DeleteRequest> request,
+    const std::string& selection,
+    const std::vector<string16>& selection_args) {
+  if (request->canceled())
+    return;
+
+  int count = 0;
+  bool result = false;
+  if (android_provider_backend_.get()) {
+    result = android_provider_backend_->DeleteHistory(selection, selection_args,
+                                                      &count);
+  }
+  request->ForwardResult(request->handle(), result, count);
+}
+
+// Statement -------------------------------------------------------------------
+
+void HistoryBackend::MoveStatement(
+    scoped_refptr<MoveStatementRequest> request,
+    history::AndroidStatement* statement,
+    int current_pos,
+    int destination) {
+  DCHECK_LE(-1, current_pos);
+  DCHECK_LE(-1, destination);
+
+  int cur = current_pos;
+  if (current_pos > destination) {
+    statement->statement()->ResetWithoutClearingBoundVariables();
+    cur = -1;
+  }
+  for (; cur < destination; ++cur) {
+    if (!statement->statement()->Step())
+      break;
+  }
+
+  request->ForwardResult(request->handle(), cur);
+}
+
+void HistoryBackend::CloseStatement(AndroidStatement* statement) {
+  delete statement;
+}
+
+// Search Term -----------------------------------------------------------------
+
+void HistoryBackend::InsertSearchTerm(scoped_refptr<InsertRequest> request,
+                                      const SearchRow& row) {
+  if (request->canceled())
+    return;
+
+  SearchTermID id = 0;
+  if (android_provider_backend_.get())
+    id = android_provider_backend_->InsertSearchTerm(row);
+
+  request->ForwardResult(request->handle(), id != 0, id);
+}
+
+void HistoryBackend::UpdateSearchTerms(
+    scoped_refptr<UpdateRequest> request,
+    const SearchRow& row,
+    const std::string& selection,
+    const std::vector<string16> selection_args) {
+  if (request->canceled())
+    return;
+
+  int count = 0;
+  bool result = false;
+  if (android_provider_backend_.get()) {
+    result =  android_provider_backend_->UpdateSearchTerms(row, selection,
+        selection_args, &count);
+  }
+  request->ForwardResult(request->handle(), result, count);
+}
+
+void HistoryBackend::DeleteSearchTerms(
+    scoped_refptr<DeleteRequest> request,
+    const std::string& selection,
+    const std::vector<string16> selection_args) {
+  if (request->canceled())
+    return;
+
+  int count = 0;
+  bool result = false;
+  if (android_provider_backend_.get()) {
+    result = android_provider_backend_->DeleteSearchTerms(selection,
+        selection_args, &count);
+  }
+
+  request->ForwardResult(request->handle(), result, count);
+}
+
+void HistoryBackend::QuerySearchTerms(
+    scoped_refptr<QueryRequest> request,
+    const std::vector<SearchRow::ColumnID>& projections,
+    const std::string& selection,
+    const std::vector<string16>& selection_args,
+    const std::string& sort_order) {
+  if (request->canceled())
+    return;
+
+  AndroidStatement* statement = NULL;
+  if (android_provider_backend_.get())
+    statement = android_provider_backend_->QuerySearchTerms(projections,
+        selection, selection_args, sort_order);
+
+  request->ForwardResult(request->handle(), statement, statement);
+}
+
+#endif  // defined(OS_ANDROID)
+
 // Downloads -------------------------------------------------------------------
 
 void HistoryBackend::GetNextDownloadId(
     scoped_refptr<DownloadNextIdRequest> request) {
   if (request->canceled()) return;
   if (db_.get()) {
     request->value = db_->next_download_id();
   } else {
     request->value = 0;
   }
@@ skipping 1315 matching lines @@
     return false;
 
   favicon->expired = (Time::Now() - last_updated) >
       TimeDelta::FromDays(kFaviconRefetchDays);
   favicon->known_icon = true;
   favicon->image_data = data;
   return true;
 }
 
 }  // namespace history