Load the table of visited links from database file asynchronously.

components/visitedlink/browser/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 "components/visitedlink/browser/visitedlink_master.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <io.h>
 #include <shlobj.h>
@@ skipping 98 matching lines @@
 // of FILE* value. Double pointer to FILE is used because file may still not
 // be opened by the time of scheduling the task for execution.
 void AsyncClose(FILE** file) {
   if (*file)
     base::IgnoreResult(fclose(*file));
   free(file);
 }
 
 }  // namespace
 
+struct VisitedLinkMaster::LoadFromFileResult
+    : public base::RefCountedThreadSafe<LoadFromFileResult> {
+  LoadFromFileResult(base::ScopedFILE file,
+                     scoped_ptr<base::SharedMemory> shared_memory,
+                     Fingerprint* hash_table,
+                     int32 num_entries,
+                     int32 used_count,
+                     uint8 salt[LINK_SALT_LENGTH]);
+
+  base::ScopedFILE file;
+  scoped_ptr<base::SharedMemory> shared_memory;
+  Fingerprint* hash_table;
+  int32 num_entries;
+  int32 used_count;
+  uint8 salt[LINK_SALT_LENGTH];
+
+ private:
+  friend class base::RefCountedThreadSafe<LoadFromFileResult>;
+  virtual ~LoadFromFileResult();
+
+  DISALLOW_COPY_AND_ASSIGN(LoadFromFileResult);
+};
+
+VisitedLinkMaster::LoadFromFileResult::LoadFromFileResult(
+    base::ScopedFILE file,
+    scoped_ptr<base::SharedMemory> shared_memory,
+    Fingerprint* hash_table,
+    int32 num_entries,
+    int32 used_count,
+    uint8 salt[LINK_SALT_LENGTH])
+    : file(file.Pass()),
+      shared_memory(shared_memory.Pass()),
+      hash_table(hash_table),
+      num_entries(num_entries),
+      used_count(used_count) {
+  memcpy(this->salt, salt, LINK_SALT_LENGTH);
+}
+
+VisitedLinkMaster::LoadFromFileResult::~LoadFromFileResult() {
+}
+
 // TableBuilder ---------------------------------------------------------------
 
 // How rebuilding from history works
 // ---------------------------------
 //
 // We mark that we're rebuilding from history by setting the table_builder_
 // member in VisitedLinkMaster to the TableBuilder we create. This builder
 // will be called on the history thread by the history system for every URL
 // in the database.
 //
@@ skipping 45 matching lines @@
 };
 
 // VisitedLinkMaster ----------------------------------------------------------
 
 VisitedLinkMaster::VisitedLinkMaster(content::BrowserContext* browser_context,
                                      VisitedLinkDelegate* delegate,
                                      bool persist_to_disk)
     : browser_context_(browser_context),
       delegate_(delegate),
       listener_(new VisitedLinkEventListener(this, browser_context)),
-      persist_to_disk_(persist_to_disk) {
+      persist_to_disk_(persist_to_disk),
+      table_is_loading_from_file_(false),
+      weak_ptr_factory_(this) {
   InitMembers();
 }
 
 VisitedLinkMaster::VisitedLinkMaster(Listener* listener,
                                      VisitedLinkDelegate* delegate,
                                      bool persist_to_disk,
                                      bool suppress_rebuild,
                                      const base::FilePath& filename,
                                      int32 default_table_size)
     : browser_context_(NULL),
       delegate_(delegate),
-      persist_to_disk_(persist_to_disk) {
+      persist_to_disk_(persist_to_disk),
+      table_is_loading_from_file_(false),
+      weak_ptr_factory_(this) {
   listener_.reset(listener);
   DCHECK(listener_.get());
   InitMembers();
 
   database_name_override_ = filename;
   table_size_override_ = default_table_size;
   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.
+
+  if (table_is_loading_from_file_ &&
+      (!added_since_rebuild_or_load_.empty() ||
+       !deleted_since_rebuild_or_load_.empty())) {
+    // Delete the database file if exist because we don't have enough time to
+    // load the table from the database file and now we have inconsistent
+    // state. On the next start table will be rebuilt.
+    base::FilePath filename;
+    GetDatabaseFileName(&filename);
+    PostIOTask(FROM_HERE,
+               base::Bind(IgnoreResult(&base::DeleteFile), filename, false));
+  }
 }
 
 void VisitedLinkMaster::InitMembers() {
   file_ = NULL;
   shared_memory_ = NULL;
   shared_memory_serial_ = 0;
   used_items_ = 0;
   table_size_override_ = 0;
   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 (persist_to_disk_) {
     if (InitFromFile())
       return true;
   }
   return InitFromScratch(suppress_rebuild_);
 }
 
 VisitedLinkMaster::Hash VisitedLinkMaster::TryToAddURL(const GURL& url) {
   // Extra check that we are not incognito. This should not happen.
   // TODO(boliu): Move this check to HistoryService when IsOffTheRecord is
   // removed from BrowserContext.
   if (browser_context_ && browser_context_->IsOffTheRecord()) {
     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_);
-  if (table_builder_.get()) {
+  if (table_builder_.get() || table_is_loading_from_file_) {
     // If we have a pending delete for this fingerprint, cancel it.
     std::set<Fingerprint>::iterator found =
-        deleted_since_rebuild_.find(fingerprint);
-    if (found != deleted_since_rebuild_.end())
-        deleted_since_rebuild_.erase(found);
+        deleted_since_rebuild_or_load_.find(fingerprint);
+    if (found != deleted_since_rebuild_or_load_.end())
+        deleted_since_rebuild_or_load_.erase(found);
 
-    // A rebuild is in progress, save this addition in the temporary list so
-    // it can be added once rebuild is complete.
-    added_since_rebuild_.insert(fingerprint);
+    // A rebuild or load is in progress, save this addition in the temporary
+    // list so it can be added once rebuild is complete.
+    added_since_rebuild_or_load_.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, true);
 }
 
 void VisitedLinkMaster::PostIOTask(const tracked_objects::Location& from_here,
                                    const base::Closure& task) {
   DCHECK(persist_to_disk_);
   BrowserThread::GetBlockingPool()->PostSequencedWorkerTask(sequence_token_,
                                                             from_here, task);
 }
 
 void VisitedLinkMaster::AddURL(const GURL& url) {
   Hash index = TryToAddURL(url);
-  if (!table_builder_.get() && index != null_hash_) {
+  if (!table_builder_.get() &&
+      !table_is_loading_from_file_ &&
+      index != null_hash_) {
     // Not rebuilding, so we want to keep the file on disk up-to-date.
     if (persist_to_disk_) {
       WriteUsedItemCountToFile();
       WriteHashRangeToFile(index, index);
     }
     ResizeTableIfNecessary();
   }
 }
 
 void VisitedLinkMaster::AddURLs(const std::vector<GURL>& url) {
   for (std::vector<GURL>::const_iterator i = url.begin();
        i != url.end(); ++i) {
     Hash index = TryToAddURL(*i);
-    if (!table_builder_.get() && index != null_hash_)
+    if (!table_builder_.get() &&
+        !table_is_loading_from_file_ &&
+        index != null_hash_)
       ResizeTableIfNecessary();
   }
 
   // Keeps the file on disk up-to-date.
-  if (!table_builder_.get() && persist_to_disk_)
+  if (!table_builder_.get() &&
+      !table_is_loading_from_file_ &&
+      persist_to_disk_)
     WriteFullTable();
 }
 
 void VisitedLinkMaster::DeleteAllURLs() {
   // Any pending modifications are invalid.
-  added_since_rebuild_.clear();
-  deleted_since_rebuild_.clear();
+  added_since_rebuild_or_load_.clear();
+  deleted_since_rebuild_or_load_.clear();
+  table_is_loading_from_file_ = false;
 
   // 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() && persist_to_disk_)
     WriteFullTable();
 
   listener_->Reset();
 }
 
 VisitedLinkDelegate* VisitedLinkMaster::GetDelegate() {
   return delegate_;
 }
 
 void VisitedLinkMaster::DeleteURLs(URLIterator* urls) {
   if (!urls->HasNextURL())
     return;
 
   listener_->Reset();
 
-  if (table_builder_.get()) {
+  if (table_builder_.get() || table_is_loading_from_file_) {
     // A rebuild is in progress, save this deletion in the temporary list so
     // it can be added once rebuild is complete.
     while (urls->HasNextURL()) {
       const GURL& url(urls->NextURL());
       if (!url.is_valid())
         continue;
 
       Fingerprint fingerprint =
           ComputeURLFingerprint(url.spec().data(), url.spec().size(), salt_);
-      deleted_since_rebuild_.insert(fingerprint);
+      deleted_since_rebuild_or_load_.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.
+      // list of things added since the last rebuild or load. 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);
+          added_since_rebuild_or_load_.find(fingerprint);
+      if (found != added_since_rebuild_or_load_.end())
+        added_since_rebuild_or_load_.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;
@@ skipping 157 matching lines @@
 
   // Write the hash data.
   WriteToFile(file_, kFileHeaderSize,
               hash_table_, table_length_ * sizeof(Fingerprint));
 
   // The hash table may have shrunk, so make sure this is the end.
   PostIOTask(FROM_HERE, base::Bind(&AsyncTruncate, file_));
 }
 
 bool VisitedLinkMaster::InitFromFile() {
-  DCHECK(file_ == NULL);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  DCHECK(file_ == nullptr);
   DCHECK(persist_to_disk_);
 
   base::FilePath filename;
-  GetDatabaseFileName(&filename);
+  if (!GetDatabaseFileName(&filename))
+    return false;
+
+  // Create the temporary table.
+  // The salt must be generated before the table so that it can be copied to
+  // the shared memory.
+  GenerateSalt(salt_);
+  if (!CreateURLTable(DefaultTableSize()))
+    return false;
+
+#ifndef NDEBUG
+  DebugValidate();
+#endif
+
+  table_is_loading_from_file_ = true;
+
+  TableLoadCompleteCallback callback = base::Bind(
+      &VisitedLinkMaster::OnTableLoadComplete, weak_ptr_factory_.GetWeakPtr());
+
+  PostIOTask(FROM_HERE,
+             base::Bind(&VisitedLinkMaster::LoadFromFile, filename, callback));
+
+  return true;
+}
+
+// static
+void VisitedLinkMaster::LoadFromFile(
+    const base::FilePath& filename,
+    const TableLoadCompleteCallback& callback) {
+  scoped_refptr<LoadFromFileResult> load_from_file_result;
+  bool success = LoadApartFromFile(filename, &load_from_file_result);
+
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      base::Bind(callback, success, load_from_file_result));
+}
+
+// static
+bool VisitedLinkMaster::LoadApartFromFile(
+    const base::FilePath& filename,
+    scoped_refptr<LoadFromFileResult>* load_from_file_result) {
+  DCHECK(load_from_file_result);
+
   base::ScopedFILE file_closer(base::OpenFile(filename, "rb+"));
   if (!file_closer.get())
     return false;
 
   int32 num_entries, used_count;
-  if (!ReadFileHeader(file_closer.get(), &num_entries, &used_count, salt_))
+  uint8 salt[LINK_SALT_LENGTH];
+  if (!ReadFileHeader(file_closer.get(), &num_entries, &used_count, salt))
     return false;  // Header isn't valid.
 
   // Allocate and read the table.
-  if (!CreateURLTable(num_entries, false))
+  scoped_ptr<base::SharedMemory> shared_memory;
+  VisitedLinkCommon::Fingerprint* hash_table;
+  if (!CreateApartURLTable(num_entries, salt, &shared_memory, &hash_table))
     return false;
-  if (!ReadFromFile(file_closer.get(), kFileHeaderSize,
-                    hash_table_, num_entries * sizeof(Fingerprint))) {
-    FreeURLTable();
+
+  if (!ReadFromFile(file_closer.get(), kFileHeaderSize, hash_table,
+                    num_entries * sizeof(Fingerprint))) {
     return false;
   }
-  used_items_ = used_count;
+
+  *load_from_file_result = new LoadFromFileResult(file_closer.Pass(),
+                                                  shared_memory.Pass(),
+                                                  hash_table,
+                                                  num_entries,
+                                                  used_count,
+                                                  salt);
+  return true;
+}
+
+void VisitedLinkMaster::OnTableLoadComplete(
+    bool success,
+    scoped_refptr<LoadFromFileResult> load_from_file_result) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(persist_to_disk_);
+  DCHECK(!table_builder_.get());
+
+  // When the apart table was loading from the database file the current table
+  // was cleared.

[brettw, 2015/11/02 05:09:23]

"was" -> "could have been" (As-is, I think the comment describes the "return"
case rather than the entire block fo code here, which I'm trying to make clear.)

+  if (!table_is_loading_from_file_)
+    return;
+
+  table_is_loading_from_file_ = false;
+
+  if (!success) {
+    // If the table isn't loaded the table will be rebuilt.
+    if (!suppress_rebuild_) {
+      RebuildTableFromDelegate();
+    } else {
+      // When we disallow rebuilds (normally just unit tests), just use the
+      // current empty table.
+      WriteFullTable();
+    }
+    return;
+  }
+
+  DCHECK(load_from_file_result.get());
+
+  // Delete the previous table.
+  DCHECK(shared_memory_);
+  delete shared_memory_;
+  shared_memory_ = nullptr;
+
+  // Assign the open file.
+  DCHECK(!file_);
+  DCHECK(load_from_file_result->file.get());
+  file_ = static_cast<FILE**>(malloc(sizeof(*file_)));
+  *file_ = load_from_file_result->file.release();
+
+  // Assign the loaded table.
+  DCHECK(load_from_file_result->shared_memory.get());
+  DCHECK(load_from_file_result->hash_table);
+  memcpy(salt_, load_from_file_result->salt, LINK_SALT_LENGTH);
+  shared_memory_ = load_from_file_result->shared_memory.release();
+  hash_table_ = load_from_file_result->hash_table;
+  table_length_ = load_from_file_result->num_entries;
+  used_items_ = load_from_file_result->used_count;
 
 #ifndef NDEBUG
   DebugValidate();
 #endif
 
-  file_ = static_cast<FILE**>(malloc(sizeof(*file_)));
-  *file_ = file_closer.release();
-  return true;
+  if (!added_since_rebuild_or_load_.empty() ||
+      !deleted_since_rebuild_or_load_.empty()) {
+    int new_size =
+        NewTableSizeForCount(used_items_ + added_since_rebuild_or_load_.size());
+    if (new_size > table_length_)
+      ResizeTable(new_size);
+
+    // Also add anything that was added while we were asynchronously
+    // loading the table.
+    for (const auto& fingerprint : added_since_rebuild_or_load_)

[brettw, 2015/11/02 05:09:23]

From here to the end of the condition is the same as OnTableRebuildComplete. I
think this is probably complex enough to warrant a helper function to avoid the
duplication.

+      AddFingerprint(fingerprint, false);
+    added_since_rebuild_or_load_.clear();
+
+    // Now handle deletions.
+    DeleteFingerprintsFromCurrentTable(deleted_since_rebuild_or_load_);
+    deleted_since_rebuild_or_load_.clear();
+
+    if (persist_to_disk_)
+      WriteFullTable();
+  }
+
+  // Send an update notification to all child processes.

[brettw, 2015/11/02 05:09:23]

This will duplicate the message if the table is resized above. I'm not actually
sure if this is benign or not. If it doesn't hurt, this is a rare edge case and
I don't think it's worth optimizing. But I'm concerned about handle duplicating
behavior on all the platforms when sharing the same memory to a process multiple
times. For example, the renderer will close the old one and add the new one, but
I'm not sure the two handles to the same memory will always be different on all
platforms.

I think this will all go away if we move this NewTable call above the "if
(!added_since..." condition above, and then also delete the checking for whether
the new size is required at the top of that condition. The additions will
organically cause a table resize if necessary and we can have fewer special
cases here. I think the only case where manually checking for the resize might
help is if the additions cause two resizes, which should be so rare as to be
almost impossible.

+  listener_->NewTable(shared_memory_);

[brettw, 2015/11/02 05:09:23]

I *think* here we also need a Reset() after the NewTable. You may have this in
your head more freshly than me, so please correct if I'm mistaken...

Now that we're loading the links asynchronously, the new table means the visited
link state of all renderers is out-of-date because we loaded all of the hashes
from disk without sending notifications. I think this only happens in Reset().
The NewTable() assumes the contents are the same but the table was expanded, so
isn't sufficient, but obviously the NewTable call has to happen first for the
new link state to be updated. Otherwise the link state on the initial tabs will
be incorrect.

If we move NewTable up above, the Reset() needs to stay at the bottom.

 }
 
 bool VisitedLinkMaster::InitFromScratch(bool suppress_rebuild) {
-  int32 table_size = kDefaultTableSize;
-  if (table_size_override_)
-    table_size = table_size_override_;
-
   // The salt must be generated before the table so that it can be copied to
   // the shared memory.
   GenerateSalt(salt_);
-  if (!CreateURLTable(table_size, true))
+  if (!CreateURLTable(DefaultTableSize()))
     return false;
 
 #ifndef NDEBUG
   DebugValidate();
 #endif
 
   if (suppress_rebuild && persist_to_disk_) {
     // When we disallow rebuilds (normally just unit tests), just use the
     // 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 RebuildTableFromDelegate();
 }
 
+// static
 bool VisitedLinkMaster::ReadFileHeader(FILE* file,
                                        int32* num_entries,
                                        int32* used_count,
                                        uint8 salt[LINK_SALT_LENGTH]) {
-  DCHECK(persist_to_disk_);
-
   // 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.
   if (fseek(file, 0, SEEK_END) == -1)
     return false;
   size_t file_size = ftell(file);
 
   if (file_size <= kFileHeaderSize)
     return false;
@@ skipping 43 matching lines @@
   if (!browser_context_ || browser_context_->GetPath().empty())
     return false;
 
   base::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) {
+bool VisitedLinkMaster::CreateURLTable(int32 num_entries) {
+  scoped_ptr<base::SharedMemory> shared_memory;
+  VisitedLinkCommon::Fingerprint* hash_table;
+  if (CreateApartURLTable(num_entries, salt_, &shared_memory, &hash_table)) {
+    shared_memory_ = shared_memory.release();
+    hash_table_ = hash_table;
+    table_length_ = num_entries;
+    used_items_ = 0;
+    return true;
+  }
+
+  return false;
+}
+
+// static
+bool VisitedLinkMaster::CreateApartURLTable(
+    int32 num_entries,
+    const uint8 salt[LINK_SALT_LENGTH],
+    scoped_ptr<base::SharedMemory>* shared_memory,
+    VisitedLinkCommon::Fingerprint** hash_table) {
+  DCHECK(salt);
+  DCHECK(shared_memory);
+  DCHECK(hash_table);
+
   // The table is the size of the table followed by the entries.
   uint32 alloc_size = num_entries * sizeof(Fingerprint) + sizeof(SharedHeader);
 
   // Create the shared memory object.
-  shared_memory_ = new base::SharedMemory();
-  if (!shared_memory_)
+  scoped_ptr<base::SharedMemory> sh_mem(new base::SharedMemory());
+  if (!sh_mem)
     return false;
 
   base::SharedMemoryCreateOptions options;
   options.size = alloc_size;
   options.share_read_only = true;
 
-  if (!shared_memory_->Create(options) || !shared_memory_->Map(alloc_size)) {
-    delete shared_memory_;
-    shared_memory_ = NULL;
+  if (!sh_mem->Create(options) || !sh_mem->Map(alloc_size))
     return false;
-  }
 
-  if (init_to_empty) {
-    memset(shared_memory_->memory(), 0, alloc_size);
-    used_items_ = 0;
-  }
-  table_length_ = num_entries;
+  memset(sh_mem->memory(), 0, alloc_size);
 
   // Save the header for other processes to read.
-  SharedHeader* header = static_cast<SharedHeader*>(shared_memory_->memory());
-  header->length = table_length_;
-  memcpy(header->salt, salt_, LINK_SALT_LENGTH);
+  SharedHeader* header = static_cast<SharedHeader*>(sh_mem->memory());
+  header->length = num_entries;
+  memcpy(header->salt, salt, LINK_SALT_LENGTH);
 
   // Our table pointer is just the data immediately following the size.
-  hash_table_ = reinterpret_cast<Fingerprint*>(
-      static_cast<char*>(shared_memory_->memory()) + sizeof(SharedHeader));
+  *hash_table = reinterpret_cast<Fingerprint*>(
+      static_cast<char*>(sh_mem->memory()) + sizeof(SharedHeader));
+
+  *shared_memory = sh_mem.Pass();
 
   return true;
 }
 
 bool VisitedLinkMaster::BeginReplaceURLTable(int32 num_entries) {
   base::SharedMemory *old_shared_memory = shared_memory_;
   Fingerprint* old_hash_table = hash_table_;
   int32 old_table_length = table_length_;
-  if (!CreateURLTable(num_entries, true)) {
+  if (!CreateURLTable(num_entries)) {
     // Try to put back the old state.
     shared_memory_ = old_shared_memory;
     hash_table_ = old_hash_table;
     table_length_ = old_table_length;
     return false;
   }
 
 #ifndef NDEBUG
   DebugValidate();
 #endif
@@ skipping 69 matching lines @@
 
 #ifndef NDEBUG
   DebugValidate();
 #endif
 
   // The new table needs to be written to disk.
   if (persist_to_disk_)
     WriteFullTable();
 }
 
+uint32 VisitedLinkMaster::DefaultTableSize() const {
+  if (table_size_override_)
+    return table_size_override_;
+
+  return kDefaultTableSize;
+}
+
 uint32 VisitedLinkMaster::NewTableSizeForCount(int32 item_count) const {
   // These table sizes are selected to be the maximum prime number less than
   // a "convenient" multiple of 1K.
   static const int table_sizes[] = {
       16381,    // 16K  = 16384   <- don't shrink below this table size
                 //                   (should be == default_table_size)
       32767,    // 32K  = 32768
       65521,    // 64K  = 65536
       130051,   // 128K = 131072
       262127,   // 256K = 262144
@@ skipping 34 matching lines @@
     bool success,
     const std::vector<Fingerprint>& fingerprints) {
   if (success) {
     // Replace the old table with a new blank one.
     shared_memory_serial_++;
 
     // We are responsible for freeing it AFTER it has been replaced if
     // replacement succeeds.
     base::SharedMemory* old_shared_memory = shared_memory_;
 
-    int new_table_size = NewTableSizeForCount(
-        static_cast<int>(fingerprints.size() + added_since_rebuild_.size()));
+    int new_table_size =
+        NewTableSizeForCount(static_cast<int>(fingerprints.size() +
+                             added_since_rebuild_or_load_.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], 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)
+      for (std::set<Fingerprint>::iterator i =
+               added_since_rebuild_or_load_.begin();
+           i != added_since_rebuild_or_load_.end(); ++i)
         AddFingerprint(*i, false);
-      added_since_rebuild_.clear();
+      added_since_rebuild_or_load_.clear();
 
       // Now handle deletions.
-      DeleteFingerprintsFromCurrentTable(deleted_since_rebuild_);
-      deleted_since_rebuild_.clear();
+      DeleteFingerprintsFromCurrentTable(deleted_since_rebuild_or_load_);
+      deleted_since_rebuild_or_load_.clear();
 
       // Send an update notification to all child processes.
       listener_->NewTable(shared_memory_);
 
       if (persist_to_disk_)
         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_.is_null()) {
     rebuild_complete_task_.Run();
     rebuild_complete_task_.Reset();
   }
 }
 
 void VisitedLinkMaster::WriteToFile(FILE** file,
                                     off_t offset,
                                     void* data,
                                     int32 data_size) {
   DCHECK(persist_to_disk_);
-#ifndef NDEBUG
-  posted_asynchronous_operation_ = true;
-#endif
+  DCHECK(!table_is_loading_from_file_);
   PostIOTask(FROM_HERE,
       base::Bind(&AsyncWrite, file, offset,
                  std::string(static_cast<const char*>(data), data_size)));
 }
 
 void VisitedLinkMaster::WriteUsedItemCountToFile() {
   DCHECK(persist_to_disk_);
   if (!file_)
     return;  // See comment on the file_ variable for why this might happen.
   WriteToFile(file_, kFileHeaderUsedOffset, &used_items_, sizeof(used_items_));
@@ skipping 14 matching lines @@
     WriteToFile(file_, kFileHeaderSize, hash_table_,
                 (last_hash + 1) * sizeof(Fingerprint));
   } else {
     // Normal case, just write the range.
     WriteToFile(file_, first_hash * sizeof(Fingerprint) + kFileHeaderSize,
                 &hash_table_[first_hash],
                 (last_hash - first_hash + 1) * sizeof(Fingerprint));
   }
 }
 
+// static
 bool VisitedLinkMaster::ReadFromFile(FILE* file,
                                      off_t offset,
                                      void* data,
                                      size_t data_size) {
-  DCHECK(persist_to_disk_);
-#ifndef NDEBUG
-  // Since this function is synchronous, we require that no asynchronous
-  // operations could possibly be pending.
-  DCHECK(!posted_asynchronous_operation_);
-#endif
-
   if (fseek(file, offset, SEEK_SET) != 0)
     return false;
 
   size_t num_read = fread(data, 1, data_size, file);
   return num_read == data_size;
 }
 
 // VisitedLinkTableBuilder ----------------------------------------------------
 
 VisitedLinkMaster::TableBuilder::TableBuilder(
@@ skipping 28 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TableBuilder::OnCompleteMainThread, this));
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 }
 
 }  // namespace visitedlink