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

components/omnibox/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/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.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/autocomplete_input.h"
 #include "components/omnibox/url_prefix.h"
 #include "components/url_fixer/url_fixer.h"
-#include "net/base/net_util.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 188 matching lines @@
     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,
              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, NULL, NULL,
+      &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 257 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;
 }