Move some content url constants to /url.

chrome/browser/autocomplete/autocomplete_input.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 "chrome/browser/autocomplete/autocomplete_input.h"
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/common/net/url_fixer_upper.h"
 #include "content/public/common/url_constants.h"

[blundell, 2014/05/27 09:39:34]

Could you replace all of the includes of //content/public/common/url_constants.h
and //chome/common/url_constants.h with //url/url_constants.h whereever this is
feasible? The concrete benefit is that knowing at a glance which //chrome and
//content dependencies a given source file has is really useful for
componentization.

[Sungmann Cho, 2014/05/28 09:10:51]

Done.

 #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 {
 
 void AdjustCursorPositionIfNecessary(size_t num_leading_chars_removed,
                                      size_t* cursor_position) {
   if (*cursor_position == base::string16::npos)
@@ skipping 131 matching lines @@
   // 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 = URLFixerUpper::FixupURL(base::UTF16ToUTF8(text),
                                                base::UTF16ToUTF8(desired_tld));
   if (!canonicalized_url->is_valid())
     return QUERY;
 
-  if (LowerCaseEqualsASCII(parsed_scheme, content::kFileScheme)) {
+  if (LowerCaseEqualsASCII(parsed_scheme, url::kFileScheme)) {
     // A user might or might not type a scheme when entering a file URL.  In
     // either case, |parsed_scheme| will tell us that this is a file URL, but
     // |parts->scheme| might be empty, e.g. if the user typed "C:\foo".
     return URL;
   }
 
   // If the user typed a scheme, and it's HTTP or HTTPS, we know how to parse it
   // well enough that we can fall through to the heuristics below.  If it's
   // something else, we can just determine our action based on what we do with
   // any input of this scheme.  In theory we could do better with some schemes
   // (e.g. "ftp" or "view-source") but I'll wait to spend the effort on that
   // until I run into some cases that really need it.
   if (parts->scheme.is_nonempty() &&
       !LowerCaseEqualsASCII(parsed_scheme, url::kHttpScheme) &&
       !LowerCaseEqualsASCII(parsed_scheme, url::kHttpsScheme)) {
     // See if we know how to handle the URL internally.  There are some schemes
     // that we convert to other things before they reach the renderer or else
     // the renderer handles internally without reaching the net::URLRequest
     // logic.  They thus won't be listed as "handled protocols", but we should
     // still claim to handle them.
     if (ProfileIOData::IsHandledProtocol(base::UTF16ToASCII(parsed_scheme)) ||
         LowerCaseEqualsASCII(parsed_scheme, content::kViewSourceScheme) ||
-        LowerCaseEqualsASCII(parsed_scheme, content::kJavaScriptScheme) ||
-        LowerCaseEqualsASCII(parsed_scheme, content::kDataScheme))
+        LowerCaseEqualsASCII(parsed_scheme, url::kJavaScriptScheme) ||
+        LowerCaseEqualsASCII(parsed_scheme, url::kDataScheme))
       return URL;
 
     // Not an internal protocol.  Check and see if the user has explicitly
     // opened this scheme as a URL before, or if the "scheme" is actually a
     // username.  We need to do this after the check above because some
     // handlable schemes (e.g. "javascript") may be treated as "blocked" by the
     // external protocol handler because we don't want pages to open them, but
     // users still can.
     // Note that the protocol handler needs to be informed that omnibox input
     // should always be considered "user gesture-triggered", lest it always
@@ skipping 250 matching lines @@
       } else {
         scheme->reset();
       }
       if (real_parts.host.is_nonempty()) {
         *host = url::Component(after_scheme_and_colon + real_parts.host.begin,
                                real_parts.host.len);
       } else {
         host->reset();
       }
     }
-  } else if (LowerCaseEqualsASCII(scheme_str, content::kFileSystemScheme) &&
+  } else if (LowerCaseEqualsASCII(scheme_str, url::kFileSystemScheme) &&
              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) {
   if (!net::CanStripTrailingSlash(url))
@@ skipping 55 matching lines @@
   current_page_classification_ = AutocompleteInput::INVALID_SPEC;
   type_ = INVALID;
   parts_ = url::Parsed();
   scheme_.clear();
   canonicalized_url_ = GURL();
   prevent_inline_autocomplete_ = false;
   prefer_keyword_ = false;
   allow_exact_keyword_match_ = false;
   want_asynchronous_matches_ = true;
 }