Remove custom Task implementations from VisitedLinkMaster and web_app.

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>
 #endif  // defined(OS_WIN)
 #include <stdio.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #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/threading/thread_restrictions.h"
 #include "chrome/browser/history/history.h"
@@ skipping 28 matching lines @@
 
 // Fills the given salt structure with some quasi-random values
 // It is not necessary to generate a cryptographically strong random string,
 // only that it be reasonably different for different users.
 void GenerateSalt(uint8 salt[LINK_SALT_LENGTH]) {
   DCHECK_EQ(LINK_SALT_LENGTH, 8) << "This code assumes the length of the salt";
   uint64 randval = base::RandUint64();
   memcpy(salt, &randval, 8);
 }
 
-// AsyncWriter ----------------------------------------------------------------
+// Returns true if the write was complete.
+static bool WriteToFile(FILE* file,
+                        off_t offset,
+                        const void* data,
+                        size_t data_len) {
+  if (fseek(file, offset, SEEK_SET) != 0)
+    return false;  // Don't write to an invalid part of the file.
+
+  size_t num_written = fwrite(data, 1, data_len, file);
+
+  // The write may not make it to the kernel (stdlib may buffer the write)
+  // until the next fseek/fclose call.  If we crash, it's easy for our used
+  // item count to be out of sync with the number of hashes we write.
+  // Protect against this by calling fflush.
+  int ret = fflush(file);
+  DCHECK_EQ(0, ret);
+  return num_written == data_len;
+}
 
 // This task executes on a background thread and executes a write. This
 // prevents us from blocking the UI thread doing I/O.
-class AsyncWriter : public Task {
- public:
-  AsyncWriter(FILE* file, int32 offset, const void* data, size_t data_len)
-      : file_(file),
-        offset_(offset) {
-    data_->resize(data_len);
-    memcpy(&*data_->begin(), data, data_len);
-  }
-
-  virtual void Run() {
-    WriteToFile(file_, offset_,
-                &*data_->begin(), static_cast<int32>(data_->size()));
-  }
-
-  // Exposed as a static so it can be called directly from the Master to
-  // reduce the number of platform-specific I/O sites we have. Returns true if
-  // the write was complete.
-  static bool WriteToFile(FILE* file,
-                          off_t offset,
-                          const void* data,
-                          size_t data_len) {
-    if (fseek(file, offset, SEEK_SET) != 0)
-      return false;  // Don't write to an invalid part of the file.
-
-    size_t num_written = fwrite(data, 1, data_len, file);
-
-    // The write may not make it to the kernel (stdlib may buffer the write)
-    // until the next fseek/fclose call.  If we crash, it's easy for our used
-    // item count to be out of sync with the number of hashes we write.
-    // Protect against this by calling fflush.
-    int ret = fflush(file);
-    DCHECK_EQ(0, ret);
-    return num_written == data_len;
-  }
-
- private:
-  // The data to write and where to write it.
-  FILE* file_;
-  int32 offset_;  // Offset from the beginning of the file.
-
-  // Most writes are just a single fingerprint, so we reserve that much in this
-  // object to avoid mallocs in that case.
-  StackVector<char, sizeof(VisitedLinkCommon::Fingerprint)> data_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncWriter);
-};
-
-// Used to asynchronously set the end of the file. This must be done on the
-// same thread as the writing to keep things synchronized.
-class AsyncSetEndOfFile : public Task {
- public:
-  explicit AsyncSetEndOfFile(FILE* file) : file_(file) {}
-
-  virtual void Run() {
-    TruncateFile(file_);
-  }
-
- private:
-  FILE* file_;
-  DISALLOW_COPY_AND_ASSIGN(AsyncSetEndOfFile);
-};
-
-// Used to asynchronously close a file. This must be done on the same thread as
-// the writing to keep things synchronized.
-class AsyncCloseHandle : public Task {
- public:
-  explicit AsyncCloseHandle(FILE* file) : file_(file) {}
-
-  virtual void Run() {
-    fclose(file_);
-  }
-
- private:
-  FILE* file_;
-  DISALLOW_COPY_AND_ASSIGN(AsyncCloseHandle);
-};
+void AsyncWrite(FILE* file, int32 offset, const std::string& data) {
+  WriteToFile(file, offset, data.data(), data.size());
+}
 
 }  // namespace
 
 // 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
@@ skipping 374 matching lines @@
   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, new AsyncSetEndOfFile(file_));
+      BrowserThread::FILE,
+      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 171 matching lines @@
 
 void VisitedLinkMaster::FreeURLTable() {
   if (shared_memory_) {
     delete shared_memory_;
     shared_memory_ = NULL;
   }
   if (!file_)
     return;
 
   BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE, new AsyncCloseHandle(file_));
+      BrowserThread::FILE,
+      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 165 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,
-      new AsyncWriter(file, offset, data, data_size));
+      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_));
 }
 
 void VisitedLinkMaster::WriteHashRangeToFile(Hash first_hash, Hash last_hash) {
   if (!file_)
@@ skipping 68 matching lines @@
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 
   // WILL (generally) DELETE THIS! This balances the AddRef in
   // VisitedLinkMaster::RebuildTableFromHistory.
   Release();
 }