Roll forward 8722,8721

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>
 
+#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"
+#if defined(OS_WIN)
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/profile.h"
+#else
+// TODO(port): We should be using history.h & profile.h, remove scaffolding
+// when those are ported.
+#include "chrome/common/temp_scaffolding_stubs.h"
+#endif  // !defined(OS_WIN)
+#if defined(OS_WIN)
 #include "chrome/common/win_util.h"
+#endif
+
+using file_util::ScopedFILE;
+using file_util::OpenFile;
+using file_util::TruncateFile;
 
 const int32 VisitedLinkMaster::kFileHeaderSignatureOffset = 0;
 const int32 VisitedLinkMaster::kFileHeaderVersionOffset = 4;
 const int32 VisitedLinkMaster::kFileHeaderLengthOffset = 8;
 const int32 VisitedLinkMaster::kFileHeaderUsedOffset = 12;
 const int32 VisitedLinkMaster::kFileHeaderSaltOffset = 16;
 
 const int32 VisitedLinkMaster::kFileCurrentVersion = 2;
 
 // the signature at the beginning of the URL table = "VLnk" (visited links)
 const int32 VisitedLinkMaster::kFileSignature = 0x6b6e4c56;
 const size_t VisitedLinkMaster::kFileHeaderSize =
     kFileHeaderSaltOffset + LINK_SALT_LENGTH;
 
 // This value should also be the same as the smallest size in the lookup
 // table in NewTableSizeForCount (prime number).
 const unsigned VisitedLinkMaster::kDefaultTableSize = 16381;
 
-const int32 VisitedLinkMaster::kBigDeleteThreshold = 64;
+const size_t VisitedLinkMaster::kBigDeleteThreshold = 64;
 
 namespace {
 
 // 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 ----------------------------------------------------------------
 
 // 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(HANDLE hfile, int32 offset, const void* data, int32 data_len)
-      : hfile_(hfile),
+  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(hfile_, offset_,
+    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(HANDLE hfile,
-                          int32 offset,
+  static bool WriteToFile(FILE* file,
+                          off_t offset,
                           const void* data,
-                          int32 data_len) {
-    if (SetFilePointer(hfile, offset, NULL, FILE_BEGIN) ==
-        INVALID_SET_FILE_POINTER)
+                          size_t data_len) {
+    if (fseek(file, offset, SEEK_SET) != 0)
       return false;  // Don't write to an invalid part of the file.
 
-    DWORD num_written;
-    return WriteFile(hfile, data, data_len, &num_written, NULL) &&
-           (num_written == data_len);
+    size_t num_written = fwrite(data, 1, data_len, file);
+    return num_written == data_len;
   }
 
  private:
   // The data to write and where to write it.
-  HANDLE hfile_;
+  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_EVIL_CONSTRUCTORS(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(HANDLE hfile) : hfile_(hfile) {}
+  explicit AsyncSetEndOfFile(FILE* file) : file_(file) {}
 
   virtual void Run() {
-    SetEndOfFile(hfile_);
+    TruncateFile(file_);
   }
 
  private:
-  HANDLE hfile_;
+  FILE* file_;
   DISALLOW_EVIL_CONSTRUCTORS(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(HANDLE hfile) : hfile_(hfile) {}
+  explicit AsyncCloseHandle(FILE* file) : file_(file) {}
 
   virtual void Run() {
-    CloseHandle(hfile_);
+    fclose(file_);
   }
 
  private:
-  HANDLE hfile_;
+  FILE* file_;
   DISALLOW_EVIL_CONSTRUCTORS(AsyncCloseHandle);
 };
 
 }  // namespace
 
 // TableBuilder ---------------------------------------------------------------
 
 // How rebuilding from history works
 // ---------------------------------
 //
@@ skipping 53 matching lines @@
 VisitedLinkMaster::VisitedLinkMaster(base::Thread* file_thread,
                                      PostNewTableEvent* poster,
                                      Profile* profile) {
   InitMembers(file_thread, poster, profile);
 }
 
 VisitedLinkMaster::VisitedLinkMaster(base::Thread* file_thread,
                                      PostNewTableEvent* poster,
                                      HistoryService* history_service,
                                      bool suppress_rebuild,
-                                     const std::wstring& filename,
+                                     const FilePath& filename,
                                      int32 default_table_size) {
   InitMembers(file_thread, poster, NULL);
 
-  database_name_override_.assign(filename);
+  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
@@ skipping 29 matching lines @@
 // The shared memory name should be unique on the system and also needs to
 // change when we create a new table. The scheme we use includes the process
 // ID, an increasing serial number, and the profile ID.
 std::wstring VisitedLinkMaster::GetSharedMemoryName() const {
   // When unit testing, there's no profile, so use an empty ID string.
   std::wstring profile_id;
   if (profile_)
     profile_id = profile_->GetID().c_str();
 
   return StringPrintf(L"GVisitedLinks_%lu_%lu_%ls",
-                      GetCurrentProcessId(), shared_memory_serial_,
+                      base::GetCurrentProcId(), shared_memory_serial_,
                       profile_id.c_str());
 }
 
 bool VisitedLinkMaster::Init() {
   if (!InitFromFile())
     return InitFromScratch(suppress_rebuild_);
   return true;
 }
 
 bool VisitedLinkMaster::ShareToProcess(base::ProcessHandle process,
@@ skipping 243 matching lines @@
   // since there may be write operations pending on the file I/O thread.
   //
   // Note that once we start writing, we do not delete on error. This means
   // there can be a partial file, but the short file will be detected next time
   // we start, and will be replaced.
   //
   // This might possibly get corrupted if we crash in the middle of writing.
   // We should pick up the most common types of these failures when we notice
   // that the file size is different when we load it back in, and then we will
   // regenerate the table.
-  win_util::ScopedHandle hfile_closer;  // Valid only when not open already.
-  HANDLE hfile;                         // Always valid.
+  ScopedFILE file_closer;  // Valid only when not open already.
+  FILE* file;                         // Always valid.
   if (file_) {
-    hfile = file_;
+    file = file_;
   } else {
-    std::wstring filename;
+    FilePath filename;
     GetDatabaseFileName(&filename);
-    hfile_closer.Set(
-        CreateFile(filename.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL,
-                   CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL));
-    if (!hfile_closer.IsValid())
+    file_closer.reset(OpenFile(filename, "wb+"));
+    if (!file_closer.get()) {
+      DLOG(ERROR) << "Failed to open file " << filename.value();
       return false;
-    hfile = hfile_closer;
+    }
+    file = file_closer.get();
   }
 
   // Write the new header.
   int32 header[4];
   header[0] = kFileSignature;
   header[1] = kFileCurrentVersion;
   header[2] = table_length_;
   header[3] = used_items_;
-  WriteToFile(hfile, 0, header, sizeof(header));
-  WriteToFile(hfile, sizeof(header), salt_, LINK_SALT_LENGTH);
+  WriteToFile(file, 0, header, sizeof(header));
+  WriteToFile(file, sizeof(header), salt_, LINK_SALT_LENGTH);
 
   // Write the hash data.
-  WriteToFile(hfile, kFileHeaderSize,
+  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(hfile);
+    AsyncSetEndOfFile* setter = new AsyncSetEndOfFile(file);
     file_thread_->PostTask(FROM_HERE, setter);
   } else {
-    SetEndOfFile(hfile);
+    TruncateFile(file);
   }
 
   // Keep the file open so we can dynamically write changes to it. When the
-  // file was alrady open, the hfile_closer is NULL, and file_ is already good.
-  if (hfile_closer.IsValid())
-    file_ = hfile_closer.Take();
+  // file was already open, the file_closer is NULL, and file_ is already good.
+  if (file_closer.get())
+    file_ = file_closer.release();
   return true;
 }
 
 bool VisitedLinkMaster::InitFromFile() {
   DCHECK(file_ == NULL);
 
-  std::wstring filename;
+  FilePath filename;
   GetDatabaseFileName(&filename);
-  win_util::ScopedHandle hfile(
-      CreateFile(filename.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL,
-                 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL));
-  if (!hfile.IsValid())
+  ScopedFILE file_closer(OpenFile(filename, "rb+"));
+  if (!file_closer.get()) {
+    DLOG(ERROR) << "Failed to open file " << filename.value();
     return false;
+  }
 
   int32 num_entries, used_count;
-  if (!ReadFileHeader(hfile, &num_entries, &used_count, salt_))
+  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))
     return false;
-  if (!ReadFromFile(hfile, kFileHeaderSize,
+  if (!ReadFromFile(file_closer.get(), kFileHeaderSize,
                     hash_table_, num_entries * sizeof(Fingerprint))) {
     FreeURLTable();
     return false;
   }
   used_items_ = used_count;
 
-  file_ = hfile.Take();
+  file_ = file_closer.release();
   return true;
 }
 
 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))
     return false;
 
   if (suppress_rebuild) {
     // When we disallow rebuilds (normally just unit tests), just use the
     // current empty table.
     return WriteFullTable();
   }
 
   // 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 RebuildTableFromHistory();
 }
 
-bool VisitedLinkMaster::ReadFileHeader(HANDLE hfile,
+bool VisitedLinkMaster::ReadFileHeader(FILE* file,
                                        int32* num_entries,
                                        int32* used_count,
                                        uint8 salt[LINK_SALT_LENGTH]) {
-  int32 file_size = GetFileSize(hfile, NULL);
+  // 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;
 
   uint8 header[kFileHeaderSize];
-  if (!ReadFromFile(hfile, 0, &header, kFileHeaderSize))
+  if (!ReadFromFile(file, 0, &header, kFileHeaderSize))
     return false;
 
   // Verify the signature.
-  uint32 signature;
+  int32 signature;
   memcpy(&signature, &header[kFileHeaderSignatureOffset], sizeof(signature));
   if (signature != kFileSignature)
     return false;
 
   // Verify the version is up-to-date. As with other read errors, a version
   // mistmatch will trigger a rebuild of the database from history, which will
   // have the effect of migrating the database.
   int32 version;
   memcpy(&version, &header[kFileHeaderVersionOffset], sizeof(version));
   if (version != kFileCurrentVersion)
     return false;  // Bad version.
 
   // Read the table size and make sure it matches the file size.
   memcpy(num_entries, &header[kFileHeaderLengthOffset], sizeof(*num_entries));
   if (*num_entries * sizeof(Fingerprint) + kFileHeaderSize != file_size)
     return false;  // Bad size.
 
   // Read the used item count.
   memcpy(used_count, &header[kFileHeaderUsedOffset], sizeof(*used_count));
   if (*used_count > *num_entries)
     return false;  // Bad used item count;
 
   // Read the salt.
   memcpy(salt, &header[kFileHeaderSaltOffset], LINK_SALT_LENGTH);
 
   // This file looks OK from the header's perspective.
   return true;
 }
 
-bool VisitedLinkMaster::GetDatabaseFileName(std::wstring* filename) {
+bool VisitedLinkMaster::GetDatabaseFileName(FilePath* filename) {
   if (!database_name_override_.empty()) {
     // use this filename, the directory must exist
     *filename = database_name_override_;
     return true;
   }
 
   if (!profile_ || profile_->GetPath().empty())
     return false;
 
-  *filename = profile_->GetPath();
-  filename->append(L"\\Visited Links");
+  FilePath profile_dir = FilePath::FromWStringHack(profile_->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) {
   // The table is the size of the table followed by the entries.
   int32 alloc_size = num_entries * sizeof(Fingerprint) + sizeof(SharedHeader);
 
   // Create the shared memory object.
@@ skipping 51 matching lines @@
 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 {
-      CloseHandle(file_);
+      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.
   const float min_table_load = 0.2f;  // Shrink when we're < this full.
 
   float load = ComputeTableLoad();
   if (load < max_table_load &&
-      (table_length_ <= kDefaultTableSize || load > min_table_load))
+      (table_length_ <= static_cast<float>(kDefaultTableSize) ||
+       load > min_table_load))
     return false;
 
   // Table needs to grow or shrink.
   int new_size = NewTableSizeForCount(used_items_);
   DCHECK(new_size > used_items_);
   DCHECK(load <= min_table_load || new_size > table_length_);
   ResizeTable(new_size);
   return true;
 }
 
@@ skipping 50 matching lines @@
       2097143,  // 2M   = 2097152
       4194301,  // 4M   = 4194304
       8388571,  // 8M   = 8388608
       16777199,  // 16M  = 16777216
       33554347};  // 32M  = 33554432
 
   // Try to leave the table 33% full.
   int desired = item_count * 3;
 
   // Find the closest prime.
-  for (int i = 0; i < arraysize(table_sizes); i ++) {
+  for (size_t i = 0; i < arraysize(table_sizes); i ++) {
     if (table_sizes[i] > desired)
       return table_sizes[i];
   }
 
   // Growing very big, just approximate a "good" number, not growing as much
   // as normal.
   return item_count * 2 - 1;
 }
 
 // See the TableBuilder definition in the header file for how this works.
@@ skipping 64 matching lines @@
   }
   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_.get()) {
     rebuild_complete_task_->Run();
     rebuild_complete_task_.reset(NULL);
   }
 }
 
-void VisitedLinkMaster::WriteToFile(HANDLE hfile,
-                                    int32 offset,
+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(hfile, offset, data, data_size);
+    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(hfile, offset, data, data_size);
+    AsyncWriter::WriteToFile(file, offset, data, data_size);
   }
 }
 
 void VisitedLinkMaster::WriteUsedItemCountToFile() {
   WriteToFile(file_, kFileHeaderUsedOffset, &used_items_, sizeof(used_items_));
 }
 
 void VisitedLinkMaster::WriteHashRangeToFile(Hash first_hash, Hash last_hash) {
   if (last_hash < first_hash) {
     // Handle wraparound at 0. This first write is first_hash->EOF
     WriteToFile(file_, first_hash * sizeof(Fingerprint) + kFileHeaderSize,
                 &hash_table_[first_hash],
                 (table_length_ - first_hash + 1) * sizeof(Fingerprint));
 
     // Now do 0->last_lash.
     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));
   }
 }
 
-bool VisitedLinkMaster::ReadFromFile(HANDLE hfile,
-                                     int32 offset,
+bool VisitedLinkMaster::ReadFromFile(FILE* file,
+                                     off_t offset,
                                      void* data,
-                                     int32 data_size) {
+                                     size_t data_size) {
 #ifndef NDEBUG
   // Since this function is synchronous, we require that no asynchronous
   // operations could possibly be pending.
   DCHECK(!posted_asynchronous_operation_);
 #endif
 
-  SetFilePointer(hfile, offset, NULL, FILE_BEGIN);
+  fseek(file, offset, SEEK_SET);
 
-  DWORD num_read;
-  return ReadFile(hfile, data, data_size, &num_read, NULL) &&
-         num_read == data_size;
+  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),
-      success_(true),
-      main_message_loop_(MessageLoop::current()) {
+      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;
 }
 
@@ skipping 15 matching lines @@
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 
   // WILL (generally) DELETE THIS! This balances the AddRef in
   // VisitedLinkMaster::RebuildTableFromHistory.
   Release();
 }