Remove VisitedLink dependency on rest of chrome

chrome/browser/visitedlink/visitedlink_master.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/visitedlink/visitedlink_master.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <io.h>
 #include <shlobj.h>
 #endif  // defined(OS_WIN)
 #include <stdio.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/containers/stack_container.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
-#include "chrome/browser/history/history.h"
-#include "chrome/browser/history/history_service_factory.h"
-#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/visitedlink/visitedlink_delegate.h"
 #include "chrome/browser/visitedlink/visitedlink_event_listener.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "googleurl/src/gurl.h"
 
 using content::BrowserThread;
 using file_util::ScopedFILE;
 using file_util::OpenFile;
 using file_util::TruncateFile;
 
 const int32 VisitedLinkMaster::kFileHeaderSignatureOffset = 0;
 const int32 VisitedLinkMaster::kFileHeaderVersionOffset = 4;
 const int32 VisitedLinkMaster::kFileHeaderLengthOffset = 8;
 const int32 VisitedLinkMaster::kFileHeaderUsedOffset = 12;
@@ skipping 89 matching lines @@
 // The builder will store the fingerprints for those URLs, and then marshalls
 // back to the main thread where the VisitedLinkMaster will be notified. The
 // master then replaces its table with a new table containing the computed
 // fingerprints.
 //
 // The builder must remain active while the history system is using it.
 // Sometimes, the master will be deleted before the rebuild is complete, in
 // which case it notifies the builder via DisownMaster(). The builder will
 // delete itself once rebuilding is complete, and not execute any callback.
 class VisitedLinkMaster::TableBuilder
-    : public HistoryService::URLEnumerator,
+    : public VisitedLinkDelegate::URLEnumerator,
       public base::RefCountedThreadSafe<TableBuilder> {
  public:
   TableBuilder(VisitedLinkMaster* master,
                const uint8 salt[LINK_SALT_LENGTH]);
 
   // Called on the main thread when the master is being destroyed. This will
   // prevent a crash when the query completes and the master is no longer
   // around. We can not actually do anything but mark this fact, since the
   // table will be being rebuilt simultaneously on the other thread.
   void DisownMaster();
 
   // HistoryService::URLEnumerator
-  virtual void OnURL(const history::URLRow& url_row);
+  virtual void OnURL(const GURL& url);
   virtual void OnComplete(bool succeed);
 
  private:
   friend class base::RefCountedThreadSafe<TableBuilder>;
 
   ~TableBuilder() {}
 
   // OnComplete mashals to this function on the main thread to do the
   // notification.
   void OnCompleteMainThread();
 
   // Owner of this object. MAY ONLY BE ACCESSED ON THE MAIN THREAD!
   VisitedLinkMaster* master_;
 
   // Indicates whether the operation has failed or not.
   bool success_;
 
   // Salt for this new table.
   uint8 salt_[LINK_SALT_LENGTH];
 
   // Stores the fingerprints we computed on the background thread.
   VisitedLinkCommon::Fingerprints fingerprints_;
 };
 
 // VisitedLinkMaster ----------------------------------------------------------
 
-VisitedLinkMaster::VisitedLinkMaster(Profile* profile)
-    : profile_(profile) {
-  listener_.reset(new VisitedLinkEventListener(profile));
-  DCHECK(listener_.get());
+VisitedLinkMaster::VisitedLinkMaster(content::BrowserContext* browser_context,
+                                     VisitedLinkDelegate* delegate)
+    : browser_context_(browser_context),
+      delegate_(delegate),
+      listener_(new VisitedLinkEventListener(
+          ALLOW_THIS_IN_INITIALIZER_LIST(this), browser_context)) {
   InitMembers();
 }
 
 VisitedLinkMaster::VisitedLinkMaster(Listener* listener,
-                                     HistoryService* history_service,
+                                     VisitedLinkDelegate* delegate,
                                      bool suppress_rebuild,
                                      const FilePath& filename,
                                      int32 default_table_size)
-    : profile_(NULL) {
+    : browser_context_(NULL),
+      delegate_(delegate) {
   listener_.reset(listener);
   DCHECK(listener_.get());
   InitMembers();
 
   database_name_override_ = filename;
   table_size_override_ = default_table_size;
-  history_service_override_ = history_service;
   suppress_rebuild_ = suppress_rebuild;
 }
 
 VisitedLinkMaster::~VisitedLinkMaster() {
   if (table_builder_.get()) {
     // Prevent the table builder from calling us back now that we're being
     // destroyed. Note that we DON'T delete the object, since the history
     // system is still writing into it. When that is complete, the table
     // builder will destroy itself when it finds we are gone.
     table_builder_->DisownMaster();
   }
   FreeURLTable();
   // FreeURLTable() will schedule closing of the file and deletion of |file_|.
   // So nothing should be done here.
 }
 
 void VisitedLinkMaster::InitMembers() {
   file_ = NULL;
   shared_memory_ = NULL;
   shared_memory_serial_ = 0;
   used_items_ = 0;
   table_size_override_ = 0;
-  history_service_override_ = NULL;
   suppress_rebuild_ = false;
   sequence_token_ = BrowserThread::GetBlockingPool()->GetSequenceToken();
 
 #ifndef NDEBUG
   posted_asynchronous_operation_ = false;
 #endif
 }
 
 bool VisitedLinkMaster::Init() {
   // We probably shouldn't be loading this from the UI thread,
   // but it does need to happen early on in startup.
   //   http://code.google.com/p/chromium/issues/detail?id=24163
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   if (!InitFromFile())
     return InitFromScratch(suppress_rebuild_);
   return true;
 }
 
 VisitedLinkMaster::Hash VisitedLinkMaster::TryToAddURL(const GURL& url) {
   // Extra check that we are not incognito. This should not happen.
-  if (profile_ && profile_->IsOffTheRecord()) {
+  if (browser_context_ && browser_context_->IsOffTheRecord()) {

[joth, 2012/12/20 01:39:29]

note BrowserContext has a TODO to remove IsOffTheRecord(). I don't think you can
do much about that here though.

[boliu, 2012/12/29 01:48:12]

Added a TODO

     NOTREACHED();
     return null_hash_;
   }
 
   if (!url.is_valid())
     return null_hash_;  // Don't add invalid URLs.
 
   Fingerprint fingerprint = ComputeURLFingerprint(url.spec().data(),
                                                   url.spec().size(),
                                                   salt_);
@@ skipping 58 matching lines @@
   memset(hash_table_, 0, this->table_length_ * sizeof(Fingerprint));
 
   // Resize it if it is now too empty. Resize may write the new table out for
   // us, otherwise, schedule writing the new table to disk ourselves.
   if (!ResizeTableIfNecessary())
     WriteFullTable();
 
   listener_->Reset();
 }
 
-void VisitedLinkMaster::DeleteURLs(const history::URLRows& rows) {
-  typedef std::set<GURL>::const_iterator SetIterator;
+VisitedLinkDelegate* VisitedLinkMaster::GetDelegate() {
+  return delegate_;
+}
 
-  if (rows.empty())
+void VisitedLinkMaster::DeleteURLs(URLIterator* urls) {
+  if (!urls->has_next())
     return;
 
   listener_->Reset();
 
   if (table_builder_) {
     // A rebuild is in progress, save this deletion in the temporary list so
     // it can be added once rebuild is complete.
-    for (history::URLRows::const_iterator i = rows.begin(); i != rows.end();
-         ++i) {
-      const GURL& url(i->url());
+    while (urls->has_next()) {
+      const GURL& url(urls->next());
       if (!url.is_valid())
         continue;
 
       Fingerprint fingerprint =
           ComputeURLFingerprint(url.spec().data(), url.spec().size(), salt_);
       deleted_since_rebuild_.insert(fingerprint);
 
       // If the URL was just added and now we're deleting it, it may be in the
       // list of things added since the last rebuild. Delete it from that list.
       std::set<Fingerprint>::iterator found =
           added_since_rebuild_.find(fingerprint);
       if (found != added_since_rebuild_.end())
         added_since_rebuild_.erase(found);
 
       // Delete the URLs from the in-memory table, but don't bother writing
       // to disk since it will be replaced soon.
       DeleteFingerprint(fingerprint, false);
     }
     return;
   }
 
   // Compute the deleted URLs' fingerprints and delete them
   std::set<Fingerprint> deleted_fingerprints;
-  for (history::URLRows::const_iterator i = rows.begin(); i != rows.end();
-       ++i) {
-    const GURL& url(i->url());
+  while (urls->has_next()) {
+    const GURL& url(urls->next());
     if (!url.is_valid())
       continue;
     deleted_fingerprints.insert(
         ComputeURLFingerprint(url.spec().data(), url.spec().size(), salt_));
   }
   DeleteFingerprintsFromCurrentTable(deleted_fingerprints);
 }
 
 // See VisitedLinkCommon::IsVisited which should be in sync with this algorithm
 VisitedLinkMaster::Hash VisitedLinkMaster::AddFingerprint(
@@ skipping 201 matching lines @@
     // current empty table.
     WriteFullTable();
     return true;
   }
 
   // This will build the table from history. On the first run, history will
   // be empty, so this will be correct. This will also write the new table
   // to disk. We don't want to save explicitly here, since the rebuild may
   // not complete, leaving us with an empty but valid visited link database.
   // In the future, we won't know we need to try rebuilding again.
-  return RebuildTableFromHistory();
+  return RebuildTableFromDelegate();
 }
 
 bool VisitedLinkMaster::ReadFileHeader(FILE* file,
                                        int32* num_entries,
                                        int32* used_count,
                                        uint8 salt[LINK_SALT_LENGTH]) {
   // Get file size.
   // Note that there is no need to seek back to the original location in the
   // file since ReadFromFile() [which is the next call accessing the file]
   // seeks before reading.
@@ skipping 39 matching lines @@
   return true;
 }
 
 bool VisitedLinkMaster::GetDatabaseFileName(FilePath* filename) {
   if (!database_name_override_.empty()) {
     // use this filename, the directory must exist
     *filename = database_name_override_;
     return true;
   }
 
-  if (!profile_ || profile_->GetPath().empty())
+  if (!browser_context_ || browser_context_->GetPath().empty())
     return false;
 
-  FilePath profile_dir = profile_->GetPath();
+  FilePath profile_dir = browser_context_->GetPath();
   *filename = profile_dir.Append(FILE_PATH_LITERAL("Visited Links"));
   return true;
 }
 
 // Initializes the shared memory structure. The salt should already be filled
 // in so that it can be written to the shared memory
 bool VisitedLinkMaster::CreateURLTable(int32 num_entries, bool init_to_empty) {
   // The table is the size of the table followed by the entries.
   uint32 alloc_size = num_entries * sizeof(Fingerprint) + sizeof(SharedHeader);
 
@@ skipping 145 matching lines @@
     if (table_sizes[i] > desired)
       return table_sizes[i];
   }
 
   // Growing very big, just approximate a "good" number, not growing as much
   // as normal.
   return item_count * 2 - 1;
 }
 
 // See the TableBuilder definition in the header file for how this works.
-bool VisitedLinkMaster::RebuildTableFromHistory() {
+bool VisitedLinkMaster::RebuildTableFromDelegate() {
   DCHECK(!table_builder_);
-  if (table_builder_)
-    return false;
-
-  HistoryService* history_service = history_service_override_;
-  if (!history_service && profile_) {
-    history_service =
-        HistoryServiceFactory::GetForProfile(profile_,
-                                             Profile::EXPLICIT_ACCESS);
-  }
-
-  if (!history_service) {
-    DLOG(WARNING) << "Attempted to rebuild visited link table, but couldn't "
-                     "obtain a HistoryService.";
-    return false;
-  }
 
   // TODO(brettw) make sure we have reasonable salt!
   table_builder_ = new TableBuilder(this, salt_);
 
   // Make sure the table builder stays live during the call, even if the
   // master is deleted. This is balanced in TableBuilder::OnCompleteMainThread.
   table_builder_->AddRef();
-  history_service->IterateURLs(table_builder_);
+  delegate_->RebuildTable(table_builder_);
   return true;
 }
 
 // See the TableBuilder declaration above for how this works.
 void VisitedLinkMaster::OnTableRebuildComplete(
     bool success,
     const std::vector<Fingerprint>& fingerprints) {
   if (success) {
     // Replace the old table with a new blank one.
     shared_memory_serial_++;
@@ skipping 103 matching lines @@
   fingerprints_.reserve(4096);
   memcpy(salt_, salt, LINK_SALT_LENGTH * sizeof(uint8));
 }
 
 // TODO(brettw): Do we want to try to cancel the request if this happens? It
 // could delay shutdown if there are a lot of URLs.
 void VisitedLinkMaster::TableBuilder::DisownMaster() {
   master_ = NULL;
 }
 
-void VisitedLinkMaster::TableBuilder::OnURL(const history::URLRow& url_row) {
-  const GURL& url(url_row.url());
+void VisitedLinkMaster::TableBuilder::OnURL(const GURL& url) {
   if (!url.is_empty()) {

[joth, 2012/12/20 01:39:29]

if (url.is_valid()) ?

     fingerprints_.push_back(VisitedLinkMaster::ComputeURLFingerprint(
         url.spec().data(), url.spec().length(), salt_));
   }
 }
 
 void VisitedLinkMaster::TableBuilder::OnComplete(bool success) {
   success_ = success;
   DLOG_IF(WARNING, !success) << "Unable to rebuild visited links";
 
   // Marshal to the main thread to notify the VisitedLinkMaster that the
   // rebuild is complete.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TableBuilder::OnCompleteMainThread, this));
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 
   // WILL (generally) DELETE THIS! This balances the AddRef in
   // VisitedLinkMaster::RebuildTableFromHistory.
   Release();
 }