Deprecate wstring version of PathService::Get() in webkit.

webkit/tools/test_shell/test_shell_main.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.
 
 #include <iostream>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/event_recorder.h"
+#include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/icu_util.h"
 #include "base/memory_debug.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/stats_table.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
@@ skipping 94 matching lines @@
 
   if (playback_mode)
     cache_mode = net::HttpCache::PLAYBACK;
   else if (record_mode)
     cache_mode = net::HttpCache::RECORD;
 
   if (layout_test_mode ||
       parsed_command_line.HasSwitch(test_shell::kEnableFileCookies))
     net::CookieMonster::EnableFileScheme();
 
-  std::wstring cache_path =
-      parsed_command_line.GetSwitchValue(test_shell::kCacheDir);
+  FilePath cache_path = FilePath::FromWStringHack(
+      parsed_command_line.GetSwitchValue(test_shell::kCacheDir));
   // If the cache_path is empty and it's layout_test_mode, leave it empty
   // so we use an in-memory cache. This makes running multiple test_shells
   // in parallel less flaky.
   if (cache_path.empty() && !layout_test_mode) {
     PathService::Get(base::DIR_EXE, &cache_path);
-    file_util::AppendToPath(&cache_path, L"cache");
+    cache_path = cache_path.AppendASCII("cache");
   }
 
   // Initializing with a default context, which means no on-disk cookie DB,
   // and no support for directory listings.
   SimpleResourceLoaderBridge::Init(
-      new TestShellRequestContext(cache_path, cache_mode, layout_test_mode));
+      new TestShellRequestContext(cache_path.ToWStringHack(),
+                                  cache_mode, layout_test_mode));
 
   // Load ICU data tables
   icu_util::Initialize();
 
   // Config the network module so it has access to a limited set of resources.
   net::NetModule::SetResourceProvider(TestShell::NetResourceProvider);
 
   // On Linux, load the test root certificate.
   net::TestServerLauncher ssl_util;
   ssl_util.LoadTestRootCert();
@@ skipping 13 matching lines @@
   if (parsed_command_line.HasSwitch(test_shell::kTestShellTimeOut)) {
     const std::wstring timeout_str = parsed_command_line.GetSwitchValue(
         test_shell::kTestShellTimeOut);
     int timeout_ms =
         static_cast<int>(StringToInt64(WideToUTF16Hack(timeout_str.c_str())));
     if (timeout_ms > 0)
       TestShell::SetFileTestTimeout(timeout_ms);
   }
 
   // Treat the first loose value as the initial URL to open.
-  std::wstring uri;
+  FilePath uri;
 
   // Default to a homepage if we're interactive.
   if (!layout_test_mode) {
     PathService::Get(base::DIR_SOURCE_ROOT, &uri);
-    file_util::AppendToPath(&uri, L"webkit");
-    file_util::AppendToPath(&uri, L"data");
-    file_util::AppendToPath(&uri, L"test_shell");
-    file_util::AppendToPath(&uri, L"index.html");
+    uri = uri.AppendASCII("webkit");
+    uri = uri.AppendASCII("data");
+    uri = uri.AppendASCII("test_shell");
+    uri = uri.AppendASCII("index.html");
   }
 
   std::vector<std::wstring> loose_values = parsed_command_line.GetLooseValues();
   if (loose_values.size() > 0)
-    uri = loose_values[0];
+    uri = FilePath::FromWStringHack(loose_values[0]);
 
   std::wstring js_flags =
     parsed_command_line.GetSwitchValue(test_shell::kJavaScriptFlags);
   // Test shell always exposes the GC.
   js_flags += L" --expose-gc";
   webkit_glue::SetJavaScriptFlags(js_flags);
   // Expose GCController to JavaScript.
   WebKit::registerExtension(extensions_v8::GCExtension::Get());
 
   if (parsed_command_line.HasSwitch(test_shell::kProfiler)) {
     WebKit::registerExtension(extensions_v8::ProfilerExtension::Get());
   }
 
   // Load and initialize the stats table.  Attempt to construct a somewhat
   // unique name to isolate separate instances from each other.
   StatsTable *table = new StatsTable(
       // truncate the random # to 32 bits for the benefit of Mac OS X, to
       // avoid tripping over its maximum shared memory segment name length
       kStatsFilePrefix + Uint64ToString(base::RandUint64() & 0xFFFFFFFFL),
       kStatsFileThreads,
       kStatsFileCounters);
   StatsTable::set_current(table);
 
   TestShell* shell;
-  if (TestShell::CreateNewWindow(uri, &shell)) {
+  if (TestShell::CreateNewWindow(uri.ToWStringHack(), &shell)) {
     if (record_mode || playback_mode) {
       platform.SetWindowPositionForRecording(shell);
       WebKit::registerExtension(extensions_v8::PlaybackExtension::Get());
     }
 
     shell->Show(shell->webView(), NEW_WINDOW);
 
     if (parsed_command_line.HasSwitch(test_shell::kDumpStatsTable))
       shell->DumpStatsTableOnExit();
 
     bool no_events = parsed_command_line.HasSwitch(test_shell::kNoEvents);
     if ((record_mode || playback_mode) && !no_events) {
-      std::wstring script_path = cache_path;
+      FilePath script_path = cache_path;
       // Create the cache directory in case it doesn't exist.
       file_util::CreateDirectory(cache_path);
-      file_util::AppendToPath(&script_path, L"script.log");
+      script_path = script_path.AppendASCII("script.log");
       if (record_mode)
         base::EventRecorder::current()->StartRecording(script_path);
       if (playback_mode)
         base::EventRecorder::current()->StartPlayback(script_path);
     }
 
     if (parsed_command_line.HasSwitch(test_shell::kDebugMemoryInUse)) {
       base::MemoryDebug::SetMemoryInUseEnabled(true);
       // Dump all in use memory at startup
       base::MemoryDebug::DumpAllMemoryInUse();
@@ skipping 15 matching lines @@
             test_shell::kDumpPixels);
         if (params.pixel_file_name.size() == 0) {
           fprintf(stderr, "No file specified for pixel tests");
           exit(1);
         }
       }
       if (parsed_command_line.HasSwitch(test_shell::kNoTree)) {
           params.dump_tree = false;
       }
 
-      if (uri.length() == 0) {
+      if (uri.empty()) {
         // Watch stdin for URLs.
         char filenameBuffer[kPathBufSize];
         while (fgets(filenameBuffer, sizeof(filenameBuffer), stdin)) {
           // When running layout tests we pass new line separated
           // tests to TestShell. Each line is a space separated list
           // of filename, timeout and expected pixel hash. The timeout
           // and the pixel hash are optional.
           char* newLine = strchr(filenameBuffer, '\n');
           if (newLine)
             *newLine = '\0';
@@ skipping 13 matching lines @@
           }
 
           if (!TestShell::RunFileTest(params))
             break;
 
           TestShell::SetFileTestTimeout(old_timeout_ms);
         }
       } else {
         // TODO(ojan): Provide a way for run-singly tests to pass
         // in a hash and then set params.pixel_hash here.
-        params.test_url = WideToUTF8(uri).c_str();
+        params.test_url = WideToUTF8(uri.ToWStringHack()).c_str();
         TestShell::RunFileTest(params);
       }
 
       shell->CallJSGC();
       shell->CallJSGC();
       if (shell) {
         // When we finish the last test, cleanup the LayoutTestController.
         // It may have references to not-yet-cleaned up windows.  By
         // cleaning up here we help purify reports.
         shell->ResetTestController();
@@ skipping 16 matching lines @@
 
   TestShell::ShutdownTestShell();
   TestShell::CleanupLogging();
 
   // Tear down shared StatsTable; prevents unit_tests from leaking it.
   StatsTable::set_current(NULL);
   delete table;
 
   return 0;
 }