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

components/visitedlink/browser/visitedlink_master.h

 // 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.
 
 #ifndef COMPONENTS_VISITEDLINK_BROWSER_VISITEDLINK_MASTER_H_
 #define COMPONENTS_VISITEDLINK_BROWSER_VISITEDLINK_MASTER_H_
 
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
+#include <stddef.h>
+#include <stdint.h>
+
 #include <set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/callback_forward.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/shared_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "build/build_config.h"
 #include "components/visitedlink/common/visitedlink_common.h"
 
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
 #if defined(UNIT_TEST) || defined(PERF_TEST) || !defined(NDEBUG)
 #include "base/logging.h"
 #endif
 
 class GURL;
 
 namespace content {
 class BrowserContext;
 }
 
@@ skipping 49 matching lines @@
   // this failure mode).
   //
   // When |suppress_rebuild| is set, we'll not attempt to load data from
   // history if the file can't be loaded. This should generally be set for
   // testing except when you want to test the rebuild process explicitly.
   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);
   ~VisitedLinkMaster() override;
 
   // Must be called immediately after object creation. Nothing else will work
   // until this is called. Returns true on success, false means that this
   // object won't work.
   bool Init();
 
   base::SharedMemory* shared_memory() { return shared_memory_; }
 
   // Adds a URL to the table.
@@ skipping 34 matching lines @@
 
   // Sets a task to execute when the next rebuild from history is complete.
   // This is used by unit tests to wait for the rebuild to complete before
   // they continue. The pointer will be owned by this object after the call.
   void set_rebuild_complete_task(const base::Closure& task) {
     DCHECK(rebuild_complete_task_.is_null());
     rebuild_complete_task_ = task;
   }
 
   // returns the number of items in the table for testing verification
-  int32 GetUsedCount() const {
-    return used_items_;
-  }
+  int32_t GetUsedCount() const { return used_items_; }
 
   // Returns the listener.
   VisitedLinkMaster::Listener* GetListener() const {
     return listener_.get();
   }
 
   // Call to cause the entire database file to be re-written from scratch
   // to disk. Used by the performance tester.
   void RewriteFile() {
     WriteFullTable();
@@ skipping 10 matching lines @@
   struct LoadFromFileResult;
 
   using TableLoadCompleteCallback = base::Callback<void(
       bool success,
       scoped_refptr<LoadFromFileResult> load_from_file_result)>;
 
   // Object to rebuild the table on the history thread (see the .cc file).
   class TableBuilder;
 
   // Byte offsets of values in the header.
-  static const int32 kFileHeaderSignatureOffset;
-  static const int32 kFileHeaderVersionOffset;
-  static const int32 kFileHeaderLengthOffset;
-  static const int32 kFileHeaderUsedOffset;
-  static const int32 kFileHeaderSaltOffset;
+  static const int32_t kFileHeaderSignatureOffset;
+  static const int32_t kFileHeaderVersionOffset;
+  static const int32_t kFileHeaderLengthOffset;
+  static const int32_t kFileHeaderUsedOffset;
+  static const int32_t kFileHeaderSaltOffset;
 
   // The signature at the beginning of a file.
-  static const int32 kFileSignature;
+  static const int32_t kFileSignature;
 
   // version of the file format this module currently uses
-  static const int32 kFileCurrentVersion;
+  static const int32_t kFileCurrentVersion;
 
   // Bytes in the file header, including the salt.
   static const size_t kFileHeaderSize;
 
   // When creating a fresh new table, we use this many entries.
   static const unsigned kDefaultTableSize;
 
   // When the user is deleting a boatload of URLs, we don't really want to do
   // individual writes for each of them. When the count exceeds this threshold,
   // we will write the whole table to disk at once instead of individual items.
@@ skipping 42 matching lines @@
       scoped_refptr<LoadFromFileResult> load_from_file_result);
 
   // Reads the header of the link coloring database from disk. Assumes the
   // file pointer is at the beginning of the file and that it is the first
   // asynchronous I/O operation on the background thread.
   //
   // Returns true on success and places the size of the table in num_entries
   // and the number of nonzero fingerprints in used_count. This will fail if
   // the version of the file is not the current version of the database.
   static bool ReadFileHeader(FILE* hfile,
-                             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]);
 
   // Fills *filename with the name of the link database filename
   bool GetDatabaseFileName(base::FilePath* filename);
 
   // Wrapper around Window's WriteFile using asynchronous I/O. This will proxy
   // the write to a background thread.
-  void WriteToFile(FILE** hfile, off_t offset, void* data, int32 data_size);
+  void WriteToFile(FILE** hfile, off_t offset, void* data, int32_t data_size);
 
   // Helper function to schedule and asynchronous write of the used count to
   // disk (this is a common operation).
   void WriteUsedItemCountToFile();
 
   // Helper function to schedule an asynchronous write of the given range of
   // hash functions to disk. The range is inclusive on both ends. The range can
   // wrap around at 0 and this function will handle it.
   void WriteHashRangeToFile(Hash first_hash, Hash last_hash);
 
@@ skipping 28 matching lines @@
 
   // Creates a new empty table, call if InitFromFile() fails. Normally, when
   // |suppress_rebuild| is false, the table will be rebuilt from history,
   // keeping us in sync. When |suppress_rebuild| is true, the new table will be
   // empty and we will not consult history. This is used when clearing the
   // database and for unit tests.
   bool InitFromScratch(bool suppress_rebuild);
 
   // Allocates the Fingerprint structure and length. Structure is filled with 0s
   // and shared header with salt and used_items_ is set to 0.
-  bool CreateURLTable(int32 num_entries);
+  bool CreateURLTable(int32_t num_entries);
 
   // Allocates the Fingerprint structure and length. Returns true on success.
   // Structure is filled with 0s and shared header with salt. The result of
   // allocation is saved into |shared_memory| and |hash_table| points to the
   // beginning of Fingerprint table in |shared_memory|.
-  static bool CreateApartURLTable(int32 num_entries,
-                                  const uint8 salt[LINK_SALT_LENGTH],
+  static bool CreateApartURLTable(int32_t num_entries,
+                                  const uint8_t salt[LINK_SALT_LENGTH],
                                   scoped_ptr<base::SharedMemory>* shared_memory,
                                   VisitedLinkCommon::Fingerprint** hash_table);
 
   // A wrapper for CreateURLTable, this will allocate a new table, initialized
   // to empty. The caller is responsible for saving the shared memory pointer
   // and handles before this call (they will be replaced with new ones) and
   // releasing them later. This is designed for callers that make a new table
   // and then copy values from the old table to the new one, then release the
   // old table.
   //
   // Returns true on success. On failure, the old table will be restored. The
   // caller should not attemp to release the pointer/handle in this case.
-  bool BeginReplaceURLTable(int32 num_entries);
+  bool BeginReplaceURLTable(int32_t num_entries);
 
   // unallocates the Fingerprint table
   void FreeURLTable();
 
   // For growing the table. ResizeTableIfNecessary will check to see if the
   // table should be resized and calls ResizeTable if needed. Returns true if
   // we decided to resize the table.
   bool ResizeTableIfNecessary();
 
   // Resizes the table (growing or shrinking) as necessary to accomodate the
   // current count.
-  void ResizeTable(int32 new_size);
+  void ResizeTable(int32_t new_size);
 
   // Returns the default table size. It can be overrided in unit tests.
-  uint32 DefaultTableSize() const;
+  uint32_t DefaultTableSize() const;
 
   // Returns the desired table size for |item_count| URLs.
-  uint32 NewTableSizeForCount(int32 item_count) const;
+  uint32_t NewTableSizeForCount(int32_t item_count) const;
 
   // Computes the table load as fraction. For example, if 1/4 of the entries are
   // full, this value will be 0.25
   float ComputeTableLoad() const {
     return static_cast<float>(used_items_) / static_cast<float>(table_length_);
   }
 
   // Initializes a rebuild of the visited link database based on the browser
   // history. This will set table_builder_ while working, and there should not
   // already be a rebuild in place when called. See the definition for more
@@ skipping 65 matching lines @@
 
   // If true, will try to persist the hash table to disk. Will rebuild from
   // VisitedLinkDelegate::RebuildTable if there are disk corruptions.
   bool persist_to_disk_;
 
   // Shared memory consists of a SharedHeader followed by the table.
   base::SharedMemory *shared_memory_;
 
   // When we generate new tables, we increment the serial number of the
   // shared memory object.
-  int32 shared_memory_serial_;
+  int32_t shared_memory_serial_;
 
   // Number of non-empty items in the table, used to compute fullness.
-  int32 used_items_;
+  int32_t used_items_;
 
   // We set this to true to avoid writing to the database file.
   bool table_is_loading_from_file_;
 
   // Testing values -----------------------------------------------------------
   //
   // The following fields exist for testing purposes. They are not used in
   // release builds. It'd be nice to eliminate them in release builds, but we
   // don't want to change the signature of the object between the unit test and
   // regular builds. Instead, we just have "default" values that these take
   // in release builds that give "regular" behavior.
 
   // Overridden database file name for testing
   base::FilePath database_name_override_;
 
   // When nonzero, overrides the table size for new databases for testing
-  int32 table_size_override_;
+  int32_t table_size_override_;
 
   // When set, indicates the task that should be run after the next rebuild from
   // history is complete.
   base::Closure rebuild_complete_task_;
 
   // Set to prevent us from attempting to rebuild the database from global
   // history if we have an error opening the file. This is used for testing,
   // will be false in production.
   bool suppress_rebuild_;
 
   base::WeakPtrFactory<VisitedLinkMaster> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VisitedLinkMaster);
 };
 
 // NOTE: These methods are defined inline here, so we can share the compilation
 //       of visitedlink_master.cc between the browser and the unit/perf tests.
 
 #if defined(UNIT_TEST) || defined(PERF_TEST) || !defined(NDEBUG)
 inline void VisitedLinkMaster::DebugValidate() {
-  int32 used_count = 0;
-  for (int32 i = 0; i < table_length_; i++) {
+  int32_t used_count = 0;
+  for (int32_t i = 0; i < table_length_; i++) {
     if (hash_table_[i])
       used_count++;
   }
   DCHECK_EQ(used_count, used_items_);
 }
 #endif
 
 }  // namespace visitedlink
 
 #endif  // COMPONENTS_VISITEDLINK_BROWSER_VISITEDLINK_MASTER_H_