Switch to standard integer types in components/, part 4 of 4.

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>
-#endif  // defined(OS_WIN)
 #include <stdio.h>
+#include <string.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/containers/stack_container.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
+#include "build/build_config.h"
 #include "components/visitedlink/browser/visitedlink_delegate.h"
 #include "components/visitedlink/browser/visitedlink_event_listener.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
+#if defined(OS_WIN)
+#include <windows.h>
+#include <io.h>
+#include <shlobj.h>
+#endif  // defined(OS_WIN)
+
 using content::BrowserThread;
 
 namespace visitedlink {
 
-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_t VisitedLinkMaster::kFileHeaderSignatureOffset = 0;
+const int32_t VisitedLinkMaster::kFileHeaderVersionOffset = 4;
+const int32_t VisitedLinkMaster::kFileHeaderLengthOffset = 8;
+const int32_t VisitedLinkMaster::kFileHeaderUsedOffset = 12;
+const int32_t VisitedLinkMaster::kFileHeaderSaltOffset = 16;
 
-const int32 VisitedLinkMaster::kFileCurrentVersion = 3;
+const int32_t VisitedLinkMaster::kFileCurrentVersion = 3;
 
 // the signature at the beginning of the URL table = "VLnk" (visited links)
-const int32 VisitedLinkMaster::kFileSignature = 0x6b6e4c56;
+const int32_t 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 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]) {
+void GenerateSalt(uint8_t salt[LINK_SALT_LENGTH]) {
   DCHECK_EQ(LINK_SALT_LENGTH, 8) << "This code assumes the length of the salt";
-  uint64 randval = base::RandUint64();
+  uint64_t randval = base::RandUint64();
   memcpy(salt, &randval, 8);
 }
 
 // Opens file on a background thread to not block UI thread.
 void AsyncOpen(FILE** file, const base::FilePath& filename) {
   *file = base::OpenFile(filename, "wb+");
   DLOG_IF(ERROR, !(*file)) << "Failed to open file " << filename.value();
 }
 
 // Returns true if the write was complete.
@@ skipping 12 matching lines @@
   // 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. Double pointer to FILE
 // is used because file may still not be opened by the time of scheduling
 // the task for execution.
-void AsyncWrite(FILE** file, int32 offset, const std::string& data) {
+void AsyncWrite(FILE** file, int32_t offset, const std::string& data) {
   if (*file)
     WriteToFile(*file, offset, data.data(), data.size());
 }
 
 // Truncates the file to the current position asynchronously on a background
 // thread. Double pointer to FILE is used because file may still not be opened
 // by the time of scheduling the task for execution.
 void AsyncTruncate(FILE** file) {
   if (*file)
     base::IgnoreResult(base::TruncateFile(*file));
 }
 
 // Closes the file on a background thread and releases memory used for storage
 // 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]);
+                     int32_t num_entries,
+                     int32_t used_count,
+                     uint8_t 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];
+  int32_t num_entries;
+  int32_t used_count;
+  uint8_t 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])
+    int32_t num_entries,
+    int32_t used_count,
+    uint8_t 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() {
 }
@@ skipping 13 matching lines @@
 // master then replaces its table with a new table containing the computed
 // fingerprints.
 //
 // The builder must remain active while the history system is using it.
 // Sometimes, the master will be deleted before the rebuild is complete, in
 // which case it notifies the builder via DisownMaster(). The builder will
 // delete itself once rebuilding is complete, and not execute any callback.
 class VisitedLinkMaster::TableBuilder
     : public VisitedLinkDelegate::URLEnumerator {
  public:
-  TableBuilder(VisitedLinkMaster* master,
-               const uint8 salt[LINK_SALT_LENGTH]);
+  TableBuilder(VisitedLinkMaster* master, const uint8_t salt[LINK_SALT_LENGTH]);
 
   // Called on the main thread when the master is being destroyed. This will
   // prevent a crash when the query completes and the master is no longer
   // around. We can not actually do anything but mark this fact, since the
   // table will be being rebuilt simultaneously on the other thread.
   void DisownMaster();
 
   // VisitedLinkDelegate::URLEnumerator
   void OnURL(const GURL& url) override;
   void OnComplete(bool succeed) override;
 
  private:
   ~TableBuilder() override {}
 
   // 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_;
 
   // Indicates whether the operation has failed or not.
   bool success_;
 
   // Salt for this new table.
-  uint8 salt_[LINK_SALT_LENGTH];
+  uint8_t salt_[LINK_SALT_LENGTH];
 
   // Stores the fingerprints we computed on the background thread.
   VisitedLinkCommon::Fingerprints fingerprints_;
 
   DISALLOW_COPY_AND_ASSIGN(TableBuilder);
 };
 
 // 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),
       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)
+                                     int32_t default_table_size)
     : browser_context_(NULL),
       delegate_(delegate),
       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;
@@ skipping 341 matching lines @@
   DCHECK(persist_to_disk_);
 
   if (!file_) {
     file_ = static_cast<FILE**>(calloc(1, sizeof(*file_)));
     base::FilePath filename;
     GetDatabaseFileName(&filename);
     PostIOTask(FROM_HERE, base::Bind(&AsyncOpen, file_, filename));
   }
 
   // Write the new header.
-  int32 header[4];
+  int32_t header[4];
   header[0] = kFileSignature;
   header[1] = kFileCurrentVersion;
   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));
@@ skipping 37 matching lines @@
 // 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;
-  uint8 salt[LINK_SALT_LENGTH];
+  int32_t num_entries, used_count;
+  uint8_t 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.
   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,
@@ skipping 117 matching lines @@
   // 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]) {
+                                       int32_t* num_entries,
+                                       int32_t* used_count,
+                                       uint8_t salt[LINK_SALT_LENGTH]) {
   // 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];
+  uint8_t header[kFileHeaderSize];
   if (!ReadFromFile(file, 0, &header, kFileHeaderSize))
     return false;
 
   // Verify the signature.
-  int32 signature;
+  int32_t 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;
+  int32_t 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.
@@ skipping 18 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 VisitedLinkMaster::CreateURLTable(int32_t 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],
+    int32_t num_entries,
+    const uint8_t 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);
+  uint32_t alloc_size =
+      num_entries * sizeof(Fingerprint) + sizeof(SharedHeader);
 
   // Create the shared memory object.
   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 (!sh_mem->Create(options) || !sh_mem->Map(alloc_size))
     return false;
 
   memset(sh_mem->memory(), 0, alloc_size);
 
   // Save the header for other processes to read.
   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*>(sh_mem->memory()) + sizeof(SharedHeader));
 
   *shared_memory = sh_mem.Pass();
 
   return true;
 }
 
-bool VisitedLinkMaster::BeginReplaceURLTable(int32 num_entries) {
+bool VisitedLinkMaster::BeginReplaceURLTable(int32_t num_entries) {
   base::SharedMemory *old_shared_memory = shared_memory_;
   Fingerprint* old_hash_table = hash_table_;
-  int32 old_table_length = table_length_;
+  int32_t old_table_length = table_length_;
   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();
@@ skipping 31 matching lines @@
     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;
 }
 
-void VisitedLinkMaster::ResizeTable(int32 new_size) {
+void VisitedLinkMaster::ResizeTable(int32_t new_size) {
   DCHECK(shared_memory_ && shared_memory_->memory() && hash_table_);
   shared_memory_serial_++;
 
 #ifndef NDEBUG
   DebugValidate();
 #endif
 
   base::SharedMemory* old_shared_memory = shared_memory_;
   Fingerprint* old_hash_table = hash_table_;
-  int32 old_table_length = table_length_;
+  int32_t old_table_length = table_length_;
   if (!BeginReplaceURLTable(new_size))
     return;
 
   // Now we have two tables, our local copy which is the old one, and the new
   // one loaded into this object where we need to copy the data.
-  for (int32 i = 0; i < old_table_length; i++) {
+  for (int32_t i = 0; i < old_table_length; i++) {
     Fingerprint cur = old_hash_table[i];
     if (cur)
       AddFingerprint(cur, false);
   }
 
   // On error unmapping, just forget about it since we can't do anything
   // else to release it.
   delete old_shared_memory;
 
   // Send an update notification to all child processes so they read the new
   // table.
   listener_->NewTable(shared_memory_);
 
 #ifndef NDEBUG
   DebugValidate();
 #endif
 
   // The new table needs to be written to disk.
   if (persist_to_disk_)
     WriteFullTable();
 }
 
-uint32 VisitedLinkMaster::DefaultTableSize() const {
+uint32_t VisitedLinkMaster::DefaultTableSize() const {
   if (table_size_override_)
     return table_size_override_;
 
   return kDefaultTableSize;
 }
 
-uint32 VisitedLinkMaster::NewTableSizeForCount(int32 item_count) const {
+uint32_t VisitedLinkMaster::NewTableSizeForCount(int32_t 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
       524269,   // 512K = 524288
@@ skipping 77 matching lines @@
   // 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) {
+                                    int32_t data_size) {
   DCHECK(persist_to_disk_);
   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_)
@@ skipping 32 matching lines @@
     return false;
 
   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) {
+    const uint8_t salt[LINK_SALT_LENGTH])
+    : master_(master), success_(true) {
   fingerprints_.reserve(4096);
-  memcpy(salt_, salt, LINK_SALT_LENGTH * sizeof(uint8));
+  memcpy(salt_, salt, LINK_SALT_LENGTH * sizeof(uint8_t));
 }
 
 // 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()) {
@@ skipping 12 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TableBuilder::OnCompleteMainThread, this));
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 }
 
 }  // namespace visitedlink