Completed the code path from AndroidProviderService to HistoryBackend.

chrome/browser/history/history.h

 // 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.
 
 #ifndef CHROME_BROWSER_HISTORY_HISTORY_H_
 #define CHROME_BROWSER_HISTORY_HISTORY_H_
 #pragma once
 
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list_threadsafe.h"
 #include "base/string16.h"
 #include "chrome/browser/cancelable_request.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/search_engines/template_url_id.h"
 #include "chrome/common/ref_counted_util.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/common/page_transition_types.h"
 #include "sql/init_status.h"
 
+#if defined(OS_ANDROID)
+#include "chrome/browser/history/android/android_history_provider_service.h"
+#endif
+
 class BookmarkService;
 class FilePath;
 class GURL;
 class HistoryURLProvider;
 struct HistoryURLProviderParams;
 class PageUsageData;
 class PageUsageRequest;
 class Profile;
 
 namespace base {
@@ skipping 571 matching lines @@
   // These are not currently used, hopefully we can do something in the future
   // to ensure that the most important things happen first.
   enum SchedulePriority {
     PRIORITY_UI,      // The highest priority (must respond to UI events).
     PRIORITY_NORMAL,  // Normal stuff like adding a page.
     PRIORITY_LOW,     // Low priority things like indexing or expiration.
   };
 
  private:
   class BackendDelegate;
+#if defined(OS_ANDROID)
+  friend class AndroidHistoryProviderService;
+#endif
   friend class base::RefCountedThreadSafe<HistoryService>;
   friend class BackendDelegate;
   friend class FaviconService;
   friend class history::HistoryBackend;
   friend class history::HistoryQueryTest;
   friend class HistoryOperation;
   friend class HistoryURLProvider;
   friend class HistoryURLProviderTest;
   friend class history::InMemoryURLIndexTest;
   template<typename Info, typename Callback> friend class DownloadRequest;
@@ skipping 166 matching lines @@
     DCHECK(thread_) << "History service being called after cleanup";
     LoadBackendIfNecessary();
     if (consumer)
       AddRequest(request, consumer);
     ScheduleTask(priority,
                  base::Bind(func, history_backend_.get(),
                             scoped_refptr<RequestType>(request), a, b, c));
     return request->handle();
   }
 
+  template<typename BackendFunc,
+           class RequestType,  // Descendant of CancelableRequstBase.
+           typename ArgA,
+           typename ArgB,
+           typename ArgC,
+           typename ArgD>
+  Handle Schedule(SchedulePriority priority,
+                  BackendFunc func,  // Function to call on the HistoryBackend.
+                  CancelableRequestConsumerBase* consumer,
+                  RequestType* request,
+                  const ArgA& a,
+                  const ArgB& b,
+                  const ArgC& c,
+                  const ArgD& d) {
+    DCHECK(thread_) << "History service being called after cleanup";
+    LoadBackendIfNecessary();
+    if (consumer)
+      AddRequest(request, consumer);
+    ScheduleTask(priority,
+                 base::Bind(func, history_backend_.get(),
+                                   scoped_refptr<RequestType>(request),
+                                   a, b, c, d));
+    return request->handle();
+  }
+
   // ScheduleAndForget ---------------------------------------------------------
   //
   // Functions for scheduling operations on the history thread that do not need
   // any callbacks and are not cancelable.
 
   template<typename BackendFunc>
   void ScheduleAndForget(SchedulePriority priority,
                          BackendFunc func) {  // Function to call on backend.
     DCHECK(thread_) << "History service being called after cleanup";
     LoadBackendIfNecessary();
@@ skipping 40 matching lines @@
                          const ArgA& a,
                          const ArgB& b,
                          const ArgC& c,
                          const ArgD& d) {
     DCHECK(thread_) << "History service being called after cleanup";
     LoadBackendIfNecessary();
     ScheduleTask(priority, base::Bind(func, history_backend_.get(),
                                       a, b, c, d));
   }
 
+#if defined(OS_ANDROID)
+  // Android Provider ---------------------------------------------------------
+  //
+  // These Android provider related methods are exposed to the
+  // AndroidHistoryProviderService. Instead of calling these methods directly
+  // you should call the respective method on the AndroidHistoryProviderService.
+
+  // Used by the AndroidHistoryProviderService to add the history and the
+  // bookmarks.
+  void InsertHistoryAndBookmark(
+      AndroidHistoryProviderService::InsertRequest* request,
+      const history::HistoryAndBookmarkRow& row);
+
+  // Used by the AndroidHistoryProviderService to query the history and the
+  // bookmarks.
+  void QueryHistoryAndBookmarks(
+      AndroidHistoryProviderService::QueryRequest* request,
+      const std::vector<history::HistoryAndBookmarkRow::ColumnID>& projections,
+      const std::string& selection,
+      const std::vector<string16>& selection_args,
+      const std::string& sort_order);
+
+  // Used by the AndroidHistoryProviderService to update the history and the
+  // bookmarks.
+  void UpdateHistoryAndBookmarks(
+      AndroidHistoryProviderService::UpdateRequest* request,
+      const history::HistoryAndBookmarkRow& row,
+      const std::string& selection,
+      const std::vector<string16>& selection_args);
+
+  // Used by the AndroidHistoryProviderService to delete the history and the
+  // bookmarks.
+  void DeleteHistoryAndBookmarks(
+      AndroidHistoryProviderService::DeleteRequest* request,
+      const std::string& selection,
+      const std::vector<string16>& selection_args);
+
+  // Used by the AndroidHistoryProviderService to delete the history.
+  void DeleteHistory(AndroidHistoryProviderService::DeleteRequest* request,
+                     const std::string& selection,
+                     const std::vector<string16>& selection_args);
+
+  // Used by the AndroidHistoryProviderService to move the given |statement|'s
+  // current row to |destination|.
+  void MoveStatement(
+      AndroidHistoryProviderService::MoveStatementRequest* request,
+      history::AndroidStatement* statement,
+      int current_pos,
+      int destination);
+
+  // Used by the AndroidHistoryProviderService to close the statement in db
+  // thread.
+  void CloseStatement(history::AndroidStatement* statement);
+
+  // Used by the AndroidHistoryProviderService to add the search term.
+  void InsertSearchTerm(AndroidHistoryProviderService::InsertRequest* request,
+                        const history::SearchRow& row);
+
+  // Used by the AndroidHistoryProviderService to update the search terms.
+  void UpdateSearchTerms(AndroidHistoryProviderService::UpdateRequest* request,
+                         const history::SearchRow& row,
+                         const std::string& selection,
+                         const std::vector<string16>& selection_arg);
+
+  // Used by the AndroidHistoryProviderService to delete the search terms.
+  void DeleteSearchTerms(AndroidHistoryProviderService::DeleteRequest* request,
+                         const std::string& selection,
+                         const std::vector<string16>& selection_arg);
+
+  // Used by the AndroidHistoryProviderService to query the search terms.
+  void QuerySearchTerms(
+      AndroidHistoryProviderService::QueryRequest* request,
+      const std::vector<history::SearchRow::ColumnID>& projections,
+      const std::string& selection,
+      const std::vector<string16>& selection_args,
+      const std::string& sort_order);
+
+#endif  // defined(OS_ANDROID)
+
   content::NotificationRegistrar registrar_;
 
   // Some void primitives require some internal processing in the main thread
   // when done. We use this internal consumer for this purpose.
   CancelableRequestConsumer internal_consumer_;
 
   // The thread used by the history service to run complicated operations.
   // |thread_| is NULL once |Cleanup| is NULL.
   base::Thread* thread_;
 
@@ skipping 32 matching lines @@
   // The index used for quick history lookups.
   scoped_ptr<history::InMemoryURLIndex> in_memory_url_index_;
 
   scoped_refptr<ObserverListThreadSafe<history::VisitDatabaseObserver> >
       visit_database_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryService);
 };
 
 #endif  // CHROME_BROWSER_HISTORY_HISTORY_H_