Monster FilePath patch!

net/url_request/url_request_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.
 
 #include "net/url_request/url_request_unittest.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #elif defined(OS_LINUX)
 #include "base/nss_init.h"
 #endif
 
 #include <algorithm>
 #include <string>
 
+#include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_module.h"
 #include "net/base/net_util.h"
@@ skipping 490 matching lines @@
   ASSERT_TRUE(NULL != server.get());
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage("echo"), &d);
     r.set_method("POST");
 
     std::wstring dir;
     PathService::Get(base::DIR_EXE, &dir);
     file_util::SetCurrentDirectory(dir);
 
-    std::wstring path;
+    FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
-    file_util::AppendToPath(&path, L"net");
-    file_util::AppendToPath(&path, L"data");
-    file_util::AppendToPath(&path, L"url_request_unittest");
-    file_util::AppendToPath(&path, L"with-headers.html");
+    path = path.Append(FILE_PATH_LITERAL("net"));
+    path = path.Append(FILE_PATH_LITERAL("data"));
+    path = path.Append(FILE_PATH_LITERAL("url_request_unittest"));
+    path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
     r.AppendFileToUpload(path);
 
     // This file should just be ignored in the upload stream.
-    r.AppendFileToUpload(L"c:\\path\\to\\non\\existant\\file.randomness.12345");
+    r.AppendFileToUpload(FilePath(FILE_PATH_LITERAL(
+        "c:\\path\\to\\non\\existant\\file.randomness.12345")));
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     int64 longsize;
     ASSERT_EQ(true, file_util::GetFileSize(path, &longsize));
     int size = static_cast<int>(longsize);
     scoped_array<char> buf(new char[size]);
@@ skipping 30 matching lines @@
     EXPECT_EQ(d.bytes_received(), 0);
   }
 #ifndef NDEBUG
   DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, FileTest) {
   FilePath app_path;
   PathService::Get(base::FILE_EXE, &app_path);
-  GURL app_url = net::FilePathToFileURL(app_path.ToWStringHack());
+  GURL app_url = net::FilePathToFileURL(app_path);
 
   TestDelegate d;
   {
     TestURLRequest r(app_url, &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
@@ skipping 153 matching lines @@
   EXPECT_TRUE(SUCCEEDED(result));
   result = persist->Save(lnk_path.c_str(), TRUE);
   EXPECT_TRUE(SUCCEEDED(result));
   if (persist)
     persist->Release();
   if (shell)
     shell->Release();
 
   TestDelegate d;
   {
-    TestURLRequest r(net::FilePathToFileURL(lnk_path), &d);
+    TestURLRequest r(net::FilePathToFileURL(FilePath(lnk_path)), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     WIN32_FILE_ATTRIBUTE_DATA data;
     GetFileAttributesEx(app_path.c_str(), GetFileExInfoStandard, &data);
     HANDLE file = CreateFile(app_path.c_str(), GENERIC_READ,
                              FILE_SHARE_READ, NULL, OPEN_EXISTING,
@@ skipping 42 matching lines @@
   EXPECT_EQ("utf-8", charset);
   req.Cancel();
 }
 
 TEST_F(URLRequestTest, FileDirCancelTest) {
   // Put in mock resource provider.
   net::NetModule::SetResourceProvider(TestNetResourceProvider);
 
   TestDelegate d;
   {
-    std::wstring file_path;
+    FilePath file_path;
     PathService::Get(base::DIR_SOURCE_ROOT, &file_path);
-    file_util::AppendToPath(&file_path, L"net");
-    file_util::AppendToPath(&file_path, L"data");
-    file_util::AppendToPath(&file_path, L"");
+    file_path = file_path.Append(FILE_PATH_LITERAL("net"));
+    file_path = file_path.Append(FILE_PATH_LITERAL("data"));
 
     TestURLRequest req(net::FilePathToFileURL(file_path), &d);
     req.Start();
     EXPECT_TRUE(req.is_pending());
 
     d.set_cancel_in_received_data_pending(true);
 
     MessageLoop::current()->Run();
   }
 #ifndef NDEBUG
@@ skipping 373 matching lines @@
 
     int64 file_size = 0;
     file_util::GetFileSize(app_path, &file_size);
 
     EXPECT_TRUE(!r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), 0);
   }
 }