Roll forward 8722,8721

chrome/browser/visitedlink_master.h

 // 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.
 
 #ifndef CHROME_BROWSER_VISITEDLINK_MASTER_H__
 #define CHROME_BROWSER_VISITEDLINK_MASTER_H__
 
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/file_path.h"
 #include "base/ref_counted.h"
 #include "base/shared_memory.h"
+#if defined(OS_WIN)
 #include "chrome/browser/history/history.h"
+#else
+// TODO(port): remove scaffolding, use history.h for both POSIX and WIN.
+#include "chrome/common/temp_scaffolding_stubs.h"
+#endif  // !defined(OS_WIN)
 #include "chrome/common/visitedlink_common.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
 class GURL;
 class Profile;
 
 // Controls the link coloring database. The master controls all writing to the
 // database as well as disk I/O. There should be only one master.
 //
 // This class will optionally defer writing operations to another thread. This
@@ skipping 21 matching lines @@
   // the main version, which will probably fail (which can be good for testing
   // 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(base::Thread* file_thread,
                     PostNewTableEvent* poster,
                     HistoryService* history_service,
                     bool suppress_rebuild,
-                    const std::wstring& filename,
+                    const FilePath& filename,
                     int32 default_table_size);
   virtual ~VisitedLinkMaster();
 
   // 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();
 
   // Duplicates the handle to the shared memory to another process.
   // Returns true on success.
@@ skipping 67 matching lines @@
 
   // 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.
-  static const int32 kBigDeleteThreshold;
+  static const size_t kBigDeleteThreshold;
 
   // Backend for the constructors initializing the members.
   void InitMembers(base::Thread* file_thread,
                    PostNewTableEvent* poster,
                    Profile* profile);
 
   // If a rebuild is in progress, we save the URL in the temporary list.
   // Otherwise, we add this to the table. Returns the index of the
   // inserted fingerprint or null_hash_ on failure.
   Hash TryToAddURL(const GURL& url);
 
   // File I/O functions
   // ------------------
 
   // Writes the entire table to disk, returning true on success. It will leave
   // the table file open and the handle to it in file_
   bool WriteFullTable();
 
   // Try to load the table from the database file. If the file doesn't exist or
   // is corrupt, this will return failure.
   bool InitFromFile();
 
   // Reads the header of the link coloring database from disk. Assumes the
   // file pointer is at the beginning of the file and that there are no pending
   // asynchronous I/O operations.
   //
   // 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.
-  bool ReadFileHeader(HANDLE hfile, int32* num_entries, int32* used_count,
+  bool ReadFileHeader(FILE* hfile, int32* num_entries, int32* used_count,
                       uint8 salt[LINK_SALT_LENGTH]);
 
   // Fills *filename with the name of the link database filename
-  bool GetDatabaseFileName(std::wstring* filename);
+  bool GetDatabaseFileName(FilePath* filename);
 
   // Wrapper around Window's WriteFile using asynchronous I/O. This will proxy
   // the write to a background thread.
-  void WriteToFile(HANDLE hfile, int32 offset, void* data, int32 data_size);
+  void WriteToFile(FILE* hfile, off_t offset, void* data, int32 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);
 
   // Synchronous read from the file. Assumes there are no pending asynchronous
   // I/O functions. Returns true if the entire buffer was successfully filled.
-  bool ReadFromFile(HANDLE hfile, int32 offset, void* data, int32 data_size);
+  bool ReadFromFile(FILE* hfile, off_t offset, void* data, size_t data_size);
 
   // General table handling
   // ----------------------
 
   // Called to add a fingerprint to the table. Returns the index of the
   // inserted fingerprint or null_hash_ if there was a duplicate and this item
   // was skippped.
   Hash AddFingerprint(Fingerprint fingerprint);
 
   // Deletes all fingerprints from the given vector from the current hash table
@@ skipping 113 matching lines @@
   std::set<Fingerprint> deleted_since_rebuild_;
 
   // TODO(brettw) Support deletion, we need to track whether anything was
   // deleted during the rebuild here. Then we should delete any of these
   // entries from the complete table later.
   //std::vector<Fingerprint> removed_since_rebuild_;
 
   // The currently open file with the table in it. This may be NULL if we're
   // rebuilding and haven't written a new version yet. Writing to the file may
   // be safely ignored in this case.
-  HANDLE file_;
+  FILE* file_;
 
   // 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_;
 
   // Number of non-empty items in the table, used to compute fullness.
   int32 used_items_;
 
   // 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
-  std::wstring database_name_override_;
+  FilePath database_name_override_;
 
   // When nonzero, overrides the table size for new databases for testing
   int32 table_size_override_;
 
   // When non-NULL, overrides the history service to use rather than as the
   // BrowserProcess. This is provided for unit tests.
   HistoryService* history_service_override_;
 
   // When non-NULL, indicates the task that should be run after the next
   // rebuild from history is complete.
@@ skipping 16 matching lines @@
   for (int32 i = 0; i < table_length_; i++) {
     if (hash_table_[i])
       used_count++;
   }
   DCHECK(used_count == used_items_);
 }
 #endif
 
 #endif // CHROME_BROWSER_VISITEDLINK_MASTER_H__