Fix to use FilePath version of PathService::Get....

chrome/browser/safe_browsing/safe_browsing_database_unittest.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.
 //
 // Unit tests for the SafeBrowsing storage system.
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
@@ skipping 1020 matching lines @@
                                      Time::Now()));
 
   TearDownTestDatabase(database);
 }
 
 void PrintStat(const char* name) {
   int value = StatsTable::current()->GetCounterValue(name);
   LOG(INFO) << StringPrintf("%s %d", name, value);
 }
 
-std::wstring GetFullSBDataPath(const std::wstring& path) {
+FilePath GetFullSBDataPath(const std::wstring& path) {
   FilePath full_path;
   CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &full_path));
   full_path = full_path.AppendASCII("chrome");
   full_path = full_path.AppendASCII("test");
   full_path = full_path.AppendASCII("data");
   full_path = full_path.AppendASCII("safe_browsing");
   full_path = full_path.Append(FilePath::FromWStringHack(path));
   CHECK(file_util::PathExists(full_path));
-  return full_path.ToWStringHack();
+  return full_path;
 }
 
 struct ChunksInfo {
   std::deque<SBChunk>* chunks;
   std::string listname;
 };
 
 void PeformUpdate(const std::wstring& initial_db,
                   const std::vector<ChunksInfo>& chunks,
                   std::vector<SBChunkDelete>* deletes) {
 // TODO(pinkerton): I don't think posix has any concept of IO counters, but
 // we can uncomment this when we implement ProcessMetrics::GetIOCounters
   IoCounters before, after;
 
   FilePath path;
   PathService::Get(base::DIR_TEMP, &path);
   path = path.AppendASCII("SafeBrowsingTestDatabase");
 
   // In case it existed from a previous run.
   file_util::Delete(path, false);
 
   if (!initial_db.empty()) {
-    std::wstring full_initial_db = GetFullSBDataPath(initial_db);
-    ASSERT_TRUE(file_util::CopyFile(
-        FilePath::FromWStringHack(full_initial_db), path));
+    FilePath full_initial_db = GetFullSBDataPath(initial_db);
+    ASSERT_TRUE(file_util::CopyFile(full_initial_db, path));
   }
 
   SafeBrowsingDatabase* database = SafeBrowsingDatabase::Create();
   database->SetSynchronous();
   EXPECT_TRUE(database->Init(path, NULL));
 
   Time before_time = Time::Now();
   base::ProcessHandle handle = base::Process::Current().handle();
   scoped_ptr<base::ProcessMetrics> metric(
       base::ProcessMetrics::CreateProcessMetrics(handle));
@@ skipping 36 matching lines @@
 }
 
 void UpdateDatabase(const std::wstring& initial_db,
                     const std::wstring& response_path,
                     const std::wstring& updates_path) {
   // First we read the chunks from disk, so that this isn't counted in IO bytes.
   std::vector<ChunksInfo> chunks;
 
   SafeBrowsingProtocolParser parser;
   if (!updates_path.empty()) {
-    std::wstring data_dir = GetFullSBDataPath(updates_path);
-    file_util::FileEnumerator file_enum(
-        FilePath::FromWStringHack(data_dir), false,
+    FilePath data_dir = GetFullSBDataPath(updates_path);
+    file_util::FileEnumerator file_enum(data_dir, false,
         file_util::FileEnumerator::FILES);
     while (true) {
       std::wstring file = file_enum.Next().ToWStringHack();
       if (file.empty())
         break;
 
       int64 size64;
       bool result = file_util::GetFileSize(file, &size64);
       CHECK(result);
 
@@ skipping 14 matching lines @@
       info.listname.resize(index);
       info.listname.erase(0, 3);  // Get rid of the 000 etc.
 
       chunks.push_back(info);
     }
   }
 
   std::vector<SBChunkDelete>* deletes = new std::vector<SBChunkDelete>;
   if (!response_path.empty()) {
     std::string update;
-    std::wstring full_response_path = GetFullSBDataPath(response_path);
+    FilePath full_response_path = GetFullSBDataPath(response_path);
     if (file_util::ReadFileToString(full_response_path, &update)) {
       int next_update;
       bool result, rekey, reset;
       std::vector<ChunkUrl> urls;
       result = parser.ParseUpdate(update.c_str(),
                                   static_cast<int>(update.length()),
                                   "",
                                   &next_update,
                                   &rekey,
                                   &reset,
@@ skipping 71 matching lines @@
 TEST(SafeBrowsingDatabase, DISABLED_DatabaseOldLotsofDeletesIO) {
   std::vector<ChunksInfo> chunks;
   std::vector<SBChunkDelete>* deletes = new std::vector<SBChunkDelete>;
   SBChunkDelete del;
   del.is_sub_del = false;
   del.list_name = safe_browsing_util::kMalwareList;
   del.chunk_del.push_back(ChunkRange(3539, 3579));
   deletes->push_back(del);
   PeformUpdate(GetOldSafeBrowsingPath(), chunks, deletes);
 }