Reverting 7083,7079....

chrome/browser/url_fixer_upper_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 <stdlib.h>
+#include <windows.h>
 
 #include "base/basictypes.h"
-#include "base/file_path.h"
-#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "chrome/browser/url_fixer_upper.h"
 #include "chrome/common/chrome_paths.h"
 #include "googleurl/src/url_parse.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 69 matching lines @@
     url_parse::Component(41, 6), // path
     url_parse::Component(48, 3), // query
     url_parse::Component(52, 3), // ref
   },
 };
 
 TEST(URLFixerUpperTest, SegmentURL) {
   std::wstring result;
   url_parse::Parsed parts;
 
-  for (size_t i = 0; i < arraysize(segment_cases); ++i) {
+  for (int i = 0; i < arraysize(segment_cases); ++i) {
     segment_case value = segment_cases[i];
     result = URLFixerUpper::SegmentURL(value.input, &parts);
     EXPECT_EQ(value.result, result);
     EXPECT_EQ(value.scheme, parts.scheme);
     EXPECT_EQ(value.username, parts.username);
     EXPECT_EQ(value.password, parts.password);
     EXPECT_EQ(value.host, parts.host);
     EXPECT_EQ(value.port, parts.port);
     EXPECT_EQ(value.path, parts.path);
     EXPECT_EQ(value.query, parts.query);
     EXPECT_EQ(value.ref, parts.ref);
   }
 }
 
 // Creates a file and returns its full name as well as the decomposed
 // version. Example:
 //    full_path = "c:\foo\bar.txt"
 //    dir = "c:\foo"
 //    file_name = "bar.txt"
 static bool MakeTempFile(const std::wstring& dir,
                          const std::wstring& file_name,
                          std::wstring* full_path) {
-  FilePath dir_path = FilePath::FromWStringHack(dir);
-  FilePath file_name_path = FilePath::FromWStringHack(file_name);
-  FilePath path = dir_path.Append(file_name_path.value());
-  if (!file_util::CreateTemporaryFileName(&path))
+  *full_path = dir + L"\\" + file_name;
+
+  HANDLE hfile = CreateFile(full_path->c_str(), GENERIC_READ | GENERIC_WRITE,
+                            0, NULL, CREATE_ALWAYS, 0, NULL);
+  if (hfile == NULL || hfile == INVALID_HANDLE_VALUE)
     return false;
-  *full_path = path.ToWStringHack();
+  CloseHandle(hfile);
   return true;
 }
 
 // Returns true if the given URL is a file: URL that matches the given file
 static bool IsMatchingFileURL(const std::wstring& url,
                               const std::wstring& full_file_path) {
   if (url.length() <= 8)
     return false;
   if (std::wstring(L"file:///") != url.substr(0, 8))
     return false; // no file:/// prefix
   if (url.find('\\') != std::wstring::npos)
     return false; // contains backslashes
 
   std::wstring derived_path;
-  net::FileURLToFilePath(GURL(WideToUTF8(url)), &derived_path);
+  net::FileURLToFilePath(GURL(url), &derived_path);
   return (derived_path.length() == full_file_path.length()) &&
       std::equal(derived_path.begin(), derived_path.end(),
                  full_file_path.begin(), CaseInsensitiveCompare<wchar_t>());
 }
 
 struct fixup_case {
   const std::wstring input;
   const std::wstring desired_tld;
   const std::wstring output;
 } fixup_cases[] = {
@@ skipping 18 matching lines @@
   {L"\x6C34.com", L"", L"http://\x6C34.com/" },
   // It would be better if this next case got treated as http, but I don't see
   // a clean way to guess this isn't the new-and-exciting "user" scheme.
   {L"user:passwd@www.google.com:8080/", L"", L"user:passwd@www.google.com:8080/"},
   //{L"file:///c:/foo/bar%20baz.txt", L"", L"file:///C:/foo/bar%20baz.txt"},
 };
 
 TEST(URLFixerUpperTest, FixupURL) {
   std::wstring output;
 
-  for (size_t i = 0; i < arraysize(fixup_cases); ++i) {
+  for (int i = 0; i < arraysize(fixup_cases); ++i) {
     fixup_case value = fixup_cases[i];
     output = URLFixerUpper::FixupURL(value.input, value.desired_tld);
     EXPECT_EQ(value.output, output);
   }
 
   // Check the TLD-appending functionality
   fixup_case tld_cases[] = {
     {L"google", L"com", L"http://www.google.com/"},
     {L"google.", L"com", L"http://www.google.com/"},
     {L"google..", L"com", L"http://www.google.com/"},
     {L".google", L"com", L"http://www.google.com/"},
     {L"www.google", L"com", L"http://www.google.com/"},
     {L"google.com", L"com", L"http://google.com/"},
     {L"http://google", L"com", L"http://www.google.com/"},
     {L"..google..", L"com", L"http://www.google.com/"},
     {L"http://www.google", L"com", L"http://www.google.com/"},
     {L"google/foo", L"com", L"http://www.google.com/foo"},
     {L"google.com/foo", L"com", L"http://google.com/foo"},
     {L"google/?foo=.com", L"com", L"http://www.google.com/?foo=.com"},
     {L"www.google/?foo=www.", L"com", L"http://www.google.com/?foo=www."},
     {L"google.com/?foo=.com", L"com", L"http://google.com/?foo=.com"},
     {L"http://www.google.com", L"com", L"http://www.google.com/"},
     {L"google:123", L"com", L"http://www.google.com:123/"},
     {L"http://google:123", L"com", L"http://www.google.com:123/"},
   };
-  for (size_t i = 0; i < arraysize(tld_cases); ++i) {
+  for (int i = 0; i < arraysize(tld_cases); ++i) {
     fixup_case value = tld_cases[i];
     output = URLFixerUpper::FixupURL(value.input, value.desired_tld);
     EXPECT_EQ(value.output, output);
   }
 }
 
 // Test different types of file inputs to URIFixerUpper::FixupURL. This
 // doesn't go into the nice array of fixups above since the file input
 // has to exist.
 TEST(URLFixerUpperTest, FixupFile) {
@@ skipping 35 matching lines @@
     //   {L"file://C:/foo/bar", L"", L"file:///C:/foo/bar"},
     //   {L"file:c:", L"", L"file:///c:/"},
     //   {L"file:c:WINDOWS", L"", L"file:///c:/WINDOWS"},
     //   {L"file:c|Program Files", L"", L"file:///c:/Program Files"},
     //   {L"file:///foo:/bar", L"", L"file://foo/bar"},
     //   {L"file:/file", L"", L"file://file/"},
     //   {L"file:////////c:\\foo", L"", L"file:///c:/foo"},
     //   {L"file://server/folder/file", L"", L"file://server/folder/file"},
     //   {L"file:/\\/server\\folder/file", L"", L"file://server/folder/file"},
   };
-  for (size_t i = 0; i < arraysize(file_cases); i++) {
+  for (int i = 0; i < arraysize(file_cases); i++) {
     fixedup = URLFixerUpper::FixupURL(file_cases[i].input,
                                       file_cases[i].desired_tld);
     EXPECT_EQ(file_cases[i].output, fixedup);
   }
 
-  EXPECT_TRUE(file_util::Delete(original, false));
+  EXPECT_TRUE(DeleteFile(original.c_str()));
 }
 
 TEST(URLFixerUpperTest, FixupRelativeFile) {
   std::wstring full_path, dir;
   std::wstring file_part(L"url_fixer_upper_existing_file.txt");
   ASSERT_TRUE(PathService::Get(chrome::DIR_APP, &dir));
   ASSERT_TRUE(MakeTempFile(dir, file_part, &full_path));
 
   // make sure we pass through good URLs
   std::wstring fixedup;
-  for (size_t i = 0; i < arraysize(fixup_cases); ++i) {
+    for (int i = 0; i < arraysize(fixup_cases); ++i) {
     fixup_case value = fixup_cases[i];
     fixedup = URLFixerUpper::FixupRelativeFile(dir, value.input);
     EXPECT_EQ(value.output, fixedup);
   }
 
   // make sure the existing file got fixed-up to a file URL, and that there
   // are no backslashes
   fixedup = URLFixerUpper::FixupRelativeFile(dir, file_part);
   EXPECT_PRED2(IsMatchingFileURL, fixedup, full_path);
-  EXPECT_TRUE(file_util::Delete(full_path, false));
+  EXPECT_TRUE(DeleteFile(full_path.c_str()));
 
   // create a filename we know doesn't exist and make sure it doesn't get
   // fixed up to a file URL
   std::wstring nonexistent_file(L"url_fixer_upper_nonexistent_file.txt");
   fixedup = URLFixerUpper::FixupRelativeFile(dir, nonexistent_file);
   EXPECT_NE(std::wstring(L"file:///"), fixedup.substr(0, 8));
   EXPECT_FALSE(IsMatchingFileURL(fixedup, nonexistent_file));
 
   // make a subdir to make sure relative paths with directories work, also
   // test spaces: "app_dir\url fixer-upper dir\url fixer-upper existing file.txt"
   std::wstring sub_dir(L"url fixer-upper dir");
   std::wstring sub_file(L"url fixer-upper existing file.txt");
   std::wstring new_dir = dir + L"\\" + sub_dir;
-  ASSERT_TRUE(file_util::CreateDirectory(new_dir));
+  CreateDirectory(new_dir.c_str(), NULL);
   ASSERT_TRUE(MakeTempFile(new_dir, sub_file, &full_path));
 
   // test file in the subdir
   std::wstring relative_file = sub_dir + L"\\" + sub_file;
   fixedup = URLFixerUpper::FixupRelativeFile(dir, relative_file);
   EXPECT_PRED2(IsMatchingFileURL, fixedup, full_path);
 
   // test file in the subdir with different slashes and escaping
   relative_file = sub_dir + L"/" + sub_file;
   ReplaceSubstringsAfterOffset(&relative_file, 0, L" ", L"%20");
   fixedup = URLFixerUpper::FixupRelativeFile(dir, relative_file);
   EXPECT_PRED2(IsMatchingFileURL, fixedup, full_path);
 
   // test relative directories and duplicate slashes
   // (should resolve to the same file as above)
   relative_file = sub_dir + L"\\../" + sub_dir  + L"\\\\\\.\\" + sub_file;
   fixedup = URLFixerUpper::FixupRelativeFile(dir, relative_file);
   EXPECT_PRED2(IsMatchingFileURL, fixedup, full_path);
 
   // done with the subdir
-  EXPECT_TRUE(file_util::Delete(new_dir, true));
+  EXPECT_TRUE(DeleteFile(full_path.c_str()));
+  EXPECT_TRUE(RemoveDirectory(new_dir.c_str()));
 }