Remove VisitedLink dependency on rest of chrome

chrome/browser/history/history.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.
 
 // The history system runs on a background thread so that potentially slow
 // database operations don't delay the browser. This backend processing is
 // represented by HistoryBackend. The HistoryService's job is to dispatch to
 // that thread.
 //
 // Main thread                       History thread
@@ skipping 93 matching lines @@
     int* id) {
   callback.Run(*id);
 }
 
 void RunWithFaviconResults(
     const FaviconService::FaviconResultsCallback& callback,
     const HistoryBackend::FaviconResults* results) {
   callback.Run(results->bitmap_results, results->size_map);
 }
 
+// Extract history::URLRows into GURLs for VisitedLinkMaster.
+class URLIteratorFromURLRows : public VisitedLinkMaster::URLIterator {
+ public:
+  explicit URLIteratorFromURLRows(const history::URLRows& url_rows)
+      : itr_(url_rows.begin()),
+        end_(url_rows.end()) {
+  }
+
+  virtual const GURL& NextURL() {
+    return (itr_++)->url();
+  }
+
+  virtual bool HasNextURL() const {
+    return itr_ != end_;
+  }
+
+ private:
+  history::URLRows::const_iterator itr_;
+  history::URLRows::const_iterator end_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLIteratorFromURLRows);
+};
+
 }  // namespace
 
 // Sends messages from the backend to us on the main thread. This must be a
 // separate class from the history service so that it can hold a reference to
 // the history service (otherwise we would have to manually AddRef and
 // Release when the Backend has a reference to us).
 class HistoryService::BackendDelegate : public HistoryBackend::Delegate {
  public:
   BackendDelegate(
       const base::WeakPtr<HistoryService>& history_service,
@@ skipping 77 matching lines @@
       current_backend_id_(-1),
       bookmark_service_(NULL),
       no_db_(false),
       needs_top_sites_migration_(false) {
 }
 
 HistoryService::HistoryService(Profile* profile)
     : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       thread_(new base::Thread(kHistoryThreadName)),
       profile_(profile),
+      visitedlink_master_(new VisitedLinkMaster(
+          profile, ALLOW_THIS_IN_INITIALIZER_LIST(this))),
       backend_loaded_(false),
       current_backend_id_(-1),
       bookmark_service_(NULL),
       no_db_(false),
       needs_top_sites_migration_(false) {
   DCHECK(profile_);
   registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URLS_DELETED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_TEMPLATE_URL_REMOVED,
                  content::Source<Profile>(profile_));
@@ skipping 244 matching lines @@
   DCHECK(thread_) << "History service being called after cleanup";
 
   // Filter out unwanted URLs. We don't add auto-subframe URLs. They are a
   // large part of history (think iframes for ads) and we never display them in
   // history UI. We will still add manual subframes, which are ones the user
   // has clicked on to get.
   if (!CanAddURL(add_page_args.url))
     return;
 
   // Add link & all redirects to visited link list.
-  VisitedLinkMaster* visited_links;
-  if (profile_ &&
-      (visited_links = VisitedLinkMaster::FromProfile(profile_))) {
-    visited_links->AddURL(add_page_args.url);
+  if (visitedlink_master_) {
+    visitedlink_master_->AddURL(add_page_args.url);
 
     if (!add_page_args.redirects.empty()) {
       // We should not be asked to add a page in the middle of a redirect chain.
       DCHECK_EQ(add_page_args.url,
                 add_page_args.redirects[add_page_args.redirects.size() - 1]);
 
       // We need the !redirects.empty() condition above since size_t is unsigned
       // and will wrap around when we subtract one from a 0 size.
       for (size_t i = 0; i < add_page_args.redirects.size() - 1; i++)
-        visited_links->AddURL(add_page_args.redirects[i]);
+        visitedlink_master_->AddURL(add_page_args.redirects[i]);
     }
   }
 
   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::AddPage, add_page_args);
 }
 
 void HistoryService::AddPageNoVisitForBookmark(const GURL& url,
                                                const string16& title) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!CanAddURL(url))
@@ skipping 24 matching lines @@
                                         int typed_count,
                                         Time last_visit,
                                         bool hidden,
                                         history::VisitSource visit_source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Filter out unwanted URLs.
   if (!CanAddURL(url))
     return;
 
   // Add to the visited links system.
-  VisitedLinkMaster* visited_links;
-  if (profile_ &&
-      (visited_links = VisitedLinkMaster::FromProfile(profile_))) {
-    visited_links->AddURL(url);
-  }
+  if (visitedlink_master_)
+    visitedlink_master_->AddURL(url);
 
   history::URLRow row(url);
   row.set_title(title);
   row.set_visit_count(visit_count);
   row.set_typed_count(typed_count);
   row.set_last_visit(last_visit);
   row.set_hidden(hidden);
 
   history::URLRows rows;
   rows.push_back(row);
 
   ScheduleAndForget(PRIORITY_NORMAL,
                     &HistoryBackend::AddPagesWithDetails, rows, visit_source);
 }
 
 void HistoryService::AddPagesWithDetails(const history::URLRows& info,
                                          history::VisitSource visit_source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Add to the visited links system.
-  VisitedLinkMaster* visited_links;
-  if (profile_ &&
-      (visited_links = VisitedLinkMaster::FromProfile(profile_))) {
+  if (visitedlink_master_) {
     std::vector<GURL> urls;
     urls.reserve(info.size());
     for (history::URLRows::const_iterator i = info.begin(); i != info.end();
          ++i)
       urls.push_back(i->url());
 
-    visited_links->AddURLs(urls);
+    visitedlink_master_->AddURLs(urls);
   }
 
   ScheduleAndForget(PRIORITY_NORMAL,
                     &HistoryBackend::AddPagesWithDetails, info, visit_source);
 }
 
 void HistoryService::SetPageContents(const GURL& url,
                                      const string16& contents) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!CanAddURL(url))
@@ skipping 136 matching lines @@
                     old_page_url, new_page_url);
 }
 
 void HistoryService::SetImportedFavicons(
     const std::vector<history::ImportedFaviconUsage>& favicon_usage) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleAndForget(PRIORITY_NORMAL,
                     &HistoryBackend::SetImportedFavicons, favicon_usage);
 }
 
-void HistoryService::IterateURLs(URLEnumerator* enumerator) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::IterateURLs, enumerator);
-}
-
 HistoryService::Handle HistoryService::QueryURL(
     const GURL& url,
     bool want_visits,
     CancelableRequestConsumerBase* consumer,
     const QueryURLCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return Schedule(PRIORITY_UI, &HistoryBackend::QueryURL, consumer,
                   new history::QueryURLRequest(callback), url, want_visits);
 }
 
@@ skipping 157 matching lines @@
     case chrome::NOTIFICATION_HISTORY_URLS_DELETED: {
       // Update the visited link system for deleted URLs. We will update the
       // visited link system for added URLs as soon as we get the add
       // notification (we don't have to wait for the backend, which allows us to
       // be faster to update the state).
       //
       // For deleted URLs, we don't typically know what will be deleted since
       // delete notifications are by time. We would also like to be more
       // respectful of privacy and never tell the user something is gone when it
       // isn't. Therefore, we update the delete URLs after the fact.
-      if (!profile_)
-        return;  // No profile, probably unit testing.
-      content::Details<history::URLsDeletedDetails> deleted_details(details);
-      VisitedLinkMaster* visited_links =
-          VisitedLinkMaster::FromProfile(profile_);
-      if (!visited_links)
-        return;  // Nobody to update.
-      if (deleted_details->all_history)
-        visited_links->DeleteAllURLs();
-      else  // Delete individual ones.
-        visited_links->DeleteURLs(deleted_details->rows);
+      if (visitedlink_master_) {
+        content::Details<history::URLsDeletedDetails> deleted_details(details);
+
+        if (deleted_details->all_history) {
+          visitedlink_master_->DeleteAllURLs();
+        } else {
+          URLIteratorFromURLRows iterator(deleted_details->rows);
+          visitedlink_master_->DeleteURLs(&iterator);
+        }
+      }
       break;
     }
 
     case chrome::NOTIFICATION_TEMPLATE_URL_REMOVED:
       DeleteAllSearchTermsForKeyword(
           *(content::Details<TemplateURLID>(details).ptr()));
       break;
 
     default:
       NOTREACHED();
   }
 }
 
+bool HistoryService::AreEquivalentContexts(content::BrowserContext* context1,
+                                           content::BrowserContext* context2) {
+  DCHECK(context1);
+  DCHECK(context2);
+
+  Profile* profile1 = Profile::FromBrowserContext(context1);
+  Profile* profile2 = Profile::FromBrowserContext(context2);
+
+  return profile1->IsSameProfile(profile2);
+}
+
+void HistoryService::RebuildTable(URLEnumerator* enumerator) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::IterateURLs, enumerator);
+}
+
 bool HistoryService::Init(const FilePath& history_dir,
                           BookmarkService* bookmark_service,
                           bool no_db) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!thread_->Start()) {
     Cleanup();
     return false;
   }
 
   history_dir_ = history_dir;
   bookmark_service_ = bookmark_service;
   no_db_ = no_db;
 
   if (profile_) {
     std::string languages =
         profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
     in_memory_url_index_.reset(
         new history::InMemoryURLIndex(profile_, history_dir_, languages));
     in_memory_url_index_->Init();
   }
 
   // Create the history backend.
   LoadBackendIfNecessary();
+
+  if (visitedlink_master_) {
+    bool result = visitedlink_master_->Init();
+    DCHECK(result);
+  }
+
   return true;
 }
 
 void HistoryService::ScheduleAutocomplete(HistoryURLProvider* provider,
                                           HistoryURLProviderParams* params) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleAndForget(PRIORITY_UI, &HistoryBackend::ScheduleAutocomplete,
                     scoped_refptr<HistoryURLProvider>(provider), params);
 }
 
@@ skipping 369 matching lines @@
   }
 }
 
 void HistoryService::OnDeleteDirectiveProcessed(
     const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive) {
   DVLOG(1) << "Processed delete directive: "
            << DeleteDirectiveToString(delete_directive);
   // TODO(akalin): Keep track of which delete directives we've already
   // processed.
 }