Remove AutocompleteInput Type and PageClassification.

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 "components/metrics/proto/omnibox_event.pb.h"
 #include "components/url_fixer/url_fixer.h"
 #include "content/public/common/url_constants.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 {
 
 void AdjustCursorPositionIfNecessary(size_t num_leading_chars_removed,
                                      size_t* cursor_position) {
   if (*cursor_position == base::string16::npos)
     return;
   if (num_leading_chars_removed < *cursor_position)
     *cursor_position -= num_leading_chars_removed;
   else
     *cursor_position = 0;
 }
 
 }  // namespace
 
 AutocompleteInput::AutocompleteInput()
     : cursor_position_(base::string16::npos),
-      current_page_classification_(AutocompleteInput::INVALID_SPEC),
+      current_page_classification_(metrics::OmniboxEventProto::INVALID_SPEC),
       type_(metrics::OmniboxInputType::INVALID),
       prevent_inline_autocomplete_(false),
       prefer_keyword_(false),
       allow_exact_keyword_match_(true),
       want_asynchronous_matches_(true) {
 }
 
 AutocompleteInput::AutocompleteInput(
     const base::string16& text,
     size_t cursor_position,
     const base::string16& desired_tld,
     const GURL& current_url,
-    AutocompleteInput::PageClassification current_page_classification,
+    metrics::OmniboxEventProto::PageClassification current_page_classification,
     bool prevent_inline_autocomplete,
     bool prefer_keyword,
     bool allow_exact_keyword_match,
     bool want_asynchronous_matches)
     : cursor_position_(cursor_position),
       current_url_(current_url),
       current_page_classification_(current_page_classification),
       prevent_inline_autocomplete_(prevent_inline_autocomplete),
       prefer_keyword_(prefer_keyword),
       allow_exact_keyword_match_(allow_exact_keyword_match),
@@ skipping 34 matching lines @@
       text_ = trimmed_text;
     }
   }
 }
 
 AutocompleteInput::~AutocompleteInput() {
 }
 
 // static
 size_t AutocompleteInput::RemoveForcedQueryStringIfNecessary(
-    AutocompleteInput::Type type,
+    metrics::OmniboxInputType::Type type,
     base::string16* text) {
   if ((type != metrics::OmniboxInputType::FORCED_QUERY) || text->empty() ||
       (*text)[0] != L'?')
     return 0;
   // Drop the leading '?'.
   text->erase(0, 1);
   return 1;
 }
 
 // static
-std::string AutocompleteInput::TypeToString(AutocompleteInput::Type type) {
+std::string AutocompleteInput::TypeToString(
+    metrics::OmniboxInputType::Type type) {
   switch (type) {
     case metrics::OmniboxInputType::INVALID:      return "invalid";
     case metrics::OmniboxInputType::UNKNOWN:      return "unknown";
     case metrics::OmniboxInputType::DEPRECATED_REQUESTED_URL:
       return "deprecated-requested-url";
     case metrics::OmniboxInputType::URL:          return "url";
     case metrics::OmniboxInputType::QUERY:        return "query";
     case metrics::OmniboxInputType::FORCED_QUERY: return "forced-query";
   }
   return std::string();
 }
 
 // static
-AutocompleteInput::Type AutocompleteInput::Parse(
+metrics::OmniboxInputType::Type AutocompleteInput::Parse(
     const base::string16& text,
     const base::string16& desired_tld,
     url::Parsed* parts,
     base::string16* scheme,
     GURL* canonicalized_url) {
   size_t first_non_white = text.find_first_not_of(base::kWhitespaceUTF16, 0);
   if (first_non_white == base::string16::npos)
     return metrics::OmniboxInputType::INVALID;  // All whitespace.
 
   if (text[first_non_white] == L'?') {
@@ skipping 74 matching lines @@
 
       default: {
         // We don't know about this scheme.  It might be that the user typed a
         // URL of the form "username:password@foo.com".
         const base::string16 http_scheme_prefix =
             base::ASCIIToUTF16(std::string(url::kHttpScheme) +
                                url::kStandardSchemeSeparator);
         url::Parsed http_parts;
         base::string16 http_scheme;
         GURL http_canonicalized_url;
-        AutocompleteInput::Type http_type =
+        metrics::OmniboxInputType::Type http_type =
             Parse(http_scheme_prefix + text, desired_tld, &http_parts,
                   &http_scheme, &http_canonicalized_url);
         DCHECK_EQ(std::string(url::kHttpScheme),
                   base::UTF16ToUTF8(http_scheme));
 
         if ((http_type == metrics::OmniboxInputType::URL) &&
             http_parts.username.is_nonempty() &&
             http_parts.password.is_nonempty()) {
           // Manually re-jigger the parsed parts to match |text| (without the
           // http scheme added).
@@ skipping 290 matching lines @@
       << "Text: '" << text << "', cp: " << cursor_position;
   text_ = text;
   cursor_position_ = cursor_position;
   parts_ = parts;
 }
 
 void AutocompleteInput::Clear() {
   text_.clear();
   cursor_position_ = base::string16::npos;
   current_url_ = GURL();
-  current_page_classification_ = AutocompleteInput::INVALID_SPEC;
+  current_page_classification_ = metrics::OmniboxEventProto::INVALID_SPEC;
   type_ = metrics::OmniboxInputType::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;
 }