Third patch in getting rid of caching MessageLoop pointers and always using C...

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>
 #endif  // defined(OS_WIN)
 #include <stdio.h>
 
 #include <algorithm>
 
 #if defined(OS_WIN)
 #include "app/win_util.h"
 #endif
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/stack_container.h"
 #include "base/string_util.h"
-#include "base/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/profile.h"
 
 using file_util::ScopedFILE;
 using file_util::OpenFile;
 using file_util::TruncateFile;
 
 const int32 VisitedLinkMaster::kFileHeaderSignatureOffset = 0;
 const int32 VisitedLinkMaster::kFileHeaderVersionOffset = 4;
@@ skipping 145 matching lines @@
   virtual void OnComplete(bool succeed);
 
  private:
   // OnComplete mashals to this function on the main thread to do the
   // notification.
   void OnCompleteMainThread();
 
   // Owner of this object. MAY ONLY BE ACCESSED ON THE MAIN THREAD!
   VisitedLinkMaster* master_;
 
-  // 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.
   VisitedLinkCommon::Fingerprints fingerprints_;
 };
 
 // VisitedLinkMaster ----------------------------------------------------------
 
-VisitedLinkMaster::VisitedLinkMaster(base::Thread* file_thread,
-                                     Listener* listener,
+VisitedLinkMaster::VisitedLinkMaster(Listener* listener,
                                      Profile* profile) {
-  InitMembers(file_thread, listener, profile);
+  InitMembers(listener, profile);
 }
 
-VisitedLinkMaster::VisitedLinkMaster(base::Thread* file_thread,
-                                     Listener* listener,
+VisitedLinkMaster::VisitedLinkMaster(Listener* listener,
                                      HistoryService* history_service,
                                      bool suppress_rebuild,
                                      const FilePath& filename,
                                      int32 default_table_size) {
-  InitMembers(file_thread, listener, NULL);
+  InitMembers(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,
-                                    Listener* listener,
-                                    Profile* profile) {
+void VisitedLinkMaster::InitMembers(Listener* listener, Profile* profile) {
   DCHECK(listener);
 
-  if (file_thread)
-    file_thread_ = file_thread->message_loop();
-  else
-    file_thread_ = NULL;
-
   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;
 
@@ skipping 287 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.
-  if (file_thread_) {
-    AsyncSetEndOfFile* setter = new AsyncSetEndOfFile(file_);
-    file_thread_->PostTask(FROM_HERE, setter);
-  } else {
-    TruncateFile(file_);
-  }
-
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE, new AsyncSetEndOfFile(file_));
   return true;
 }
 
 bool VisitedLinkMaster::InitFromFile() {
   DCHECK(file_ == NULL);
 
   FilePath filename;
   GetDatabaseFileName(&filename);
   ScopedFILE file_closer(OpenFile(filename, "rb+"));
   if (!file_closer.get())
@@ skipping 174 matching lines @@
 #endif
 
   return true;
 }
 
 void VisitedLinkMaster::FreeURLTable() {
   if (shared_memory_) {
     delete shared_memory_;
     shared_memory_ = NULL;
   }
-  if (file_) {
-    if (file_thread_) {
-      AsyncCloseHandle* closer = new AsyncCloseHandle(file_);
-      file_thread_->PostTask(FROM_HERE, closer);
-    } else {
-      fclose(file_);
-    }
-  }
+  if (!file_)
+    return;
+
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE, new AsyncCloseHandle(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 159 matching lines @@
 }
 
 void VisitedLinkMaster::WriteToFile(FILE* file,
                                     off_t offset,
                                     void* data,
                                     int32 data_size) {
 #ifndef NDEBUG
   posted_asynchronous_operation_ = true;
 #endif
 
-  if (file_thread_) {
-    // Send the write to the other thread for execution to avoid blocking.
-    AsyncWriter* writer = new AsyncWriter(file, offset, data, data_size);
-    file_thread_->PostTask(FROM_HERE, writer);
-  } else {
-    // When there is no I/O thread, we are probably running in unit test mode,
-    // just do the write synchronously.
-    AsyncWriter::WriteToFile(file, offset, data, data_size);
-  }
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      new AsyncWriter(file, offset, 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_));
 }
 
 void VisitedLinkMaster::WriteHashRangeToFile(Hash first_hash, Hash last_hash) {
   if (!file_)
@@ skipping 30 matching lines @@
   size_t num_read = fread(data, 1, data_size, file);
   return num_read == data_size;
 }
 
 // VisitedLinkTableBuilder ----------------------------------------------------
 
 VisitedLinkMaster::TableBuilder::TableBuilder(
     VisitedLinkMaster* master,
     const uint8 salt[LINK_SALT_LENGTH])
     : master_(master),
-      main_message_loop_(MessageLoop::current()),
       success_(true) {
   fingerprints_.reserve(4096);
   memcpy(salt_, salt, sizeof(salt));
 }
 
 // TODO(brettw): Do we want to try to cancel the request if this happens? It
 // could delay shutdown if there are a lot of URLs.
 void VisitedLinkMaster::TableBuilder::DisownMaster() {
   master_ = NULL;
 }
 
 void VisitedLinkMaster::TableBuilder::OnURL(const GURL& url) {
   if (!url.is_empty()) {
     fingerprints_.push_back(VisitedLinkMaster::ComputeURLFingerprint(
         url.spec().data(), url.spec().length(), salt_));
   }
 }
 
 void VisitedLinkMaster::TableBuilder::OnComplete(bool success) {
   success_ = success;
   DLOG_IF(WARNING, !success) << "Unable to rebuild visited links";
 
   // Marshal to the main thread to notify the VisitedLinkMaster that the
   // rebuild is complete.
-  main_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &TableBuilder::OnCompleteMainThread));
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      NewRunnableMethod(this, &TableBuilder::OnCompleteMainThread));
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 
   // WILL (generally) DELETE THIS! This balances the AddRef in
   // VisitedLinkMaster::RebuildTableFromHistory.
   Release();
 }