Revert "Remove VisitedLink dependency on rest of chrome"

chrome/browser/visitedlink/visitedlink_master.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_VISITEDLINK_VISITEDLINK_MASTER_H_
 #define CHROME_BROWSER_VISITEDLINK_VISITEDLINK_MASTER_H_
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 #include <set>
 #include <vector>
 
-#include "base/callback.h"
 #include "base/callback_forward.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/shared_memory.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "chrome/browser/history/history.h"
+#include "chrome/browser/history/history_types.h"
+#include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/common/visitedlink_common.h"
 
-#if defined(UNIT_TEST) || defined(PERF_TEST) || !defined(NDEBUG)
-#include "base/logging.h"
-#endif
-
 class GURL;
-class VisitedLinkDelegate;
-
-namespace content {
-class BrowserContext;
-}  // namespace content
-
+class Profile;
 
 // Controls the link coloring database. The master controls all writing to the
 // database as well as disk I/O. There should be only one master.
 //
 // This class will defer writing operations to the file thread. This means that
 // class destruction, the file may still be open since operations are pending on
 // another thread.
-class VisitedLinkMaster : public VisitedLinkCommon {
+class VisitedLinkMaster : public VisitedLinkCommon,
+                          public ProfileKeyedService  {
  public:
   // Listens to the link coloring database events. The master is given this
   // event as a constructor argument and dispatches events using it.
   class Listener {
    public:
     virtual ~Listener() {}
 
     // Called when link coloring database has been created or replaced. The
     // argument is the new table handle.
     virtual void NewTable(base::SharedMemory*) = 0;
 
     // Called when new link has been added. The argument is the fingerprint
     // (hash) of the link.
     virtual void Add(Fingerprint fingerprint) = 0;
 
     // Called when link coloring state has been reset. This may occur when
     // entire or parts of history were deleted.
     virtual void Reset() = 0;
   };
 
-  VisitedLinkMaster(content::BrowserContext* browser_context,
-                    VisitedLinkDelegate* delegate);
+  explicit VisitedLinkMaster(Profile* profile);
 
   // In unit test mode, we allow the caller to optionally specify the database
   // filename so that it can be run from a unit test. The directory where this
   // file resides must exist in this mode. You can also specify the default
   // table size to test table resizing. If this parameter is 0, we will use the
   // defaults.
   //
   // In the unit test mode, we also allow the caller to provide a history
   // service pointer (the history service can't be fetched from the browser
   // process when we're in unit test mode). This can be NULL to try to access
   // the main version, which will probably fail (which can be good for testing
   // this failure mode).
   //
   // When |suppress_rebuild| is set, we'll not attempt to load data from
   // history if the file can't be loaded. This should generally be set for
   // testing except when you want to test the rebuild process explicitly.
   VisitedLinkMaster(Listener* listener,
-                    VisitedLinkDelegate* delegate,
+                    HistoryService* history_service,
                     bool suppress_rebuild,
                     const FilePath& filename,
                     int32 default_table_size);
   virtual ~VisitedLinkMaster();
 
+  // Return the VisitedLinkMaster instance for a profile.
+  static VisitedLinkMaster* FromProfile(Profile* profile);
+
   // Must be called immediately after object creation. Nothing else will work
   // until this is called. Returns true on success, false means that this
   // object won't work.
   bool Init();
 
   base::SharedMemory* shared_memory() { return shared_memory_; }
 
   // Adds a URL to the table.
   void AddURL(const GURL& url);
 
   // Adds a set of URLs to the table.
   void AddURLs(const std::vector<GURL>& url);
 
-  // See DeleteURLs.
-  class URLIterator {
-   public:
-    // HasNextURL must return true when this is called. Returns the next URL
-    // then advances the iterator. Note that the returned reference is only
-    // valid until the next call of NextURL.
-    virtual const GURL& NextURL() = 0;
-
-    // Returns true if still has URLs to be iterated.
-    virtual bool HasNextURL() const = 0;
-
-   protected:
-    virtual ~URLIterator() {}
-  };
-
   // Deletes the specified URLs from |rows| from the table.
-  void DeleteURLs(URLIterator* iterator);
+  void DeleteURLs(const history::URLRows& rows);
 
   // Clears the visited links table by deleting the file from disk. Used as
   // part of history clearing.
   void DeleteAllURLs();
 
-  // Returns the Delegate of this Master.
-  VisitedLinkDelegate* GetDelegate();
-
 #if defined(UNIT_TEST) || !defined(NDEBUG) || defined(PERF_TEST)
   // This is a debugging function that can be called to double-check internal
   // data structures. It will assert if the check fails.
   void DebugValidate();
 
   // Sets a task to execute when the next rebuild from history is complete.
   // This is used by unit tests to wait for the rebuild to complete before
   // they continue. The pointer will be owned by this object after the call.
   void set_rebuild_complete_task(const base::Closure& task) {
     DCHECK(rebuild_complete_task_.is_null());
@@ skipping 169 matching lines @@
     return static_cast<float>(used_items_) / static_cast<float>(table_length_);
   }
 
   // Initializes a rebuild of the visited link database based on the browser
   // history. This will set table_builder_ while working, and there should not
   // already be a rebuild in place when called. See the definition for more
   // details on how this works.
   //
   // Returns true on success. Failure means we're not attempting to rebuild
   // the database because something failed.
-  bool RebuildTableFromDelegate();
+  bool RebuildTableFromHistory();
 
   // Callback that the table rebuilder uses when the rebuild is complete.
   // |success| is true if the fingerprint generation succeeded, in which case
   // |fingerprints| will contain the computed fingerprints. On failure, there
   // will be no fingerprints.
   void OnTableRebuildComplete(bool success,
                               const std::vector<Fingerprint>& fingerprints);
 
   // Increases or decreases the given hash value by one, wrapping around as
   // necessary. Used for probing.
@@ skipping 10 matching lines @@
 
 #ifndef NDEBUG
   // Indicates whether any asynchronous operation has ever been completed.
   // We do some synchronous reads that require that no asynchronous operations
   // are pending, yet we don't track whether they have been completed. This
   // flag is a sanity check that these reads only happen before any
   // asynchronous writes have been fired.
   bool posted_asynchronous_operation_;
 #endif
 
-  // Reference to the browser context that this object belongs to
+  // Reference to the user profile that this object belongs to
   // (it knows the path to where the data is stored)
-  content::BrowserContext* browser_context_;
-
-  // Client owns the delegate and is responsible for it being valid through
-  // the life time this VisitedLinkMaster.
-  VisitedLinkDelegate* delegate_;
+  Profile* profile_;
 
   // VisitedLinkEventListener to handle incoming events.
   scoped_ptr<Listener> listener_;
 
   // Lazily initialized sequence token for posting file tasks.
   base::SequencedWorkerPool::SequenceToken sequence_token_;
 
   // When non-NULL, indicates we are in database rebuild mode and points to
   // the class collecting fingerprint information from the history system.
   // The pointer is owned by this class, but it must remain valid while the
@@ skipping 37 matching lines @@
   // don't want to change the signature of the object between the unit test and
   // regular builds. Instead, we just have "default" values that these take
   // in release builds that give "regular" behavior.
 
   // Overridden database file name for testing
   FilePath database_name_override_;
 
   // When nonzero, overrides the table size for new databases for testing
   int32 table_size_override_;
 
+  // When non-NULL, overrides the history service to use rather than as the
+  // BrowserProcess. This is provided for unit tests.
+  HistoryService* history_service_override_;
+
   // When set, indicates the task that should be run after the next rebuild from
   // history is complete.
   base::Closure rebuild_complete_task_;
 
   // Set to prevent us from attempting to rebuild the database from global
   // history if we have an error opening the file. This is used for testing,
   // will be false in production.
   bool suppress_rebuild_;
 
   DISALLOW_COPY_AND_ASSIGN(VisitedLinkMaster);
 };
 
 // NOTE: These methods are defined inline here, so we can share the compilation
 //       of visitedlink_master.cc between the browser and the unit/perf tests.
 
 #if defined(UNIT_TEST) || defined(PERF_TEST) || !defined(NDEBUG)
 inline void VisitedLinkMaster::DebugValidate() {
   int32 used_count = 0;
   for (int32 i = 0; i < table_length_; i++) {
     if (hash_table_[i])
       used_count++;
   }
   DCHECK_EQ(used_count, used_items_);
 }
 #endif
 
 #endif  // CHROME_BROWSER_VISITEDLINK_VISITEDLINK_MASTER_H_