| // Copyright (c) 2012 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 "components/url_formatter/url_fixer.h" |
| |
| #include <stddef.h> |
| |
| #include <algorithm> |
| |
| #include "base/files/file_path.h" |
| #include "base/files/file_util.h" |
| #include "base/logging.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "build/build_config.h" |
| #include "components/url_formatter/url_formatter.h" |
| #include "net/base/escape.h" |
| #include "net/base/filename_util.h" |
| #include "net/base/registry_controlled_domains/registry_controlled_domain.h" |
| #include "url/third_party/mozilla/url_parse.h" |
| #include "url/url_file.h" |
| #include "url/url_util.h" |
| |
| #if defined(OS_POSIX) || defined(OS_FUCHSIA) |
| #include "base/path_service.h" |
| #endif |
| |
| namespace url_formatter { |
| |
| const char* home_directory_override = nullptr; |
| |
| namespace { |
| |
| // Hardcode these constants to avoid dependences on //chrome and //content. |
| const char kChromeUIScheme[] = "chrome"; |
| const char kChromeUIDefaultHost[] = "version"; |
| const char kViewSourceScheme[] = "view-source"; |
| |
| // TODO(estade): Remove these ugly, ugly functions. They are only used in |
| // SegmentURL. A url::Parsed object keeps track of a bunch of indices into |
| // a url string, and these need to be updated when the URL is converted from |
| // UTF8 to UTF16. Instead of this after-the-fact adjustment, we should parse it |
| // in the correct string format to begin with. |
| url::Component UTF8ComponentToUTF16Component( |
| const std::string& text_utf8, |
| const url::Component& component_utf8) { |
| if (component_utf8.len == -1) |
| return url::Component(); |
| |
| std::string before_component_string = |
| text_utf8.substr(0, component_utf8.begin); |
| std::string component_string = |
| text_utf8.substr(component_utf8.begin, component_utf8.len); |
| base::string16 before_component_string_16 = |
| base::UTF8ToUTF16(before_component_string); |
| base::string16 component_string_16 = base::UTF8ToUTF16(component_string); |
| url::Component component_16(before_component_string_16.length(), |
| component_string_16.length()); |
| return component_16; |
| } |
| |
| void UTF8PartsToUTF16Parts(const std::string& text_utf8, |
| const url::Parsed& parts_utf8, |
| url::Parsed* parts) { |
| if (base::IsStringASCII(text_utf8)) { |
| *parts = parts_utf8; |
| return; |
| } |
| |
| parts->scheme = UTF8ComponentToUTF16Component(text_utf8, parts_utf8.scheme); |
| parts->username = |
| UTF8ComponentToUTF16Component(text_utf8, parts_utf8.username); |
| parts->password = |
| UTF8ComponentToUTF16Component(text_utf8, parts_utf8.password); |
| parts->host = UTF8ComponentToUTF16Component(text_utf8, parts_utf8.host); |
| parts->port = UTF8ComponentToUTF16Component(text_utf8, parts_utf8.port); |
| parts->path = UTF8ComponentToUTF16Component(text_utf8, parts_utf8.path); |
| parts->query = UTF8ComponentToUTF16Component(text_utf8, parts_utf8.query); |
| parts->ref = UTF8ComponentToUTF16Component(text_utf8, parts_utf8.ref); |
| } |
| |
| base::TrimPositions TrimWhitespaceUTF8(const std::string& input, |
| base::TrimPositions positions, |
| std::string* output) { |
| // This implementation is not so fast since it converts the text encoding |
| // twice. Please feel free to file a bug if this function hurts the |
| // performance of Chrome. |
| DCHECK(base::IsStringUTF8(input)); |
| base::string16 input16 = base::UTF8ToUTF16(input); |
| base::string16 output16; |
| base::TrimPositions result = |
| base::TrimWhitespace(input16, positions, &output16); |
| *output = base::UTF16ToUTF8(output16); |
| return result; |
| } |
| |
| // does some basic fixes for input that we want to test for file-ness |
| void PrepareStringForFileOps(const base::FilePath& text, |
| base::FilePath::StringType* output) { |
| #if defined(OS_WIN) |
| base::TrimWhitespace(text.value(), base::TRIM_ALL, output); |
| replace(output->begin(), output->end(), '/', '\\'); |
| #elif defined(OS_POSIX) || defined(OS_FUCHSIA) |
| TrimWhitespaceUTF8(text.value(), base::TRIM_ALL, output); |
| #else |
| #error Unsupported platform |
| #endif |
| } |
| |
| // 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. |
| bool ValidPathForFile(const base::FilePath::StringType& text, |
| base::FilePath* full_path) { |
| base::FilePath file_path = base::MakeAbsoluteFilePath(base::FilePath(text)); |
| if (file_path.empty()) |
| return false; |
| |
| if (!base::PathExists(file_path)) |
| return false; |
| |
| *full_path = file_path; |
| return true; |
| } |
| |
| #if defined(OS_POSIX) || defined(OS_FUCHSIA) |
| // Given a path that starts with ~, return a path that starts with an |
| // expanded-out /user/foobar directory. |
| std::string FixupHomedir(const std::string& text) { |
| DCHECK(text.length() > 0 && text[0] == '~'); |
| |
| if (text.length() == 1 || text[1] == '/') { |
| base::FilePath file_path; |
| if (home_directory_override) |
| file_path = base::FilePath(home_directory_override); |
| else |
| base::PathService::Get(base::DIR_HOME, &file_path); |
| |
| // We'll probably break elsewhere if $HOME is undefined, but check here |
| // just in case. |
| if (file_path.value().empty()) |
| return text; |
| // Append requires to be a relative path, so we have to cut all preceeding |
| // '/' characters. |
| size_t i = 1; |
| while (i < text.length() && text[i] == '/') |
| ++i; |
| return file_path.Append(text.substr(i)).value(); |
| } |
| |
| // Otherwise, this is a path like ~foobar/baz, where we must expand to |
| // user foobar's home directory. Officially, we should use getpwent(), |
| // but that is a nasty blocking call. |
| |
| #if defined(OS_MACOSX) |
| static const char kHome[] = "/Users/"; |
| #else |
| static const char kHome[] = "/home/"; |
| #endif |
| return kHome + text.substr(1); |
| } |
| #endif |
| |
| // Tries to create a file: URL from |text| if it looks like a filename, even if |
| // it doesn't resolve as a valid path or to an existing file. Returns a |
| // (possibly invalid) file: URL in |fixed_up_url| for input beginning |
| // with a drive specifier or "\\". Returns the unchanged input in other cases |
| // (including file: URLs: these don't look like filenames). |
| std::string FixupPath(const std::string& text) { |
| DCHECK(!text.empty()); |
| |
| base::FilePath::StringType filename; |
| #if defined(OS_WIN) |
| base::FilePath input_path(base::UTF8ToWide(text)); |
| PrepareStringForFileOps(input_path, &filename); |
| |
| // Fixup Windows-style drive letters, where "C:" gets rewritten to "C|". |
| if (filename.length() > 1 && filename[1] == '|') |
| filename[1] = ':'; |
| #elif defined(OS_POSIX) || defined(OS_FUCHSIA) |
| base::FilePath input_path(text); |
| PrepareStringForFileOps(input_path, &filename); |
| if (filename.length() > 0 && filename[0] == '~') |
| filename = FixupHomedir(filename); |
| #endif |
| |
| // Here, we know the input looks like a file. |
| GURL file_url = net::FilePathToFileURL(base::FilePath(filename)); |
| if (file_url.is_valid()) { |
| return base::UTF16ToUTF8(url_formatter::FormatUrl( |
| file_url, url_formatter::kFormatUrlOmitUsernamePassword, |
| net::UnescapeRule::NORMAL, nullptr, nullptr, nullptr)); |
| } |
| |
| // Invalid file URL, just return the input. |
| return text; |
| } |
| |
| // Checks |domain| to see if a valid TLD is already present. If not, appends |
| // |desired_tld| to the domain, and prepends "www." unless it's already present. |
| void AddDesiredTLD(const std::string& desired_tld, std::string* domain) { |
| if (desired_tld.empty() || domain->empty()) |
| return; |
| |
| // Abort if we already have a known TLD. In the case of an invalid host, |
| // HostHasRegistryControlledDomain will return false and we will try to |
| // append a TLD (which may make it valid). For example, "999999999999" is |
| // detected as a broken IP address and marked invalid, but attaching ".com" |
| // makes it legal. We disallow unknown registries here so users can input |
| // "mail.yahoo" and hit ctrl-enter to get "www.mail.yahoo.com". |
| if (net::registry_controlled_domains::HostHasRegistryControlledDomain( |
| *domain, net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES, |
| net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES)) |
| return; |
| |
| // Add the suffix at the end of the domain. |
| const size_t domain_length(domain->length()); |
| DCHECK_GT(domain_length, 0U); |
| DCHECK_NE(desired_tld[0], '.'); |
| if ((*domain)[domain_length - 1] != '.') |
| domain->push_back('.'); |
| domain->append(desired_tld); |
| |
| // Now, if the domain begins with "www.", stop. |
| const std::string prefix("www."); |
| if (domain->compare(0, prefix.length(), prefix) != 0) { |
| // Otherwise, add www. to the beginning of the URL. |
| domain->insert(0, prefix); |
| } |
| } |
| |
| inline void FixupUsername(const std::string& text, |
| const url::Component& part, |
| std::string* url) { |
| if (!part.is_valid()) |
| return; |
| |
| // We don't fix up the username at the moment. |
| url->append(text, part.begin, part.len); |
| // Do not append the trailing '@' because we might need to include the user's |
| // password. FixupURL itself will append the '@' for us. |
| } |
| |
| inline void FixupPassword(const std::string& text, |
| const url::Component& part, |
| std::string* url) { |
| if (!part.is_valid()) |
| return; |
| |
| // We don't fix up the password at the moment. |
| url->append(":"); |
| url->append(text, part.begin, part.len); |
| } |
| |
| void FixupHost(const std::string& text, |
| const url::Component& part, |
| bool has_scheme, |
| const std::string& desired_tld, |
| std::string* url) { |
| if (!part.is_valid()) |
| return; |
| |
| // Make domain valid. |
| // Strip all leading dots and all but one trailing dot, unless the user only |
| // typed dots, in which case their input is totally invalid and we should just |
| // leave it unchanged. |
| std::string domain(text, part.begin, part.len); |
| const size_t first_nondot(domain.find_first_not_of('.')); |
| if (first_nondot != std::string::npos) { |
| domain.erase(0, first_nondot); |
| size_t last_nondot(domain.find_last_not_of('.')); |
| DCHECK(last_nondot != std::string::npos); |
| last_nondot += 2; // Point at second period in ending string |
| if (last_nondot < domain.length()) |
| domain.erase(last_nondot); |
| } |
| |
| // Add any user-specified TLD, if applicable. |
| AddDesiredTLD(desired_tld, &domain); |
| |
| url->append(domain); |
| } |
| |
| void FixupPort(const std::string& text, |
| const url::Component& part, |
| std::string* url) { |
| if (!part.is_valid()) |
| return; |
| |
| // We don't fix up the port at the moment. |
| url->append(":"); |
| url->append(text, part.begin, part.len); |
| } |
| |
| inline void FixupPath(const std::string& text, |
| const url::Component& part, |
| std::string* url) { |
| if (!part.is_valid() || part.len == 0) { |
| // We should always have a path. |
| url->append("/"); |
| return; |
| } |
| |
| // Append the path as is. |
| url->append(text, part.begin, part.len); |
| } |
| |
| inline void FixupQuery(const std::string& text, |
| const url::Component& part, |
| std::string* url) { |
| if (!part.is_valid()) |
| return; |
| |
| // We don't fix up the query at the moment. |
| url->append("?"); |
| url->append(text, part.begin, part.len); |
| } |
| |
| inline void FixupRef(const std::string& text, |
| const url::Component& part, |
| std::string* url) { |
| if (!part.is_valid()) |
| return; |
| |
| // We don't fix up the ref at the moment. |
| url->append("#"); |
| url->append(text, part.begin, part.len); |
| } |
| |
| bool HasPort(const std::string& original_text, |
| const url::Component& scheme_component) { |
| // Find the range between the ":" and the "/". |
| size_t port_start = scheme_component.end() + 1; |
| size_t port_end = port_start; |
| while ((port_end < original_text.length()) && |
| !url::IsAuthorityTerminator(original_text[port_end])) |
| ++port_end; |
| if (port_end == port_start) |
| return false; |
| |
| // Scan the range to see if it is entirely digits. |
| for (size_t i = port_start; i < port_end; ++i) { |
| if (!base::IsAsciiDigit(original_text[i])) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| // Try to extract a valid scheme from the beginning of |text|. |
| // If successful, set |scheme_component| to the text range where the scheme |
| // was located, and fill |canon_scheme| with its canonicalized form. |
| // Otherwise, return false and leave the outputs in an indeterminate state. |
| bool GetValidScheme(const std::string& text, |
| url::Component* scheme_component, |
| std::string* canon_scheme) { |
| canon_scheme->clear(); |
| |
| // Locate everything up to (but not including) the first ':' |
| if (!url::ExtractScheme(text.data(), static_cast<int>(text.length()), |
| scheme_component)) { |
| return false; |
| } |
| |
| // Make sure the scheme contains only valid characters, and convert |
| // to lowercase. This also catches IPv6 literals like [::1], because |
| // brackets are not in the whitelist. |
| url::StdStringCanonOutput canon_scheme_output(canon_scheme); |
| url::Component canon_scheme_component; |
| if (!url::CanonicalizeScheme(text.data(), *scheme_component, |
| &canon_scheme_output, &canon_scheme_component)) { |
| return false; |
| } |
| |
| // Strip the ':', and any trailing buffer space. |
| DCHECK_EQ(0, canon_scheme_component.begin); |
| canon_scheme->erase(canon_scheme_component.len); |
| |
| // We need to fix up the segmentation for "www.example.com:/". For this |
| // case, we guess that schemes with a "." are not actually schemes. |
| if (canon_scheme->find('.') != std::string::npos) |
| return false; |
| |
| // We need to fix up the segmentation for "www:123/". For this case, we |
| // will add an HTTP scheme later and make the URL parser happy. |
| // TODO(pkasting): Maybe we should try to use GURL's parser for this? |
| if (HasPort(text, *scheme_component)) |
| return false; |
| |
| // Everything checks out. |
| return true; |
| } |
| |
| // Performs the work for url_formatter::SegmentURL. |text| may be modified on |
| // output on success: a semicolon following a valid scheme is replaced with a |
| // colon. |
| std::string SegmentURLInternal(std::string* text, url::Parsed* parts) { |
| // Initialize the result. |
| *parts = url::Parsed(); |
| |
| std::string trimmed; |
| TrimWhitespaceUTF8(*text, base::TRIM_ALL, &trimmed); |
| if (trimmed.empty()) |
| return std::string(); // Nothing to segment. |
| |
| std::string scheme; |
| #if defined(OS_WIN) |
| int trimmed_length = static_cast<int>(trimmed.length()); |
| if (url::DoesBeginWindowsDriveSpec(trimmed.data(), 0, trimmed_length) || |
| url::DoesBeginUNCPath(trimmed.data(), 0, trimmed_length, true)) |
| scheme = url::kFileScheme; |
| #elif defined(OS_POSIX) || defined(OS_FUCHSIA) |
| if (base::FilePath::IsSeparator(trimmed.data()[0]) || |
| trimmed.data()[0] == '~') |
| scheme = url::kFileScheme; |
| #endif |
| |
| // Otherwise, we need to look at things carefully. |
| if (scheme.empty() && !GetValidScheme(*text, &parts->scheme, &scheme)) { |
| // Try again if there is a ';' in the text. If changing it to a ':' results |
| // in a standard scheme, "about", "chrome" or "file" scheme being found, |
| // continue processing with the modified text. |
| bool found_scheme = false; |
| size_t semicolon = text->find(';'); |
| if (semicolon != 0 && semicolon != std::string::npos) { |
| (*text)[semicolon] = ':'; |
| if (GetValidScheme(*text, &parts->scheme, &scheme) && |
| (url::IsStandard( |
| scheme.c_str(), |
| url::Component(0, static_cast<int>(scheme.length()))) || |
| scheme == url::kAboutScheme || scheme == kChromeUIScheme || |
| scheme == url::kFileScheme)) |
| found_scheme = true; |
| else |
| (*text)[semicolon] = ';'; |
| } |
| if (!found_scheme) { |
| // Couldn't determine the scheme, so just default to http. |
| parts->scheme.reset(); |
| scheme = url::kHttpScheme; |
| } |
| } |
| |
| // Proceed with about and chrome schemes, but not file or nonstandard schemes. |
| if ((scheme != url::kAboutScheme) && (scheme != kChromeUIScheme) && |
| !url::IsStandard(scheme.c_str(), |
| url::Component(0, static_cast<int>(scheme.length())))) { |
| return scheme; |
| } |
| |
| int text_length = static_cast<int>(text->length()); |
| if (scheme == url::kFileScheme) { |
| url::ParseFileURL(text->data(), text_length, parts); |
| return scheme; |
| } |
| |
| if (scheme == url::kFileSystemScheme) { |
| // Have the GURL parser do the heavy lifting for us. |
| url::ParseFileSystemURL(text->data(), text_length, parts); |
| return scheme; |
| } |
| |
| if (parts->scheme.is_valid()) { |
| // Have the GURL parser do the heavy lifting for us. |
| url::ParseStandardURL(text->data(), text_length, parts); |
| return scheme; |
| } |
| |
| // We need to add a scheme in order for ParseStandardURL to be happy. |
| // Find the first non-whitespace character. |
| std::string::iterator first_nonwhite = text->begin(); |
| while ((first_nonwhite != text->end()) && |
| base::IsUnicodeWhitespace(*first_nonwhite)) |
| ++first_nonwhite; |
| |
| // Construct the text to parse by inserting the scheme. |
| std::string inserted_text(scheme); |
| // Assume a leading colon was meant to be a scheme separator (which GURL will |
| // fix up for us into the full "://"). Otherwise add the separator ourselves. |
| if (first_nonwhite == text->end() || *first_nonwhite != ':') |
| inserted_text.append(url::kStandardSchemeSeparator); |
| std::string 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. |
| url::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); |
| OffsetComponent(offset, &parts->query); |
| OffsetComponent(offset, &parts->ref); |
| |
| return scheme; |
| } |
| |
| } // namespace |
| |
| std::string SegmentURL(const std::string& text, url::Parsed* parts) { |
| std::string mutable_text(text); |
| return SegmentURLInternal(&mutable_text, parts); |
| } |
| |
| base::string16 SegmentURL(const base::string16& text, url::Parsed* parts) { |
| std::string text_utf8 = base::UTF16ToUTF8(text); |
| url::Parsed parts_utf8; |
| std::string scheme_utf8 = SegmentURL(text_utf8, &parts_utf8); |
| UTF8PartsToUTF16Parts(text_utf8, parts_utf8, parts); |
| return base::UTF8ToUTF16(scheme_utf8); |
| } |
| |
| GURL FixupURL(const std::string& text, const std::string& desired_tld) { |
| std::string trimmed; |
| TrimWhitespaceUTF8(text, base::TRIM_ALL, &trimmed); |
| if (trimmed.empty()) |
| return GURL(); // Nothing here. |
| |
| // Segment the URL. |
| url::Parsed parts; |
| std::string scheme(SegmentURLInternal(&trimmed, &parts)); |
| |
| // For view-source: URLs, we strip "view-source:", do fixup, and stick it back |
| // on. This allows us to handle things like "view-source:google.com". |
| if (scheme == kViewSourceScheme) { |
| // Reject "view-source:view-source:..." to avoid deep recursion. |
| std::string view_source(kViewSourceScheme + std::string(":")); |
| if (!base::StartsWith(text, view_source + view_source, |
| base::CompareCase::INSENSITIVE_ASCII)) { |
| return GURL(kViewSourceScheme + std::string(":") + |
| FixupURL(trimmed.substr(scheme.length() + 1), desired_tld) |
| .possibly_invalid_spec()); |
| } |
| } |
| |
| // We handle the file scheme separately. |
| if (scheme == url::kFileScheme) |
| return GURL(parts.scheme.is_valid() ? text : FixupPath(text)); |
| |
| // We handle the filesystem scheme separately. |
| if (scheme == url::kFileSystemScheme) { |
| if (parts.inner_parsed() && parts.inner_parsed()->scheme.is_valid()) |
| return GURL(text); |
| return GURL(); |
| } |
| |
| // 'about:blank' is special-cased in various places in the code so it |
| // shouldn't be transformed into 'chrome://blank' as the code below will do. |
| if (base::LowerCaseEqualsASCII(scheme, url::kAboutScheme)) { |
| GURL about_url(base::ToLowerASCII(trimmed)); |
| if (about_url.IsAboutBlank()) |
| return about_url; |
| } |
| |
| // Parse and rebuild about: and chrome: URLs. |
| bool chrome_url = |
| (scheme == url::kAboutScheme) || (scheme == kChromeUIScheme); |
| |
| // For some schemes whose layouts we understand, we rebuild it. |
| if (chrome_url || |
| url::IsStandard(scheme.c_str(), |
| url::Component(0, static_cast<int>(scheme.length())))) { |
| // Replace the about: scheme with the chrome: scheme. |
| std::string url(chrome_url ? kChromeUIScheme : scheme); |
| url.append(url::kStandardSchemeSeparator); |
| |
| // 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("@"); |
| } |
| |
| FixupHost(trimmed, parts.host, parts.scheme.is_valid(), desired_tld, &url); |
| if (chrome_url && !parts.host.is_valid()) |
| url.append(kChromeUIDefaultHost); |
| FixupPort(trimmed, parts.port, &url); |
| FixupPath(trimmed, parts.path, &url); |
| FixupQuery(trimmed, parts.query, &url); |
| FixupRef(trimmed, parts.ref, &url); |
| |
| return GURL(url); |
| } |
| |
| // In the worst-case, we insert a scheme if the URL lacks one. |
| if (!parts.scheme.is_valid()) { |
| std::string fixed_scheme(scheme); |
| fixed_scheme.append(url::kStandardSchemeSeparator); |
| trimmed.insert(0, fixed_scheme); |
| } |
| |
| return GURL(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. |
| GURL FixupRelativeFile(const base::FilePath& base_dir, |
| const base::FilePath& text) { |
| base::FilePath old_cur_directory; |
| if (!base_dir.empty()) { |
| // Save the old current directory before we move to the new one. |
| base::GetCurrentDirectory(&old_cur_directory); |
| base::SetCurrentDirectory(base_dir); |
| } |
| |
| // Allow funny input with extra whitespace and the wrong kind of slashes. |
| base::FilePath::StringType trimmed; |
| PrepareStringForFileOps(text, &trimmed); |
| |
| bool is_file = true; |
| // Avoid recognizing definite non-file URLs as file paths. |
| GURL gurl(trimmed); |
| if (gurl.is_valid() && gurl.IsStandard()) |
| is_file = false; |
| base::FilePath full_path; |
| if (is_file && !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. |
| #if defined(OS_WIN) |
| std::wstring unescaped = base::UTF8ToWide(net::UnescapeURLComponent( |
| base::WideToUTF8(trimmed), |
| net::UnescapeRule::SPACES | net::UnescapeRule::PATH_SEPARATORS | |
| net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS)); |
| #elif defined(OS_POSIX) || defined(OS_FUCHSIA) |
| std::string unescaped = net::UnescapeURLComponent( |
| trimmed, |
| net::UnescapeRule::SPACES | net::UnescapeRule::PATH_SEPARATORS | |
| net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS); |
| #endif |
| |
| if (!ValidPathForFile(unescaped, &full_path)) |
| is_file = false; |
| } |
| |
| // Put back the current directory if we saved it. |
| if (!base_dir.empty()) |
| base::SetCurrentDirectory(old_cur_directory); |
| |
| if (is_file) { |
| GURL file_url = net::FilePathToFileURL(full_path); |
| if (file_url.is_valid()) |
| return GURL(base::UTF16ToUTF8(url_formatter::FormatUrl( |
| file_url, url_formatter::kFormatUrlOmitUsernamePassword, |
| net::UnescapeRule::NORMAL, nullptr, nullptr, nullptr))); |
| // Invalid files fall through to regular processing. |
| } |
| |
| // Fall back on regular fixup for this input. |
| #if defined(OS_WIN) |
| std::string text_utf8 = base::WideToUTF8(text.value()); |
| #elif defined(OS_POSIX) || defined(OS_FUCHSIA) |
| std::string text_utf8 = text.value(); |
| #endif |
| return FixupURL(text_utf8, std::string()); |
| } |
| |
| void OffsetComponent(int offset, url::Component* part) { |
| DCHECK(part); |
| |
| if (part->is_valid()) { |
| // Offset the location of this component. |
| part->begin += offset; |
| |
| // This part might not have existed in the original text. |
| if (part->begin < 0) |
| part->reset(); |
| } |
| } |
| |
| bool IsEquivalentScheme(const std::string& scheme1, |
| const std::string& scheme2) { |
| return scheme1 == scheme2 || |
| (scheme1 == url::kAboutScheme && scheme2 == kChromeUIScheme) || |
| (scheme1 == kChromeUIScheme && scheme2 == url::kAboutScheme); |
| } |
| |
| } // namespace url_formatter |