Code cleanup

chrome/browser/android/provider/chrome_browser_provider.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/android/provider/chrome_browser_provider.h"
 
 #include <cmath>
 #include <list>
 #include <utility>
 
@@ skipping 614 matching lines @@
 };
 
 // ------------- Aynchronous requests classes ------------- //
 
 // Base class for asynchronous blocking requests to Chromium services.
 // Service: type of the service to use (e.g. HistoryService, FaviconService).
 template <typename Service>
 class AsyncServiceRequest : protected BlockingUIThreadAsyncRequest {
  public:
   AsyncServiceRequest(Service* service,
-                      CancelableRequestConsumer* cancelable_consumer,
                       base::CancelableTaskTracker* cancelable_tracker)
-      : service_(service),
-        cancelable_consumer_(cancelable_consumer),
-        cancelable_tracker_(cancelable_tracker) {}
+      : service_(service), cancelable_tracker_(cancelable_tracker) {}
 
   Service* service() const { return service_; }
 
-  CancelableRequestConsumer* cancelable_consumer() const {
-    return cancelable_consumer_;
-  }
-
   base::CancelableTaskTracker* cancelable_tracker() const {
     return cancelable_tracker_;
   }
 
  private:
   Service* service_;
-  CancelableRequestConsumer* cancelable_consumer_;
   base::CancelableTaskTracker* cancelable_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncServiceRequest);
 };
 
 // Base class for all asynchronous blocking tasks that use the favicon service.
 class FaviconServiceTask : public AsyncServiceRequest<FaviconService> {
  public:
   FaviconServiceTask(FaviconService* service,
-                     Profile* profile,
-                     CancelableRequestConsumer* cancelable_consumer,
-                     base::CancelableTaskTracker* cancelable_tracker)
-      : AsyncServiceRequest<FaviconService>(service,
-                                            cancelable_consumer,
-                                            cancelable_tracker),
+                     base::CancelableTaskTracker* cancelable_tracker,
+                     Profile* profile)
+      : AsyncServiceRequest<FaviconService>(service, cancelable_tracker),
         profile_(profile) {}
 
   Profile* profile() const { return profile_; }
 
  private:
   Profile* profile_;
 
   DISALLOW_COPY_AND_ASSIGN(FaviconServiceTask);
 };
 
 // Retrieves the favicon or touch icon for a URL from the FaviconService.
 class BookmarkIconFetchTask : public FaviconServiceTask {
  public:
   BookmarkIconFetchTask(FaviconService* favicon_service,
-                        Profile* profile,
-                        CancelableRequestConsumer* cancelable_consumer,
-                        base::CancelableTaskTracker* cancelable_tracker)
-      : FaviconServiceTask(favicon_service,
-                           profile,
-                           cancelable_consumer,
-                           cancelable_tracker) {}
+                        base::CancelableTaskTracker* cancelable_tracker,
+                        Profile* profile)
+      : FaviconServiceTask(favicon_service, cancelable_tracker, profile) {}
 
   favicon_base::FaviconRawBitmapResult Run(const GURL& url) {
     float max_scale = ui::GetScaleForScaleFactor(
         ResourceBundle::GetSharedInstance().GetMaxScaleFactor());
     int desired_size_in_pixel = std::ceil(gfx::kFaviconSize * max_scale);
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&FaviconService::GetRawFaviconForPageURL,
                    base::Unretained(service()),
                    url,
                    favicon_base::FAVICON | favicon_base::TOUCH_ICON,
@@ skipping 15 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkIconFetchTask);
 };
 
 // Base class for all asynchronous blocking tasks that use the Android history
 // provider service.
 class HistoryProviderTask
     : public AsyncServiceRequest<AndroidHistoryProviderService> {
  public:
   HistoryProviderTask(AndroidHistoryProviderService* service,
-                      CancelableRequestConsumer* cancelable_consumer,
                       base::CancelableTaskTracker* cancelable_tracker)
       : AsyncServiceRequest<AndroidHistoryProviderService>(service,
-                                                           cancelable_consumer,
                                                            cancelable_tracker) {
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HistoryProviderTask);
 };
 
 // Adds a bookmark from the API.
 class AddBookmarkFromAPITask : public HistoryProviderTask {
  public:
   AddBookmarkFromAPITask(AndroidHistoryProviderService* service,
-                         CancelableRequestConsumer* cancelable_consumer,
                          base::CancelableTaskTracker* cancelable_tracker)
-      : HistoryProviderTask(service, cancelable_consumer, cancelable_tracker) {}
+      : HistoryProviderTask(service, cancelable_tracker) {}
 
   history::URLID Run(const history::HistoryAndBookmarkRow& row) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::InsertHistoryAndBookmark,
                    base::Unretained(service()),
                    row,
                    base::Bind(&AddBookmarkFromAPITask::OnBookmarkInserted,
                               base::Unretained(this)),
                    cancelable_tracker()));
     return result_;
   }
 
  private:
   void OnBookmarkInserted(history::URLID id) {
     // Note that here 0 means an invalid id.
     // This is because it represents a SQLite database row id.
     result_ = id;
     RequestCompleted();
   }
 
   history::URLID result_;
 
   DISALLOW_COPY_AND_ASSIGN(AddBookmarkFromAPITask);
 };
 
 // Queries bookmarks from the API.
 class QueryBookmarksFromAPITask : public HistoryProviderTask {
  public:
   QueryBookmarksFromAPITask(AndroidHistoryProviderService* service,
-                            CancelableRequestConsumer* cancelable_consumer,
                             base::CancelableTaskTracker* cancelable_tracker)
-      : HistoryProviderTask(service, cancelable_consumer, cancelable_tracker),
-        result_(NULL) {}
+      : HistoryProviderTask(service, cancelable_tracker), result_(NULL) {}
 
   history::AndroidStatement* Run(
       const std::vector<history::HistoryAndBookmarkRow::ColumnID>& projections,
       const std::string& selection,
       const std::vector<base::string16>& selection_args,
       const std::string& sort_order) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::QueryHistoryAndBookmarks,
                    base::Unretained(service()),
                    projections,
@@ skipping 14 matching lines @@
 
   history::AndroidStatement* result_;
 
   DISALLOW_COPY_AND_ASSIGN(QueryBookmarksFromAPITask);
 };
 
 // Updates bookmarks from the API.
 class UpdateBookmarksFromAPITask : public HistoryProviderTask {
  public:
   UpdateBookmarksFromAPITask(AndroidHistoryProviderService* service,
-                             CancelableRequestConsumer* cancelable_consumer,
                              base::CancelableTaskTracker* cancelable_tracker)
-      : HistoryProviderTask(service, cancelable_consumer, cancelable_tracker),
-        result_(0) {}
+      : HistoryProviderTask(service, cancelable_tracker), result_(0) {}
 
   int Run(const history::HistoryAndBookmarkRow& row,
           const std::string& selection,
           const std::vector<base::string16>& selection_args) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::UpdateHistoryAndBookmarks,
                    base::Unretained(service()),
                    row,
                    selection,
                    selection_args,
@@ skipping 11 matching lines @@
 
   int result_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateBookmarksFromAPITask);
 };
 
 // Removes bookmarks from the API.
 class RemoveBookmarksFromAPITask : public HistoryProviderTask {
  public:
   RemoveBookmarksFromAPITask(AndroidHistoryProviderService* service,
-                             CancelableRequestConsumer* cancelable_consumer,
                              base::CancelableTaskTracker* cancelable_tracker)
-      : HistoryProviderTask(service, cancelable_consumer, cancelable_tracker),
-        result_(0) {}
+      : HistoryProviderTask(service, cancelable_tracker), result_(0) {}
 
   int Run(const std::string& selection,
           const std::vector<base::string16>& selection_args) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::DeleteHistoryAndBookmarks,
                    base::Unretained(service()),
                    selection,
                    selection_args,
                    base::Bind(&RemoveBookmarksFromAPITask::OnBookmarksRemoved,
                               base::Unretained(this)),
                    cancelable_tracker()));
     return result_;
   }
 
  private:
   void OnBookmarksRemoved(int removed_row_count) {
     result_ = removed_row_count;
     RequestCompleted();
   }
 
   int result_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveBookmarksFromAPITask);
 };
 
 // Removes history from the API.
 class RemoveHistoryFromAPITask : public HistoryProviderTask {
  public:
   RemoveHistoryFromAPITask(AndroidHistoryProviderService* service,
-                           CancelableRequestConsumer* cancelable_consumer,
                            base::CancelableTaskTracker* cancelable_tracker)
-      : HistoryProviderTask(service, cancelable_consumer, cancelable_tracker),
-        result_(0) {}
+      : HistoryProviderTask(service, cancelable_tracker), result_(0) {}
 
   int Run(const std::string& selection,
           const std::vector<base::string16>& selection_args) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::DeleteHistory,
                    base::Unretained(service()),
                    selection,
                    selection_args,
                    base::Bind(&RemoveHistoryFromAPITask::OnHistoryRemoved,
                               base::Unretained(this)),
                    cancelable_tracker()));
     return result_;
   }
 
  private:
   void OnHistoryRemoved(int removed_row_count) {
     result_ = removed_row_count;
     RequestCompleted();
   }
 
   int result_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveHistoryFromAPITask);
 };
 
 // This class provides the common method for the SearchTermAPIHelper.
 class SearchTermTask : public HistoryProviderTask {
  protected:
   SearchTermTask(AndroidHistoryProviderService* service,
-                 CancelableRequestConsumer* cancelable_consumer,
                  base::CancelableTaskTracker* cancelable_tracker,
                  Profile* profile)
-      : HistoryProviderTask(service, cancelable_consumer, cancelable_tracker),
-        profile_(profile) {}
+      : HistoryProviderTask(service, cancelable_tracker), profile_(profile) {}
 
   // Fill SearchRow's keyword_id and url fields according the given
   // search_term. Return true if succeeded.
   void BuildSearchRow(history::SearchRow* row) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     TemplateURLService* template_service =
         TemplateURLServiceFactory::GetForProfile(profile_);
     template_service->Load();
 
@@ skipping 15 matching lines @@
  private:
   Profile* profile_;
 
   DISALLOW_COPY_AND_ASSIGN(SearchTermTask);
 };
 
 // Adds a search term from the API.
 class AddSearchTermFromAPITask : public SearchTermTask {
  public:
   AddSearchTermFromAPITask(AndroidHistoryProviderService* service,
-                           CancelableRequestConsumer* cancelable_consumer,
                            base::CancelableTaskTracker* cancelable_tracker,
                            Profile* profile)
-      : SearchTermTask(service,
-                       cancelable_consumer,
-                       cancelable_tracker,
-                       profile) {}
+      : SearchTermTask(service, cancelable_tracker, profile) {}
 
   history::URLID Run(const history::SearchRow& row) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AddSearchTermFromAPITask::MakeRequestOnUIThread,
                    base::Unretained(this), row));
     return result_;
   }
 
  private:
   void MakeRequestOnUIThread(const history::SearchRow& row) {
@@ skipping 16 matching lines @@
 
   history::URLID result_;
 
   DISALLOW_COPY_AND_ASSIGN(AddSearchTermFromAPITask);
 };
 
 // Queries search terms from the API.
 class QuerySearchTermsFromAPITask : public SearchTermTask {
  public:
   QuerySearchTermsFromAPITask(AndroidHistoryProviderService* service,
-                              CancelableRequestConsumer* cancelable_consumer,
                               base::CancelableTaskTracker* cancelable_tracker,
                               Profile* profile)
-      : SearchTermTask(service,
-                       cancelable_consumer,
-                       cancelable_tracker,
-                       profile),
-        result_(NULL) {}
+      : SearchTermTask(service, cancelable_tracker, profile), result_(NULL) {}
 
   history::AndroidStatement* Run(
       const std::vector<history::SearchRow::ColumnID>& projections,
       const std::string& selection,
       const std::vector<base::string16>& selection_args,
       const std::string& sort_order) {
     RunAsyncRequestOnUIThreadBlocking(base::Bind(
         &AndroidHistoryProviderService::QuerySearchTerms,
         base::Unretained(service()),
         projections,
@@ skipping 15 matching lines @@
 
   history::AndroidStatement* result_;
 
   DISALLOW_COPY_AND_ASSIGN(QuerySearchTermsFromAPITask);
 };
 
 // Updates search terms from the API.
 class UpdateSearchTermsFromAPITask : public SearchTermTask {
  public:
   UpdateSearchTermsFromAPITask(AndroidHistoryProviderService* service,
-                               CancelableRequestConsumer* cancelable_consumer,
                                base::CancelableTaskTracker* cancelable_tracker,
                                Profile* profile)
-      : SearchTermTask(service,
-                       cancelable_consumer,
-                       cancelable_tracker,
-                       profile),
-        result_(0) {}
+      : SearchTermTask(service, cancelable_tracker, profile), result_(0) {}
 
   int Run(const history::SearchRow& row,
           const std::string& selection,
           const std::vector<base::string16>& selection_args) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&UpdateSearchTermsFromAPITask::MakeRequestOnUIThread,
                    base::Unretained(this), row, selection, selection_args));
     return result_;
   }
 
@@ skipping 21 matching lines @@
 
   int result_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateSearchTermsFromAPITask);
 };
 
 // Removes search terms from the API.
 class RemoveSearchTermsFromAPITask : public SearchTermTask {
  public:
   RemoveSearchTermsFromAPITask(AndroidHistoryProviderService* service,
-                               CancelableRequestConsumer* cancelable_consumer,
                                base::CancelableTaskTracker* cancelable_tracker,
                                Profile* profile)
-      : SearchTermTask(service,
-                       cancelable_consumer,
-                       cancelable_tracker,
-                       profile),
-        result_() {}
+      : SearchTermTask(service, cancelable_tracker, profile), result_() {}
 
   int Run(const std::string& selection,
           const std::vector<base::string16>& selection_args) {
     RunAsyncRequestOnUIThreadBlocking(base::Bind(
         &AndroidHistoryProviderService::DeleteSearchTerms,
         base::Unretained(service()),
         selection,
         selection_args,
         base::Bind(&RemoveSearchTermsFromAPITask::OnSearchTermsDeleted,
                    base::Unretained(this)),
@@ skipping 184 matching lines @@
   history::HistoryAndBookmarkRow row;
   FillBookmarkRow(env, obj, url, created, isBookmark, date, favicon, title,
                   visits, parent_id, &row, bookmark_model_);
 
   // URL must be valid.
   if (row.url().is_empty()) {
     LOG(ERROR) << "Not a valid URL " << row.raw_url();
     return kInvalidContentProviderId;
   }
 
-  AddBookmarkFromAPITask task(
-      service_.get(), &android_history_consumer_, &cancelable_task_tracker_);
+  AddBookmarkFromAPITask task(service_.get(), &cancelable_task_tracker_);
   return task.Run(row);
 }
 
 ScopedJavaLocalRef<jobject> ChromeBrowserProvider::QueryBookmarkFromAPI(
     JNIEnv* env,
     jobject obj,
     jobjectArray projection,
     jstring selections,
     jobjectArray selection_args,
     jstring sort_order) {
@@ skipping 25 matching lines @@
   std::string where_clause;
   if (selections) {
     where_clause = ConvertJavaStringToUTF8(env, selections);
   }
 
   std::string sort_clause;
   if (sort_order) {
     sort_clause = ConvertJavaStringToUTF8(env, sort_order);
   }
 
-  QueryBookmarksFromAPITask task(
-      service_.get(), &android_history_consumer_, &cancelable_task_tracker_);
+  QueryBookmarksFromAPITask task(service_.get(), &cancelable_task_tracker_);
   history::AndroidStatement* statement = task.Run(
       query_columns, where_clause, where_args, sort_clause);
   if (!statement)
     return ScopedJavaLocalRef<jobject>();
 
   // Creates and returns org.chromium.chrome.browser.database.SQLiteCursor
   // Java object.
   return SQLiteCursor::NewJavaSqliteCursor(env, columns_name, statement,
              service_.get(), favicon_service_.get());
 }
@@ skipping 16 matching lines @@
   FillBookmarkRow(env, obj, url, created, isBookmark, date, favicon, title,
                   visits, parent_id, &row, bookmark_model_);
 
   std::vector<base::string16> where_args =
       ConvertJStringArrayToString16Array(env, selection_args);
 
   std::string where_clause;
   if (selections)
     where_clause = ConvertJavaStringToUTF8(env, selections);
 
-  UpdateBookmarksFromAPITask task(
-      service_.get(), &android_history_consumer_, &cancelable_task_tracker_);
+  UpdateBookmarksFromAPITask task(service_.get(), &cancelable_task_tracker_);
   return task.Run(row, where_clause, where_args);
 }
 
 jint ChromeBrowserProvider::RemoveBookmarkFromAPI(JNIEnv* env,
                                                   jobject obj,
                                                   jstring selections,
                                                   jobjectArray selection_args) {
   std::vector<base::string16> where_args =
       ConvertJStringArrayToString16Array(env, selection_args);
 
   std::string where_clause;
   if (selections)
     where_clause = ConvertJavaStringToUTF8(env, selections);
 
-  RemoveBookmarksFromAPITask task(
-      service_.get(), &android_history_consumer_, &cancelable_task_tracker_);
+  RemoveBookmarksFromAPITask task(service_.get(), &cancelable_task_tracker_);
   return task.Run(where_clause, where_args);
 }
 
 jint ChromeBrowserProvider::RemoveHistoryFromAPI(JNIEnv* env,
                                                  jobject obj,
                                                  jstring selections,
                                                  jobjectArray selection_args) {
   std::vector<base::string16> where_args =
       ConvertJStringArrayToString16Array(env, selection_args);
 
   std::string where_clause;
   if (selections)
     where_clause = ConvertJavaStringToUTF8(env, selections);
 
-  RemoveHistoryFromAPITask task(
-      service_.get(), &android_history_consumer_, &cancelable_task_tracker_);
+  RemoveHistoryFromAPITask task(service_.get(), &cancelable_task_tracker_);
   return task.Run(where_clause, where_args);
 }
 
 // Add the search term with the given column values. The value is not given if
 // it is NULL.
 jlong ChromeBrowserProvider::AddSearchTermFromAPI(JNIEnv* env,
                                                   jobject obj,
                                                   jstring search_term,
                                                   jobject date) {
   DCHECK(search_term);
 
   history::SearchRow row;
   FillSearchRow(env, obj, search_term, date, &row);
 
   // URL must be valid.
   if (row.search_term().empty()) {
     LOG(ERROR) << "Search term is empty.";
     return kInvalidContentProviderId;
   }
 
   AddSearchTermFromAPITask task(service_.get(),
-                                &android_history_consumer_,
                                 &cancelable_task_tracker_,
                                 profile_);
   return task.Run(row);
 }
 
 ScopedJavaLocalRef<jobject> ChromeBrowserProvider::QuerySearchTermFromAPI(
     JNIEnv* env,
     jobject obj,
     jobjectArray projection,
     jstring selections,
@@ skipping 27 matching lines @@
   if (selections) {
     where_clause = ConvertJavaStringToUTF8(env, selections);
   }
 
   std::string sort_clause;
   if (sort_order) {
     sort_clause = ConvertJavaStringToUTF8(env, sort_order);
   }
 
   QuerySearchTermsFromAPITask task(service_.get(),
-                                   &android_history_consumer_,
                                    &cancelable_task_tracker_,
                                    profile_);
   history::AndroidStatement* statement = task.Run(
       query_columns, where_clause, where_args, sort_clause);
   if (!statement)
     return ScopedJavaLocalRef<jobject>();
   // Creates and returns org.chromium.chrome.browser.database.SQLiteCursor
   // Java object.
   return SQLiteCursor::NewJavaSqliteCursor(env, columns_name, statement,
              service_.get(), favicon_service_.get());
 }
 
 // Updates the search terms with the given column values. The value is not
 // given if it is NULL.
 jint ChromeBrowserProvider::UpdateSearchTermFromAPI(
     JNIEnv* env, jobject obj, jstring search_term, jobject date,
     jstring selections, jobjectArray selection_args) {
   history::SearchRow row;
   FillSearchRow(env, obj, search_term, date, &row);
 
   std::vector<base::string16> where_args = ConvertJStringArrayToString16Array(
       env, selection_args);
 
   std::string where_clause;
   if (selections)
     where_clause = ConvertJavaStringToUTF8(env, selections);
 
   UpdateSearchTermsFromAPITask task(service_.get(),
-                                    &android_history_consumer_,
                                     &cancelable_task_tracker_,
                                     profile_);
   return task.Run(row, where_clause, where_args);
 }
 
 jint ChromeBrowserProvider::RemoveSearchTermFromAPI(
     JNIEnv* env, jobject obj, jstring selections, jobjectArray selection_args) {
   std::vector<base::string16> where_args =
       ConvertJStringArrayToString16Array(env, selection_args);
 
   std::string where_clause;
   if (selections)
     where_clause = ConvertJavaStringToUTF8(env, selections);
 
   RemoveSearchTermsFromAPITask task(service_.get(),
-                                    &android_history_consumer_,
                                     &cancelable_task_tracker_,
                                     profile_);
   return task.Run(where_clause, where_args);
 }
 
 // ------------- Provider custom APIs ------------- //
 
 jboolean ChromeBrowserProvider::BookmarkNodeExists(
     JNIEnv* env,
     jobject obj,
@@ skipping 57 matching lines @@
   IsInMobileBookmarksBranchTask task(bookmark_model_);
   return task.Run(id);
 }
 
 ScopedJavaLocalRef<jbyteArray> ChromeBrowserProvider::GetFaviconOrTouchIcon(
     JNIEnv* env, jobject obj, jstring jurl) {
   if (!jurl)
     return ScopedJavaLocalRef<jbyteArray>();
 
   GURL url = GURL(ConvertJavaStringToUTF16(env, jurl));
-  BookmarkIconFetchTask favicon_task(favicon_service_.get(),
-                                     profile_,
-                                     &favicon_consumer_,
-                                     &cancelable_task_tracker_);
+  BookmarkIconFetchTask favicon_task(
+      favicon_service_.get(), &cancelable_task_tracker_, profile_);
   favicon_base::FaviconRawBitmapResult bitmap_result = favicon_task.Run(url);
 
   if (!bitmap_result.is_valid() || !bitmap_result.bitmap_data.get())
     return ScopedJavaLocalRef<jbyteArray>();
 
   return base::android::ToJavaByteArray(env, bitmap_result.bitmap_data->front(),
                                         bitmap_result.bitmap_data->size());
 }
 
 ScopedJavaLocalRef<jbyteArray> ChromeBrowserProvider::GetThumbnail(
@@ skipping 53 matching lines @@
     Java_ChromeBrowserProvider_onBookmarkChanged(env, obj.obj());
   } else if (type ==
       chrome::NOTIFICATION_HISTORY_KEYWORD_SEARCH_TERM_UPDATED) {
     JNIEnv* env = AttachCurrentThread();
     ScopedJavaLocalRef<jobject> obj = weak_java_provider_.get(env);
     if (obj.is_null())
       return;
     Java_ChromeBrowserProvider_onSearchTermChanged(env, obj.obj());
   }
 }