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

components/omnibox/browser/search_suggestion_parser.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/search_suggestion_parser.h"
 
 #include <algorithm>
 
 #include "base/i18n/icu_string_conversions.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/omnibox/browser/autocomplete_i18n.h"
 #include "components/omnibox/browser/autocomplete_input.h"
 #include "components/omnibox/browser/url_prefix.h"
-#include "components/url_fixer/url_fixer.h"
-#include "net/base/net_util.h"
+#include "components/url_formatter/url_fixer.h"
+#include "components/url_formatter/url_formatter.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "url/url_constants.h"
 
 namespace {
 
 AutocompleteMatchType::Type GetAutocompleteMatchType(const std::string& type) {
   if (type == "CALCULATOR")
     return AutocompleteMatchType::CALCULATOR;
   if (type == "ENTITY")
@@ skipping 186 matching lines @@
     const AutocompleteSchemeClassifier& scheme_classifier,
     const GURL& url,
     AutocompleteMatchType::Type type,
     const base::string16& description,
     const std::string& deletion_url,
     bool from_keyword_provider,
     int relevance,
     bool relevance_from_server,
     const base::string16& input_text,
     const std::string& languages)
-    : Result(from_keyword_provider, relevance, relevance_from_server, type,
+    : Result(from_keyword_provider,
+             relevance,
+             relevance_from_server,
+             type,
              deletion_url),
       url_(url),
       formatted_url_(AutocompleteInput::FormattedStringWithEquivalentMeaning(
-          url, net::FormatUrl(url, languages,
-                              net::kFormatUrlOmitAll & ~net::kFormatUrlOmitHTTP,
-                              net::UnescapeRule::SPACES, NULL, NULL, NULL),
+          url,
+          url_formatter::FormatUrl(url,
+                                   languages,
+                                   url_formatter::kFormatUrlOmitAll &
+                                       ~url_formatter::kFormatUrlOmitHTTP,
+                                   net::UnescapeRule::SPACES,
+                                   nullptr,
+                                   nullptr,
+                                   nullptr),
           scheme_classifier)),
       description_(description) {
   DCHECK(url_.is_valid());
   CalculateAndClassifyMatchContents(true, input_text, languages);
 }
 
 SearchSuggestionParser::NavigationResult::~NavigationResult() {}
 
 void
 SearchSuggestionParser::NavigationResult::CalculateAndClassifyMatchContents(
     const bool allow_bolding_nothing,
     const base::string16& input_text,
     const std::string& languages) {
   if (input_text.empty()) {
     // In case of zero-suggest results, do not highlight matches.
     match_contents_class_.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
     return;
   }
 
   // First look for the user's input inside the formatted url as it would be
   // without trimming the scheme, so we can find matches at the beginning of the
   // scheme.
   const URLPrefix* prefix =
       URLPrefix::BestURLPrefix(formatted_url_, input_text);
   size_t match_start = (prefix == NULL) ?
       formatted_url_.find(input_text) : prefix->prefix.length();
   bool trim_http = !AutocompleteInput::HasHTTPScheme(input_text) &&
                    (!prefix || (match_start != 0));
-  const net::FormatUrlTypes format_types =
-      net::kFormatUrlOmitAll & ~(trim_http ? 0 : net::kFormatUrlOmitHTTP);
+  const url_formatter::FormatUrlTypes format_types =
+      url_formatter::kFormatUrlOmitAll &
+      ~(trim_http ? 0 : url_formatter::kFormatUrlOmitHTTP);
 
-  base::string16 match_contents = net::FormatUrl(url_, languages, format_types,
-      net::UnescapeRule::SPACES, NULL, NULL, &match_start);
+  base::string16 match_contents = url_formatter::FormatUrl(
+      url_, languages, format_types, net::UnescapeRule::SPACES, nullptr,
+      nullptr, &match_start);
   // If the first match in the untrimmed string was inside a scheme that we
   // trimmed, look for a subsequent match.
   if (match_start == base::string16::npos)
     match_start = match_contents.find(input_text);
   // Update |match_contents_| and |match_contents_class_| if it's allowed.
   if (allow_bolding_nothing || (match_start != base::string16::npos)) {
     match_contents_ = match_contents;
     // Safe if |match_start| is npos; also safe if the input is longer than the
     // remaining contents after |match_start|.
     AutocompleteMatch::ClassifyLocationInString(match_start,
@@ skipping 183 matching lines @@
     const base::DictionaryValue* suggestion_detail = NULL;
     std::string deletion_url;
 
     if (suggestion_details &&
         suggestion_details->GetDictionary(index, &suggestion_detail))
       suggestion_detail->GetString("du", &deletion_url);
 
     if ((match_type == AutocompleteMatchType::NAVSUGGEST) ||
         (match_type == AutocompleteMatchType::NAVSUGGEST_PERSONALIZED)) {
       // Do not blindly trust the URL coming from the server to be valid.
-      GURL url(
-          url_fixer::FixupURL(base::UTF16ToUTF8(suggestion), std::string()));
+      GURL url(url_formatter::FixupURL(base::UTF16ToUTF8(suggestion),
+                                       std::string()));
       if (url.is_valid() && allow_navsuggest) {
         base::string16 title;
         if (descriptions != NULL)
           descriptions->GetString(index, &title);
         results->navigation_results.push_back(NavigationResult(
             scheme_classifier, url, match_type, title, deletion_url,
             is_keyword_result, relevance, relevances != NULL, input.text(),
             languages));
       }
     } else {
@@ skipping 52 matching lines @@
           base::CollapseWhitespace(suggestion, false), match_type,
           base::CollapseWhitespace(match_contents, false),
           match_contents_prefix, annotation, answer_contents, answer_type_str,
           answer.Pass(), suggest_query_params, deletion_url, is_keyword_result,
           relevance, relevances != NULL, should_prefetch, trimmed_input));
     }
   }
   results->relevances_from_server = relevances != NULL;
   return true;
 }