Safe browsing cleanup:...

chrome/browser/safe_browsing/safe_browsing_database.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_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_
 #define CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_
 
 #include <deque>
 #include <list>
 #include <string>
 #include <vector>
 
+#include "base/file_path.h"
 #include "base/hash_tables.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "chrome/browser/safe_browsing/bloom_filter.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
 class GURL;
 
 // Encapsulates the database that stores information about phishing and malware
 // sites.  There is one on-disk database for all profiles, as it doesn't
 // contain user-specific data.  This object is not thread-safe, i.e. all its
 // methods should be used on the same thread that it was created on, with the
 // exception of NeedToCheckUrl.
 class SafeBrowsingDatabase {
  public:
   // Factory method for obtaining a SafeBrowsingDatabase implementation.
   static SafeBrowsingDatabase* Create();
 
   virtual ~SafeBrowsingDatabase() {}
 
   // Initializes the database with the given filename.  The callback is
   // executed after finishing a chunk.
-  virtual bool Init(const std::wstring& filename,
+  virtual bool Init(const FilePath& filename,
                     Callback0::Type* chunk_inserted_callback) = 0;
 
   // Deletes the current database and creates a new one.
   virtual bool ResetDatabase() = 0;
 
   // This function can be called on any thread to check if the given url may be
   // in the database.  If this function returns false, it is definitely not in
   // the database and ContainsUrl doesn't need to be called.  If it returns
   // true, then the url might be in the database and ContainsUrl needs to be
   // called.  This function can only be called after Init succeeded.
@@ skipping 30 matching lines @@
   virtual void CacheHashResults(
       const std::vector<SBPrefix>& prefixes,
       const std::vector<SBFullHashResult>& full_hits) = 0;
 
   // Called when the user's machine has resumed from a lower power state.
   virtual void HandleResume() = 0;
 
   virtual bool UpdateStarted() { return true; }
   virtual void UpdateFinished(bool update_succeeded) {}
 
-  virtual std::wstring filename() const { return filename_; }
+  virtual FilePath filename() const { return filename_; }
 
  protected:
   friend class SafeBrowsingDatabaseTest;
   FRIEND_TEST(SafeBrowsingDatabase, HashCaching);
 
-  static std::wstring BloomFilterFilename(const std::wstring& db_filename);
+  static FilePath BloomFilterFilename(const FilePath& db_filename);
 
   // Load the bloom filter off disk, or generates one if it doesn't exist.
   virtual void LoadBloomFilter();
 
   // Deletes the on-disk bloom filter, i.e. because it's stale.
   virtual void DeleteBloomFilter();
 
   // Writes the current bloom filter to disk.
   virtual void WriteBloomFilter();
 
@@ skipping 15 matching lines @@
   typedef base::hash_map<SBPrefix, HashList> HashCache;
 
   scoped_ptr<HashCache> hash_cache_;
   HashCache* hash_cache() { return hash_cache_.get(); }
 
   // Cache of prefixes that returned empty results (no full hash match).
   typedef std::set<SBPrefix> PrefixCache;
   PrefixCache prefix_miss_cache_;
   PrefixCache* prefix_miss_cache() { return &prefix_miss_cache_; }
 
-  std::wstring filename_;
-  std::wstring bloom_filter_filename_;
+  FilePath filename_;
+  FilePath bloom_filter_filename_;
   scoped_refptr<BloomFilter> bloom_filter_;
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_