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

chrome/browser/visitedlink_master.cc

 // 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.
 
 #include "chrome/browser/visitedlink_master.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <io.h>
 #include <shlobj.h>
@@ skipping 181 matching lines @@
   // The thread the visited link master is on where we will notify it.
   MessageLoop* main_message_loop_;
 
   // 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.
-  std::vector<VisitedLinkMaster::Fingerprint> fingerprints_;
+  VisitedLinkCommon::Fingerprints fingerprints_;
 };
 
 // VisitedLinkMaster ----------------------------------------------------------
 
 VisitedLinkMaster::VisitedLinkMaster(base::Thread* file_thread,
-                                     PostNewTableEvent* poster,
+                                     Listener* listener,
                                      Profile* profile) {
-  InitMembers(file_thread, poster, profile);
+  InitMembers(file_thread, listener, profile);
 }
 
 VisitedLinkMaster::VisitedLinkMaster(base::Thread* file_thread,
-                                     PostNewTableEvent* poster,
+                                     Listener* listener,
                                      HistoryService* history_service,
                                      bool suppress_rebuild,
                                      const FilePath& filename,
                                      int32 default_table_size) {
-  InitMembers(file_thread, poster, NULL);
+  InitMembers(file_thread, listener, NULL);
 
   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();
 }
 
 void VisitedLinkMaster::InitMembers(base::Thread* file_thread,
-                                    PostNewTableEvent* poster,
+                                    Listener* listener,
                                     Profile* profile) {
+  DCHECK(listener);
+
   if (file_thread)
     file_thread_ = file_thread->message_loop();
   else
     file_thread_ = NULL;
 
-  post_new_table_event_ = poster;
+  listener_ = listener;
   file_ = NULL;
   shared_memory_ = NULL;
   shared_memory_serial_ = 0;
   used_items_ = 0;
   table_size_override_ = 0;
   history_service_override_ = NULL;
   suppress_rebuild_ = false;
   profile_ = profile;
 
 #ifndef NDEBUG
@@ skipping 84 matching lines @@
   deleted_since_rebuild_.clear();
 
   // Clear the hash table.
   used_items_ = 0;
   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 std::set<GURL>& urls) {
   typedef std::set<GURL>::const_iterator SetIterator;
 
   if (urls.empty())
     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 (SetIterator i = urls.begin(); i != urls.end(); ++i) {
       if (!i->is_valid())
         continue;
 
       Fingerprint fingerprint =
           ComputeURLFingerprint(i->spec().data(), i->spec().size(), salt_);
       deleted_since_rebuild_.insert(fingerprint);
@@ skipping 35 matching lines @@
   Hash first_hash = cur_hash;
   while (true) {
     Fingerprint cur_fingerprint = FingerprintAt(cur_hash);
     if (cur_fingerprint == fingerprint)
       return null_hash_;  // This fingerprint is already in there, do nothing.
 
     if (cur_fingerprint == null_fingerprint_) {
       // End of probe sequence found, insert here.
       hash_table_[cur_hash] = fingerprint;
       used_items_++;
+      // Notify listener that a new visited link was added.
+      listener_->Add(fingerprint);
       return cur_hash;
     }
 
     // Advance in the probe sequence.
     cur_hash = IncrementHash(cur_hash);
     if (cur_hash == first_hash) {
       // This means that we've wrapped around and are about to go into an
       // infinite loop. Something was wrong with the hashtable resizing
       // logic, so stop here.
       NOTREACHED();
@@ skipping 374 matching lines @@
     if (cur)
       AddFingerprint(cur);
   }
 
   // On error unmapping, just forget about it since we can't do anything
   // else to release it.
   delete old_shared_memory;
 
   // Send an update notification to all child processes so they read the new
   // table.
-  post_new_table_event_(shared_memory_);
+  listener_->NewTable(shared_memory_);
 
 #ifndef NDEBUG
   DebugValidate();
 #endif
 
   // The new table needs to be written to disk.
   WriteFullTable();
 }
 
 uint32 VisitedLinkMaster::NewTableSizeForCount(int32 item_count) const {
@@ skipping 82 matching lines @@
       for (std::set<Fingerprint>::iterator i = added_since_rebuild_.begin();
            i != added_since_rebuild_.end(); ++i)
         AddFingerprint(*i);
       added_since_rebuild_.clear();
 
       // Now handle deletions.
       DeleteFingerprintsFromCurrentTable(deleted_since_rebuild_);
       deleted_since_rebuild_.clear();
 
       // Send an update notification to all child processes.
-      post_new_table_event_(shared_memory_);
+      listener_->NewTable(shared_memory_);
 
       WriteFullTable();
     }
   }
   table_builder_ = NULL;  // Will release our reference to the builder.
 
   // Notify the unit test that the rebuild is complete (will be NULL in prod.)
   if (rebuild_complete_task_.get()) {
     rebuild_complete_task_->Run();
     rebuild_complete_task_.reset(NULL);
@@ skipping 97 matching lines @@
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 
   // WILL (generally) DELETE THIS! This balances the AddRef in
   // VisitedLinkMaster::RebuildTableFromHistory.
   Release();
 }