Fix Acid3 Test 48: LINKTEST, Chromium side....

chrome/browser/visitedlink_master.h

 // Copyright (c) 2006-2008 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_MASTER_H__
 #define CHROME_BROWSER_VISITEDLINK_MASTER_H__
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
@@ skipping 17 matching lines @@
 }  // namespace base
 
 // 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 optionally defer writing operations to another thread. This
 // means that after class destruction, the file may still be open since
 // operations are pending on another thread.
 class VisitedLinkMaster : public VisitedLinkCommon {
  public:
-   typedef void (PostNewTableEvent)(base::SharedMemory*);
+  // 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;
+  };
 
   // The |file_thread| may be NULL, in which case write operations will be
   // synchronous.
+  // The |listener| may not be NULL.
   VisitedLinkMaster(base::Thread* file_thread,
-                    PostNewTableEvent* poster,
+                    Listener* listener,
                     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(base::Thread* file_thread,
-                    PostNewTableEvent* poster,
+                    Listener* listener,
                     HistoryService* history_service,
                     bool suppress_rebuild,
                     const FilePath& filename,
                     int32 default_table_size);
   virtual ~VisitedLinkMaster();
 
   // 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();
@@ skipping 70 matching lines @@
   // When creating a fresh new table, we use this many entries.
   static const unsigned kDefaultTableSize;
 
   // When the user is deleting a boatload of URLs, we don't really want to do
   // individual writes for each of them. When the count exceeds this threshold,
   // we will write the whole table to disk at once instead of individual items.
   static const size_t kBigDeleteThreshold;
 
   // Backend for the constructors initializing the members.
   void InitMembers(base::Thread* file_thread,
-                   PostNewTableEvent* poster,
+                   Listener* listener,
                    Profile* profile);
 
   // If a rebuild is in progress, we save the URL in the temporary list.
   // Otherwise, we add this to the table. Returns the index of the
   // inserted fingerprint or null_hash_ on failure.
   Hash TryToAddURL(const GURL& url);
 
   // File I/O functions
   // ------------------
 
@@ skipping 123 matching lines @@
     if (hash >= table_length_ - 1)
       return 0;  // Wrap around.
     return hash + 1;
   }
   inline Hash DecrementHash(Hash hash) {
     if (hash <= 0)
       return table_length_ - 1;  // Wrap around.
     return hash - 1;
   }
 
-  PostNewTableEvent* post_new_table_event_;
+  Listener* listener_;
 
 #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
 
@@ skipping 73 matching lines @@
   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_MASTER_H__