Remove AutocompleteInput Type and PageClassification.

chrome/browser/autocomplete/autocomplete_input_unittest.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/basictypes.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/url_parse.h"
 
 using base::ASCIIToUTF16;
+using metrics::OmniboxEventProto;
 
 TEST(AutocompleteInputTest, InputType) {
   struct test_data {
     const base::string16 input;
-    const AutocompleteInput::Type type;
+    const metrics::OmniboxInputType::Type type;
   } input_cases[] = {
     { base::string16(), metrics::OmniboxInputType::INVALID },
     { ASCIIToUTF16("?"), metrics::OmniboxInputType::FORCED_QUERY },
     { ASCIIToUTF16("?foo"), metrics::OmniboxInputType::FORCED_QUERY },
     { ASCIIToUTF16("?foo bar"), metrics::OmniboxInputType::FORCED_QUERY },
     { ASCIIToUTF16("?http://foo.com/bar"), metrics::OmniboxInputType::FORCED_QUERY },
     { ASCIIToUTF16("foo"), metrics::OmniboxInputType::UNKNOWN },
     { ASCIIToUTF16("localhost"), metrics::OmniboxInputType::URL },
     { ASCIIToUTF16("foo.c"), metrics::OmniboxInputType::UNKNOWN },
     { ASCIIToUTF16("foo.com"), metrics::OmniboxInputType::URL },
@@ skipping 102 matching lines @@
     { ASCIIToUTF16("chrome-devtools:"), metrics::OmniboxInputType::QUERY },
     { ASCIIToUTF16("about://f;"), metrics::OmniboxInputType::QUERY },
     { ASCIIToUTF16("://w"), metrics::OmniboxInputType::QUERY },
     { ASCIIToUTF16(":w"), metrics::OmniboxInputType::QUERY },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
     SCOPED_TRACE(input_cases[i].input);
     AutocompleteInput input(input_cases[i].input, base::string16::npos,
                             base::string16(), GURL(),
-                            AutocompleteInput::INVALID_SPEC, true, false, true,
+                            OmniboxEventProto::INVALID_SPEC, true, false, true,
                             true);
     EXPECT_EQ(input_cases[i].type, input.type());
   }
 }
 
 TEST(AutocompleteInputTest, InputTypeWithDesiredTLD) {
   struct test_data {
     const base::string16 input;
-    const AutocompleteInput::Type type;
+    const metrics::OmniboxInputType::Type type;
     const std::string spec;  // Unused if not a URL.
   } input_cases[] = {
     { ASCIIToUTF16("401k"), metrics::OmniboxInputType::URL,
         std::string("http://www.401k.com/") },
     { ASCIIToUTF16("999999999999999"), metrics::OmniboxInputType::URL,
         std::string("http://www.999999999999999.com/") },
     { ASCIIToUTF16("x@y"), metrics::OmniboxInputType::URL,
         std::string("http://x@www.y.com/") },
     { ASCIIToUTF16("y/z z"), metrics::OmniboxInputType::URL,
         std::string("http://www.y.com/z%20z") },
     { ASCIIToUTF16("abc.com"), metrics::OmniboxInputType::URL,
         std::string("http://abc.com/") },
     { ASCIIToUTF16("foo bar"), metrics::OmniboxInputType::QUERY,
         std::string() },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
     SCOPED_TRACE(input_cases[i].input);
     AutocompleteInput input(input_cases[i].input, base::string16::npos,
                             ASCIIToUTF16("com"), GURL(),
-                            AutocompleteInput::INVALID_SPEC, true, false, true,
+                            OmniboxEventProto::INVALID_SPEC, true, false, true,
                             true);
     EXPECT_EQ(input_cases[i].type, input.type());
     if (input_cases[i].type == metrics::OmniboxInputType::URL)
       EXPECT_EQ(input_cases[i].spec, input.canonicalized_url().spec());
   }
 }
 
 // This tests for a regression where certain input in the omnibox caused us to
 // crash. As long as the test completes without crashing, we're fine.
 TEST(AutocompleteInputTest, InputCrash) {
   AutocompleteInput input(base::WideToUTF16(L"\uff65@s"), base::string16::npos,
                           base::string16(), GURL(),
-                          AutocompleteInput::INVALID_SPEC, true, false,
+                          OmniboxEventProto::INVALID_SPEC, true, false,
                           true, true);
 }
 
 TEST(AutocompleteInputTest, ParseForEmphasizeComponent) {
   using url::Component;
   Component kInvalidComponent(0, -1);
   struct test_data {
     const base::string16 input;
     const Component scheme;
     const Component host;
@@ skipping 23 matching lines @@
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
     SCOPED_TRACE(input_cases[i].input);
     Component scheme, host;
     AutocompleteInput::ParseForEmphasizeComponents(input_cases[i].input,
                                                    &scheme,
                                                    &host);
     AutocompleteInput input(input_cases[i].input, base::string16::npos,
                             base::string16(), GURL(),
-                            AutocompleteInput::INVALID_SPEC, true,
+                            OmniboxEventProto::INVALID_SPEC, true,
                             false, true, true);
     EXPECT_EQ(input_cases[i].scheme.begin, scheme.begin);
     EXPECT_EQ(input_cases[i].scheme.len, scheme.len);
     EXPECT_EQ(input_cases[i].host.begin, host.begin);
     EXPECT_EQ(input_cases[i].host.len, host.len);
   }
 }
 
 TEST(AutocompleteInputTest, InputTypeWithCursorPosition) {
   struct test_data {
@@ skipping 18 matching lines @@
     { ASCIIToUTF16("  ?foo bar"), 4, ASCIIToUTF16("foo bar"), 1 },
     { ASCIIToUTF16("?  foo bar"), 4, ASCIIToUTF16("foo bar"), 1 },
     { ASCIIToUTF16("  ?  foo bar"), 6, ASCIIToUTF16("foo bar"), 1 },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
     SCOPED_TRACE(input_cases[i].input);
     AutocompleteInput input(input_cases[i].input,
                             input_cases[i].cursor_position,
                             base::string16(), GURL(),
-                            AutocompleteInput::INVALID_SPEC,
+                            OmniboxEventProto::INVALID_SPEC,
                             true, false, true, true);
     EXPECT_EQ(input_cases[i].normalized_input, input.text());
     EXPECT_EQ(input_cases[i].normalized_cursor_position,
               input.cursor_position());
   }
 }