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

components/omnibox/browser/autocomplete_input.cc

 // Copyright 2014 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/omnibox/browser/autocomplete_input.h"
 
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/omnibox/browser/autocomplete_scheme_classifier.h"
 #include "components/omnibox/browser/omnibox_field_trial.h"
-#include "components/url_fixer/url_fixer.h"
+#include "components/url_formatter/url_fixer.h"
+#include "components/url_formatter/url_formatter.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "url/url_canon_ip.h"
 #include "url/url_util.h"
 
 namespace {
 
 // Hardcode constant to avoid any dependencies on content/.
 const char kViewSourceScheme[] = "view-source";
 
@@ skipping 157 matching lines @@
     return metrics::OmniboxInputType::FORCED_QUERY;
   }
 
   // Ask our parsing back-end to help us understand what the user typed.  We
   // use the URLFixerUpper here because we want to be smart about what we
   // consider a scheme.  For example, we shouldn't consider www.google.com:80
   // to have a scheme.
   url::Parsed local_parts;
   if (!parts)
     parts = &local_parts;
-  const base::string16 parsed_scheme(url_fixer::SegmentURL(text, parts));
+  const base::string16 parsed_scheme(url_formatter::SegmentURL(text, parts));
   if (scheme)
     *scheme = parsed_scheme;
   const std::string parsed_scheme_utf8(base::UTF16ToUTF8(parsed_scheme));
 
   // If we can't canonicalize the user's input, the rest of the autocomplete
   // system isn't going to be able to produce a navigable URL match for it.
   // So we just return QUERY immediately in these cases.
   GURL placeholder_canonicalized_url;
   if (!canonicalized_url)
     canonicalized_url = &placeholder_canonicalized_url;
   *canonicalized_url =
-      url_fixer::FixupURL(base::UTF16ToUTF8(text), desired_tld);
+      url_formatter::FixupURL(base::UTF16ToUTF8(text), desired_tld);
   if (!canonicalized_url->is_valid())
     return metrics::OmniboxInputType::QUERY;
 
   if (base::LowerCaseEqualsASCII(parsed_scheme_utf8, url::kFileScheme)) {
     // A user might or might not type a scheme when entering a file URL.  In
     // either case, |parsed_scheme_utf8| will tell us that this is a file URL,
     // but |parts->scheme| might be empty, e.g. if the user typed "C:\foo".
     return metrics::OmniboxInputType::URL;
   }
 
@@ skipping 34 matching lines @@
       url::Component* components[] = {
         &http_parts.username,
         &http_parts.password,
         &http_parts.host,
         &http_parts.port,
         &http_parts.path,
         &http_parts.query,
         &http_parts.ref,
       };
       for (size_t i = 0; i < arraysize(components); ++i) {
-        url_fixer::OffsetComponent(
+        url_formatter::OffsetComponent(
             -static_cast<int>(http_scheme_prefix.length()), components[i]);
       }
 
       *parts = http_parts;
       if (scheme)
         scheme->clear();
       *canonicalized_url = http_canonicalized_url;
 
       return metrics::OmniboxInputType::URL;
     }
@@ skipping 228 matching lines @@
              parts.inner_parsed() && parts.inner_parsed()->scheme.is_valid()) {
     *host = parts.inner_parsed()->host;
   }
 }
 
 // static
 base::string16 AutocompleteInput::FormattedStringWithEquivalentMeaning(
     const GURL& url,
     const base::string16& formatted_url,
     const AutocompleteSchemeClassifier& scheme_classifier) {
-  if (!net::CanStripTrailingSlash(url))
+  if (!url_formatter::CanStripTrailingSlash(url))
     return formatted_url;
   const base::string16 url_with_path(formatted_url + base::char16('/'));
   return (AutocompleteInput::Parse(formatted_url, std::string(),
                                    scheme_classifier, NULL, NULL, NULL) ==
           AutocompleteInput::Parse(url_with_path, std::string(),
                                    scheme_classifier, NULL, NULL, NULL)) ?
       formatted_url : url_with_path;
 }
 
 // static
@@ skipping 46 matching lines @@
   parts_ = url::Parsed();
   scheme_.clear();
   canonicalized_url_ = GURL();
   prevent_inline_autocomplete_ = false;
   prefer_keyword_ = false;
   allow_exact_keyword_match_ = false;
   want_asynchronous_matches_ = true;
   from_omnibox_focus_ = false;
   terms_prefixed_by_http_or_https_.clear();
 }