Ensure that VisitedLink listener Add event only fires when new fingerprint is...

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 293 matching lines @@
     added_since_rebuild_.insert(fingerprint);
   }
 
   // If the table is "full", we don't add URLs and just drop them on the floor.
   // This can happen if we get thousands of new URLs and something causes
   // the table resizing to fail. This check prevents a hang in that case. Note
   // that this is *not* the resize limit, this is just a sanity check.
   if (used_items_ / 8 > table_length_ / 10)
     return null_hash_;  // Table is more than 80% full.
 
-  return AddFingerprint(fingerprint);
+  return AddFingerprint(fingerprint, true);
 }
 
 void VisitedLinkMaster::AddURL(const GURL& url) {
   Hash index = TryToAddURL(url);
   if (!table_builder_ && index != null_hash_) {
     // Not rebuilding, so we want to keep the file on disk up-to-date.
     WriteUsedItemCountToFile();
     WriteHashRangeToFile(index, index);
     ResizeTableIfNecessary();
   }
@@ skipping 68 matching lines @@
     if (!i->is_valid())
       continue;
     deleted_fingerprints.insert(
         ComputeURLFingerprint(i->spec().data(), i->spec().size(), salt_));
   }
   DeleteFingerprintsFromCurrentTable(deleted_fingerprints);
 }
 
 // See VisitedLinkCommon::IsVisited which should be in sync with this algorithm
 VisitedLinkMaster::Hash VisitedLinkMaster::AddFingerprint(
-    Fingerprint fingerprint) {
+    Fingerprint fingerprint,
+    bool send_notifications) {
   if (!hash_table_ || table_length_ == 0) {
     NOTREACHED();  // Not initialized.
     return null_hash_;
   }
 
   Hash cur_hash = HashFingerprint(fingerprint);
   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);
+      // If allowed, notify listener that a new visited link was added.
+      if (send_notifications)
+        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 64 matching lines @@
       // This will balance the increment of this value in AddFingerprint below
       // so there is no net change.
       used_items_--;
     }
     hash_table_[i] = null_fingerprint_;
   }
 
   if (!shuffled_fingerprints->empty()) {
     // Need to add the new items back.
     for (size_t i = 0; i < shuffled_fingerprints->size(); i++)
-      AddFingerprint(shuffled_fingerprints[i]);
+      AddFingerprint(shuffled_fingerprints[i], false);
   }
 
   // Write the affected range to disk [deleted_hash, end_range].
   if (update_file)
     WriteHashRangeToFile(deleted_hash, end_range);
 
   return true;
 }
 
 bool VisitedLinkMaster::WriteFullTable() {
@@ skipping 280 matching lines @@
   Fingerprint* old_hash_table = hash_table_;
   int32 old_table_length = table_length_;
   if (!BeginReplaceURLTable(new_size))
     return;
 
   // Now we have two tables, our local copy which is the old one, and the new
   // one loaded into this object where we need to copy the data.
   for (int32 i = 0; i < old_table_length; i++) {
     Fingerprint cur = old_hash_table[i];
     if (cur)
-      AddFingerprint(cur);
+      AddFingerprint(cur, false);
   }
 
   // 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.
   listener_->NewTable(shared_memory_);
 
@@ skipping 77 matching lines @@
     base::SharedMemory* old_shared_memory = shared_memory_;
 
     int new_table_size = NewTableSizeForCount(
         static_cast<int>(fingerprints.size()));
     if (BeginReplaceURLTable(new_table_size)) {
       // Free the old table.
       delete old_shared_memory;
 
       // Add the stored fingerprints to the hash table.
       for (size_t i = 0; i < fingerprints.size(); i++)
-        AddFingerprint(fingerprints[i]);
+        AddFingerprint(fingerprints[i], false);
 
       // Also add anything that was added while we were asynchronously
       // generating the new table.
       for (std::set<Fingerprint>::iterator i = added_since_rebuild_.begin();
            i != added_since_rebuild_.end(); ++i)
-        AddFingerprint(*i);
+        AddFingerprint(*i, false);
       added_since_rebuild_.clear();
 
       // Now handle deletions.
       DeleteFingerprintsFromCurrentTable(deleted_since_rebuild_);
       deleted_since_rebuild_.clear();
 
       // Send an update notification to all child processes.
       listener_->NewTable(shared_memory_);
 
       WriteFullTable();
@@ skipping 105 matching lines @@
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 
   // WILL (generally) DELETE THIS! This balances the AddRef in
   // VisitedLinkMaster::RebuildTableFromHistory.
   Release();
 }