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

components/bookmarks/browser/bookmark_utils.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/bookmarks/browser/bookmark_utils.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/string_search.h"
 #include "base/macros.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/bookmarks/browser/bookmark_client.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/scoped_group_bookmark_actions.h"
 #include "components/bookmarks/common/bookmark_pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/query_parser/query_parser.h"
-#include "net/base/net_util.h"
+#include "components/url_formatter/url_formatter.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/models/tree_node_iterator.h"
 #include "url/gurl.h"
 
 using base::Time;
 
 namespace bookmarks {
 
 namespace {
 
@@ skipping 50 matching lines @@
     }
   }
   return true;
 }
 
 // Returns true if |node|s title or url contains the strings in |words|.
 // |languages| argument is user's accept-language setting to decode IDN.
 bool DoesBookmarkContainWords(const BookmarkNode* node,
                               const std::vector<base::string16>& words,
                               const std::string& languages) {
-  return
-      DoesBookmarkTextContainWords(node->GetTitle(), words) ||
-      DoesBookmarkTextContainWords(
-          base::UTF8ToUTF16(node->url().spec()), words) ||
-      DoesBookmarkTextContainWords(net::FormatUrl(
-          node->url(), languages, net::kFormatUrlOmitNothing,
-          net::UnescapeRule::NORMAL, NULL, NULL, NULL), words);
+  return DoesBookmarkTextContainWords(node->GetTitle(), words) ||
+         DoesBookmarkTextContainWords(base::UTF8ToUTF16(node->url().spec()),
+                                      words) ||
+         DoesBookmarkTextContainWords(
+             url_formatter::FormatUrl(
+                 node->url(), languages, url_formatter::kFormatUrlOmitNothing,
+                 net::UnescapeRule::NORMAL, NULL, NULL, NULL),
+             words);
 }
 
 // This is used with a tree iterator to skip subtrees which are not visible.
 bool PruneInvisibleFolders(const BookmarkNode* node) {
   return !node->IsVisible();
 }
 
 // This traces parents up to root, determines if node is contained in a
 // selected folder.
 bool HasSelectedAncestor(BookmarkModel* model,
@@ skipping 393 matching lines @@
     if (index > -1 && model->client()->CanBeEditedByUser(node))
       model->Remove(node);
   }
 }
 
 base::string16 CleanUpUrlForMatching(
     const GURL& gurl,
     const std::string& languages,
     base::OffsetAdjuster::Adjustments* adjustments) {
   base::OffsetAdjuster::Adjustments tmp_adjustments;
-  return base::i18n::ToLower(net::FormatUrlWithAdjustments(
+  return base::i18n::ToLower(url_formatter::FormatUrlWithAdjustments(
       GURL(TruncateUrl(gurl.spec())), languages,
-      net::kFormatUrlOmitUsernamePassword,
-      net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS,
-      NULL, NULL, adjustments ? adjustments : &tmp_adjustments));
+      url_formatter::kFormatUrlOmitUsernamePassword,
+      net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS, NULL,
+      NULL, adjustments ? adjustments : &tmp_adjustments));
 }
 
 base::string16 CleanUpTitleForMatching(const base::string16& title) {
   return base::i18n::ToLower(title.substr(0u, kCleanedUpTitleMaxLength));
 }
 
 bool CanAllBeEditedByUser(BookmarkClient* client,
                           const std::vector<const BookmarkNode*>& nodes) {
   for (size_t i = 0; i < nodes.size(); ++i) {
     if (!client->CanBeEditedByUser(nodes[i]))
@@ skipping 25 matching lines @@
 bool HasDescendantsOf(const std::vector<const BookmarkNode*>& list,
                       const BookmarkNode* root) {
   for (const BookmarkNode* node : list) {
     if (IsDescendantOf(node, root))
       return true;
   }
   return false;
 }
 
 }  // namespace bookmarks