Move net::FormatUrl and friends outside of //net and into //components

components/url_formatter/url_fixer.cc

 // 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_fixer/url_fixer.h"
+#include "components/url_formatter/url_fixer.h"
 
 #include <algorithm>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #if defined(OS_POSIX)
 #include "base/path_service.h"
 #endif
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "components/url_formatter/url_formatter.h"
 #include "net/base/escape.h"
 #include "net/base/filename_util.h"
-#include "net/base/net_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"
 
-const char* url_fixer::home_directory_override = NULL;
+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
@@ skipping 81 matching lines @@
 }
 
 #if defined(OS_POSIX)
 // 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 (url_fixer::home_directory_override)
-      file_path = base::FilePath(url_fixer::home_directory_override);
+    if (home_directory_override)
+      file_path = base::FilePath(home_directory_override);
     else
       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;
@@ skipping 34 matching lines @@
 #elif defined(OS_POSIX)
   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(net::FormatUrl(file_url,
-                                            std::string(),
-                                            net::kFormatUrlOmitUsernamePassword,
-                                            net::UnescapeRule::NORMAL,
-                                            NULL,
-                                            NULL,
-                                            NULL));
+    return base::UTF16ToUTF8(url_formatter::FormatUrl(
+        file_url, std::string(), 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;
 
   // Check the TLD.  If the return value is positive, we already have a TLD, so
   // abort.  If the return value is std::string::npos, there's no valid host,
   // but we can try to append a TLD anyway, since the host may become valid once
   // the TLD is attached -- for example, "999999999999" is detected as a broken
   // IP address and marked invalid, but attaching ".com" makes it legal.  When
   // the return value is 0, there's a valid host with no known TLD, so we can
   // definitely append the user's TLD.  We disallow unknown registries here so
   // users can input "mail.yahoo" and hit ctrl-enter to get
   // "www.mail.yahoo.com".
   const size_t registry_length =
       net::registry_controlled_domains::GetRegistryLength(
-          *domain,
-          net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
+          *domain, net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
           net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
   if ((registry_length != 0) && (registry_length != std::string::npos))
     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('.');
@@ skipping 128 matching lines @@
 // 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)) {
+  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)) {
+  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_fixer::SegmentURL. |text| may be modified on
+// 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.
@@ skipping 19 matching lines @@
     if (semicolon != 0 && semicolon != std::string::npos) {
       (*text)[semicolon] = ':';
       if (GetValidScheme(*text, &parts->scheme, &scheme))
         found_scheme = true;
       else
         (*text)[semicolon] = ';';
     }
     if (!found_scheme) {
       // Couldn't determine the scheme, so just pick one.
       parts->scheme.reset();
-      scheme = base::StartsWith(*text, "ftp.",
-                                base::CompareCase::INSENSITIVE_ASCII) ?
-          url::kFtpScheme : url::kHttpScheme;
+      scheme =
+          base::StartsWith(*text, "ftp.", base::CompareCase::INSENSITIVE_ASCII)
+              ? url::kFtpScheme
+              : url::kHttpScheme;
     }
   }
 
   // Proceed with about and chrome schemes, but not file or nonstandard schemes.
   if ((scheme != url::kAboutScheme) && (scheme != kChromeUIScheme) &&
       ((scheme == url::kFileScheme) ||
        !url::IsStandard(
            scheme.c_str(),
            url::Component(0, static_cast<int>(scheme.length()))))) {
     return scheme;
   }
 
   if (scheme == url::kFileSystemScheme) {
     // Have the GURL parser do the heavy lifting for us.
-    url::ParseFileSystemURL(
-        text->data(), static_cast<int>(text->length()), parts);
+    url::ParseFileSystemURL(text->data(), static_cast<int>(text->length()),
+                            parts);
     return scheme;
   }
 
   if (parts->scheme.is_valid()) {
     // Have the GURL parser do the heavy lifting for us.
-    url::ParseStandardURL(
-        text->data(), static_cast<int>(text->length()), parts);
+    url::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.
   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);
   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);
+  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());
-  url_fixer::OffsetComponent(offset, &parts->scheme);
-  url_fixer::OffsetComponent(offset, &parts->username);
-  url_fixer::OffsetComponent(offset, &parts->password);
-  url_fixer::OffsetComponent(offset, &parts->host);
-  url_fixer::OffsetComponent(offset, &parts->port);
-  url_fixer::OffsetComponent(offset, &parts->path);
-  url_fixer::OffsetComponent(offset, &parts->query);
-  url_fixer::OffsetComponent(offset, &parts->ref);
+  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 url_fixer::SegmentURL(const std::string& text, url::Parsed* parts) {
+std::string SegmentURL(const std::string& text, url::Parsed* parts) {
   std::string mutable_text(text);
   return SegmentURLInternal(&mutable_text, parts);
 }
 
-base::string16 url_fixer::SegmentURL(const base::string16& text,
-                                     url::Parsed* 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 url_fixer::FixupURL(const std::string& text,
-                         const std::string& desired_tld) {
+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
@@ skipping 61 matching lines @@
   }
 
   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 url_fixer::FixupRelativeFile(const base::FilePath& base_dir,
-                                  const base::FilePath& text) {
+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);
@@ skipping 22 matching lines @@
       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(net::FormatUrl(file_url,
-                                           std::string(),
-                                           net::kFormatUrlOmitUsernamePassword,
-                                           net::UnescapeRule::NORMAL,
-                                           NULL,
-                                           NULL,
-                                           NULL)));
+      return GURL(base::UTF16ToUTF8(url_formatter::FormatUrl(
+          file_url, std::string(),
+          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)
   std::string text_utf8 = text.value();
 #endif
   return FixupURL(text_utf8, std::string());
 }
 
-void url_fixer::OffsetComponent(int offset, url::Component* part) {
+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 url_fixer::IsEquivalentScheme(const std::string& scheme1,
-                                   const std::string& scheme2) {
+bool IsEquivalentScheme(const std::string& scheme1,
+                        const std::string& scheme2) {
   return scheme1 == scheme2 ||
-      (scheme1 == url::kAboutScheme && scheme2 == kChromeUIScheme) ||
-      (scheme1 == kChromeUIScheme && scheme2 == url::kAboutScheme);
+         (scheme1 == url::kAboutScheme && scheme2 == kChromeUIScheme) ||
+         (scheme1 == kChromeUIScheme && scheme2 == url::kAboutScheme);
 }
+
+}  // namespace url_formatter