Change HistoryService::QueryURL to use CancelableTaskTracker

chrome/browser/custom_home_pages_table_model.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/custom_home_pages_table_model.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/i18n/rtl.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
@@ skipping 26 matching lines @@
       return false;
     }
   }
 
   return true;
 }
 
 }  // namespace
 
 struct CustomHomePagesTableModel::Entry {
-  Entry() : title_handle(0) {}
+  Entry() : task_id(base::CancelableTaskTracker::kBadTaskId) {}
 
   // URL of the page.
   GURL url;
 
   // Page title.  If this is empty, we'll display the URL as the entry.
   base::string16 title;
 
-  // If non-zero, indicates we're loading the title for the page.
-  HistoryService::Handle title_handle;
+  // If not |base::CancelableTaskTracker::kBadTaskId|, indicates we're loading
+  // the title for the page.
+  base::CancelableTaskTracker::TaskId task_id;
 };
 
 CustomHomePagesTableModel::CustomHomePagesTableModel(Profile* profile)
     : profile_(profile),
       observer_(NULL) {
 }
 
 CustomHomePagesTableModel::~CustomHomePagesTableModel() {
 }
 
@@ skipping 74 matching lines @@
   LoadTitle(&(entries_[index]));
   if (observer_)
     observer_->OnItemsAdded(index, 1);
 }
 
 void CustomHomePagesTableModel::Remove(int index) {
   DCHECK(index >= 0 && index < RowCount());
   Entry* entry = &(entries_[index]);
   // Cancel any pending load requests now so we don't deref a bogus pointer when
   // we get the loaded notification.
-  if (entry->title_handle) {
-    HistoryService* history_service = HistoryServiceFactory::GetForProfile(
-        profile_, Profile::EXPLICIT_ACCESS);
-    if (history_service)
-      history_service->CancelRequest(entry->title_handle);
+  if (entry->task_id != base::CancelableTaskTracker::kBadTaskId) {
+    task_tracker_.TryCancel(entry->task_id);
+    entry->task_id = base::CancelableTaskTracker::kBadTaskId;
   }
   entries_.erase(entries_.begin() + static_cast<size_t>(index));
   if (observer_)
     observer_->OnItemsRemoved(index, 1);
 }
 
 void CustomHomePagesTableModel::SetToCurrentlyOpenPages() {
   // Remove the current entries.
   while (RowCount())
     Remove(0);
@@ skipping 40 matching lines @@
 }
 
 void CustomHomePagesTableModel::SetObserver(ui::TableModelObserver* observer) {
   observer_ = observer;
 }
 
 void CustomHomePagesTableModel::LoadTitle(Entry* entry) {
     HistoryService* history_service = HistoryServiceFactory::GetForProfile(
         profile_, Profile::EXPLICIT_ACCESS);
   if (history_service) {
-    entry->title_handle = history_service->QueryURL(entry->url, false,
-        &history_query_consumer_,
+    entry->task_id = history_service->QueryURL(
+        entry->url,
+        false,
         base::Bind(&CustomHomePagesTableModel::OnGotTitle,
-                   base::Unretained(this)));
+                   base::Unretained(this),
+                   entry->url),
+        &task_tracker_);
   }
 }
 
-void CustomHomePagesTableModel::OnGotTitle(HistoryService::Handle handle,
+void CustomHomePagesTableModel::OnGotTitle(const GURL& entry_url,
                                            bool found_url,
-                                           const history::URLRow* row,
-                                           history::VisitVector* visits) {
-  int entry_index;
-  Entry* entry =
-      GetEntryByLoadHandle(&Entry::title_handle, handle, &entry_index);
+                                           const history::URLRow& row,
+                                           const history::VisitVector& visits) {
+  int entry_index = 0;
+  Entry* entry = NULL;
+  for (size_t i = 0; i < entries_.size(); ++i) {
+    if (entries_[i].url == entry_url) {
+      entry = &entries_[i];
+      entry_index = i;
+      break;
+    }
+  }
   if (!entry) {
     // The URLs changed before we were called back.
     return;
   }
-  entry->title_handle = 0;
-  if (found_url && !row->title().empty()) {
-    entry->title = row->title();
+  entry->task_id = base::CancelableTaskTracker::kBadTaskId;
+  if (found_url && !row.title().empty()) {
+    entry->title = row.title();
     if (observer_)
       observer_->OnItemsChanged(static_cast<int>(entry_index), 1);

[Scott Hess - ex-Googler, 2014/06/12 18:04:35]

This case seems wrong ... but assigning a size_t to an int above also seems
wrong.  Maybe entry_index should be a size_t?

   }
 }
 
-CustomHomePagesTableModel::Entry*
-    CustomHomePagesTableModel::GetEntryByLoadHandle(
-    CancelableRequestProvider::Handle Entry::* member,
-    CancelableRequestProvider::Handle handle,
-    int* index) {
-  for (size_t i = 0; i < entries_.size(); ++i) {
-    if (entries_[i].*member == handle) {
-      *index = static_cast<int>(i);
-      return &entries_[i];
-    }
-  }
-  return NULL;
-}
-
 base::string16 CustomHomePagesTableModel::FormattedURL(int row) const {
   std::string languages =
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
   base::string16 url = net::FormatUrl(entries_[row].url, languages);
   url = base::i18n::GetDisplayStringInLTRDirectionality(url);
   return url;
 }