Reverting 7083,7079....

chrome/browser/url_fixer_upper.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 <algorithm>
+#include <windows.h>
 
 #include "chrome/browser/url_fixer_upper.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "chrome/common/gfx/text_elider.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
 #include "googleurl/src/url_file.h"
 #include "googleurl/src/url_parse.h"
 #include "googleurl/src/url_util.h"
 #include "net/base/escape.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domain.h"
 
 using namespace std;
 
 // does some basic fixes for input that we want to test for file-ness
 static void PrepareStringForFileOps(const wstring& text, wstring* output) {
   TrimWhitespace(text, TRIM_ALL, output);
   replace(output->begin(), output->end(), '/', '\\');
 }
 
 // Tries to create a full path from |text|.  If the result is valid and the
 // file exists, returns true and sets |full_path| to the result.  Otherwise,
 // returns false and leaves |full_path| unchanged.
 static bool ValidPathForFile(const wstring& text, wstring* full_path) {
-  wstring file_path(text);
-  if (!file_util::AbsolutePath(&file_path))
+  wchar_t file_path[MAX_PATH];
+  if (!_wfullpath(file_path, text.c_str(), MAX_PATH))
     return false;
 
   if (!file_util::PathExists(file_path))
     return false;
 
   full_path->assign(file_path);
   return true;
 }
 
 // Tries to create a file: URL from |text| if it looks like a filename, even if
@@ skipping 201 matching lines @@
   }
 
   return true;
 }
 
 wstring URLFixerUpper::SegmentURL(const wstring& text,
                                   url_parse::Parsed* parts) {
   // Initialize the result.
   *parts = url_parse::Parsed();
 
-#if defined(OS_WIN)
   wstring trimmed;
   TrimWhitespace(text, TRIM_ALL, &trimmed);
   if (trimmed.empty())
     return wstring(); // Nothing to segment.
 
   int trimmed_length = static_cast<int>(trimmed.length());
   if (url_parse::DoesBeginWindowsDriveSpec(trimmed.data(), 0, trimmed_length)
       || url_parse::DoesBeginUNCPath(trimmed.data(), 0, trimmed_length, false))
     return L"file";
-#endif
 
   // Otherwise, we need to look at things carefully.
   wstring scheme;
-  string text_utf8 = WideToUTF8(text);
-  if (url_parse::ExtractScheme(text_utf8.c_str(),
-                               static_cast<int>(text_utf8.length()),
+  if (url_parse::ExtractScheme(text.data(),
+                               static_cast<int>(text.length()),
                                &parts->scheme)) {
     // We were able to extract a scheme.  Remember what we have, but we may
     // decide to change our minds later.
     scheme.assign(text.substr(parts->scheme.begin, parts->scheme.len));
 
     if (parts->scheme.is_valid() &&
         // Valid schemes are ASCII-only.
         (!IsStringASCII(scheme) ||
         // We need to fix up the segmentation for "www.example.com:/".  For this
         // case, we guess that schemes with a "." are not actually schemes.
@@ skipping 13 matching lines @@
   } else {
     // Having been unable to extract a scheme, we default to HTTP.
     scheme.assign(L"http");
     scheme_end = 0;
   }
 
   // Cannonicalize the scheme.
   StringToLowerASCII(&scheme);
 
   // Not segmenting file schemes or nonstandard schemes.
-  string scheme_utf8 = WideToUTF8(scheme);
   if ((scheme == L"file") ||
-      !url_util::IsStandard(scheme_utf8.c_str(),
-          static_cast<int>(scheme_utf8.length()),
-          url_parse::Component(0, static_cast<int>(scheme_utf8.length()))))
+      !url_util::IsStandard(scheme.c_str(), static_cast<int>(scheme.length()),
+          url_parse::Component(0, static_cast<int>(scheme.length()))))
     return scheme;
 
   if (parts->scheme.is_valid()) {
     // Have the GURL parser do the heavy lifting for us.
-    string text_utf8 = WideToUTF8(text);
-    url_parse::ParseStandardURL(text_utf8.c_str(),
-                                static_cast<int>(text_utf8.length()),
+    url_parse::ParseStandardURL(text.data(), static_cast<int>(text.length()),
                                 parts);
     return scheme;
   }
 
   // We need to add a scheme in order for ParseStandardURL to be happy.
   // Find the first non-whitespace character.
   wstring::const_iterator first_nonwhite = text.begin();
   while ((first_nonwhite != text.end()) && IsWhitespace(*first_nonwhite))
     ++first_nonwhite;
 
   // Construct the text to parse by inserting the scheme.
   wstring inserted_text(scheme);
   inserted_text.append(L"://");
   wstring text_to_parse(text.begin(), first_nonwhite);
   text_to_parse.append(inserted_text);
   text_to_parse.append(first_nonwhite, text.end());
 
   // Have the GURL parser do the heavy lifting for us.
-  string text_to_parse_utf8 = WideToUTF8(text_to_parse);
-  url_parse::ParseStandardURL(text_to_parse_utf8.c_str(),
-                              static_cast<int>(text_to_parse_utf8.length()),
+  url_parse::ParseStandardURL(text_to_parse.data(),
+                              static_cast<int>(text_to_parse.length()),
                               parts);
 
   // Offset the results of the parse to match the original text.
   const int offset = -static_cast<int>(inserted_text.length());
   OffsetComponent(offset, &parts->scheme);
   OffsetComponent(offset, &parts->username);
   OffsetComponent(offset, &parts->password);
   OffsetComponent(offset, &parts->host);
   OffsetComponent(offset, &parts->port);
   OffsetComponent(offset, &parts->path);
@@ skipping 12 matching lines @@
 
   // Segment the URL.
   url_parse::Parsed parts;
   wstring scheme(SegmentURL(trimmed, &parts));
 
   // We handle the file scheme separately.
   if (scheme == L"file")
     return (parts.scheme.is_valid() ? text : FixupPath(text));
 
   // For some schemes whose layouts we understand, we rebuild it.
-  if (url_util::IsStandard(
-      WideToUTF8(scheme).c_str(), static_cast<int>(scheme.length()),
-      url_parse::Component(0, static_cast<int>(scheme.length())))) {
+  if (url_util::IsStandard(scheme.c_str(), static_cast<int>(scheme.length()),
+          url_parse::Component(0, static_cast<int>(scheme.length())))) {
     wstring url(scheme);
     url.append(L"://");
 
     // We need to check whether the |username| is valid because it is our
     // responsibility to append the '@' to delineate the user information from
     // the host portion of the URL.
     if (parts.username.is_valid()) {
       FixupUsername(trimmed, parts.username, &url);
       FixupPassword(trimmed, parts.password, &url);
       url.append(L"@");
@@ skipping 18 matching lines @@
   return trimmed;
 }
 
 // The rules are different here than for regular fixup, since we need to handle
 // input like "hello.html" and know to look in the current directory.  Regular
 // fixup will look for cues that it is actually a file path before trying to
 // figure out what file it is.  If our logic doesn't work, we will fall back on
 // regular fixup.
 wstring URLFixerUpper::FixupRelativeFile(const wstring& base_dir,
                                          const wstring& text) {
-  wstring old_cur_directory;
+  wchar_t old_cur_directory[MAX_PATH];
   if (!base_dir.empty()) {
     // save the old current directory before we move to the new one
-    file_util::GetCurrentDirectory(&old_cur_directory);
-    file_util::SetCurrentDirectory(base_dir);
+    // TODO: in the future, we may want to handle paths longer than MAX_PATH
+    GetCurrentDirectory(MAX_PATH, old_cur_directory);
+    SetCurrentDirectory(base_dir.c_str());
   }
 
   // allow funny input with extra whitespace and the wrong kind of slashes
   wstring trimmed;
   PrepareStringForFileOps(text, &trimmed);
 
   bool is_file = true;
   wstring full_path;
   if (!ValidPathForFile(trimmed, &full_path)) {
     // Not a path as entered, try unescaping it in case the user has
     // escaped things. We need to go through 8-bit since the escaped values
     // only represent 8-bit values.
     std::wstring unescaped = UTF8ToWide(UnescapeURLComponent(
         WideToUTF8(trimmed),
         UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS));
     if (!ValidPathForFile(unescaped, &full_path))
       is_file = false;
   }
 
   // Put back the current directory if we saved it.
   if (!base_dir.empty())
-    file_util::SetCurrentDirectory(old_cur_directory);
+    SetCurrentDirectory(old_cur_directory);
 
   if (is_file) {
     GURL file_url = net::FilePathToFileURL(full_path);
     if (file_url.is_valid())
       return gfx::ElideUrl(file_url, ChromeFont(), 0, std::wstring());
     // Invalid files fall through to regular processing.
   }
 
   // Fall back on regular fixup for this input.
   return FixupURL(text, L"");
 }