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 574 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 92 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_