Hook up the SequencedWorkerPool to the browser thread.

chrome/browser/visitedlink/visitedlink_master.cc

 // Copyright (c) 2011 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/visitedlink_master.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <io.h>
 #include <shlobj.h>
@@ skipping 173 matching lines @@
 
   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;
+  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
@@ skipping 31 matching lines @@
   // 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) {
+  BrowserThread::GetBlockingPool()->PostSequencedWorkerTask(sequence_token_,
+                                                            from_here, task);
+}
+
 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 218 matching lines @@
   header[2] = table_length_;
   header[3] = used_items_;
   WriteToFile(file_, 0, header, sizeof(header));
   WriteToFile(file_, sizeof(header), salt_, LINK_SALT_LENGTH);
 
   // 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.
-  BrowserThread::PostTask(
-      BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&TruncateFile), file_));
+  PostIOTask(FROM_HERE, base::Bind(base::IgnoreResult(&TruncateFile), file_));
   return true;
 }
 
 bool VisitedLinkMaster::InitFromFile() {
   DCHECK(file_ == NULL);
 
   FilePath filename;
   GetDatabaseFileName(&filename);
   ScopedFILE file_closer(OpenFile(filename, "rb+"));
   if (!file_closer.get())
@@ skipping 169 matching lines @@
   return true;
 }
 
 void VisitedLinkMaster::FreeURLTable() {
   if (shared_memory_) {
     delete shared_memory_;
     shared_memory_ = NULL;
   }
   if (!file_)
     return;
-
-  BrowserThread::PostTask(
-      BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&fclose), file_));
+  PostIOTask(FROM_HERE, base::Bind(base::IgnoreResult(&fclose), file_));
 }
 
 bool VisitedLinkMaster::ResizeTableIfNecessary() {
   DCHECK(table_length_ > 0) << "Must have a table";
 
   // Load limits for good performance/space. We are pretty conservative about
   // keeping the table not very full. This is because we use linear probing
   // which increases the likelihood of clumps of entries which will reduce
   // performance.
   const float max_table_load = 0.5f;  // Grow when we're > this full.
@@ skipping 162 matching lines @@
   }
 }
 
 void VisitedLinkMaster::WriteToFile(FILE* file,
                                     off_t offset,
                                     void* data,
                                     int32 data_size) {
 #ifndef NDEBUG
   posted_asynchronous_operation_ = true;
 #endif
-
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
+  PostIOTask(FROM_HERE,
       base::Bind(&AsyncWrite, file, offset,
                  std::string(static_cast<const char*>(data), data_size)));
 }
 
 void VisitedLinkMaster::WriteUsedItemCountToFile() {
   if (!file_)
     return;  // See comment on the file_ variable for why this might happen.
   WriteToFile(file_, kFileHeaderUsedOffset, &used_items_, sizeof(used_items_));
 }
 
@@ skipping 70 matching lines @@
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 
   // WILL (generally) DELETE THIS! This balances the AddRef in
   // VisitedLinkMaster::RebuildTableFromHistory.
   Release();
 }