Omnibox: Change |inline_autocomplete_offset| to |inline_autocompletion|

chrome/browser/autocomplete/history_url_provider_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/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/message_loop.h"
 #include "base/path_service.h"
@@ skipping 165 matching lines @@
   void RunTest(const string16 text,
                const string16& desired_tld,
                bool prevent_inline_autocomplete,
                const std::string* expected_urls,
                size_t num_results) {
     AutocompleteInput::Type type;
     return RunTest(text, desired_tld, prevent_inline_autocomplete,
                    expected_urls, num_results, &type);
   }
 
-  void RunAdjustOffsetTest(const string16 text, size_t expected_offset);
-
   content::TestBrowserThreadBundle thread_bundle_;
   ACMatches matches_;
   scoped_ptr<TestingProfile> profile_;
   HistoryService* history_service_;
   scoped_refptr<HistoryURLProvider> autocomplete_;
   // Should the matches be sorted and duplicates removed?
   bool sort_matches_;
 };
 
 class HistoryURLProviderTestNoDB : public HistoryURLProviderTest {
@@ skipping 81 matching lines @@
                    matches_.end());
     std::sort(matches_.begin(), matches_.end(),
               &AutocompleteMatch::MoreRelevant);
   }
   ASSERT_EQ(num_results, matches_.size()) << "Input text: " << text
                                           << "\nTLD: \"" << desired_tld << "\"";
   for (size_t i = 0; i < num_results; ++i)
     EXPECT_EQ(expected_urls[i], matches_[i].destination_url.spec());
 }
 
-void HistoryURLProviderTest::RunAdjustOffsetTest(const string16 text,
-                                                 size_t expected_offset) {
-  AutocompleteInput input(text, string16::npos, string16(), GURL(), false,
-                          false, true, AutocompleteInput::ALL_MATCHES);
-  autocomplete_->Start(input, false);
-  if (!autocomplete_->done())
-    base::MessageLoop::current()->Run();
-
-  matches_ = autocomplete_->matches();
-  ASSERT_GE(matches_.size(), 1U) << "Input text: " << text;
-  EXPECT_EQ(expected_offset, matches_[0].inline_autocomplete_offset);
-}
-
 TEST_F(HistoryURLProviderTest, PromoteShorterURLs) {
   // Test that hosts get synthesized below popular pages.
   const std::string expected_nonsynth[] = {
     "http://slashdot.org/favorite_page.html",
     "http://slashdot.org/",
   };
   RunTest(ASCIIToUTF16("slash"), string16(), true, expected_nonsynth,
           arraysize(expected_nonsynth));
 
   // Test that hosts get synthesized above less popular pages.
@@ skipping 171 matching lines @@
   RunTest(WideToUTF16(L"\uff65@s"), string16(), false, fixup_crash,
           arraysize(fixup_crash));
   RunTest(WideToUTF16(L"\u2015\u2015@ \uff7c"), string16(), false, NULL, 0);
 
   // Fixing up "file:" should result in an inline autocomplete offset of just
   // after "file:", not just after "file://".
   const string16 input_1(ASCIIToUTF16("file:"));
   const std::string fixup_1[] = {"file:///C:/foo.txt"};
   ASSERT_NO_FATAL_FAILURE(RunTest(input_1, string16(), false, fixup_1,
                                   arraysize(fixup_1)));
-  EXPECT_EQ(input_1.length(), matches_.front().inline_autocomplete_offset);
+  EXPECT_EQ(ASCIIToUTF16("///C:/foo.txt"),
+            matches_.front().inline_autocompletion);
 
   // Fixing up "http:/" should result in an inline autocomplete offset of just
   // after "http:/", not just after "http:".
   const string16 input_2(ASCIIToUTF16("http:/"));
   const std::string fixup_2[] = {
     "http://bogussite.com/a",
     "http://bogussite.com/b",
     "http://bogussite.com/c",
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(input_2, string16(), false, fixup_2,
                                   arraysize(fixup_2)));
-  EXPECT_EQ(input_2.length(), matches_.front().inline_autocomplete_offset);
+  EXPECT_EQ(ASCIIToUTF16("/bogussite.com/a"),
+            matches_.front().inline_autocompletion);
 
   // Adding a TLD to a small number like "56" should result in "www.56.com"
   // rather than "0.0.0.56.com".
   const std::string fixup_3[] = {"http://www.56.com/"};
   RunTest(ASCIIToUTF16("56"), ASCIIToUTF16("com"), true, fixup_3,
           arraysize(fixup_3));
 
   // An input looks like a IP address like "127.0.0.1" should result in
   // "http://127.0.0.1/".
   const std::string fixup_4[] = {"http://127.0.0.1/"};
   RunTest(ASCIIToUTF16("127.0.0.1"), string16(), false, fixup_4,
           arraysize(fixup_4));
 
   // An number "17173" should result in "http://www.17173.com/" in db.
   const std::string fixup_5[] = {"http://www.17173.com/"};
   RunTest(ASCIIToUTF16("17173"), string16(), false, fixup_5,
           arraysize(fixup_5));
 }
 
-TEST_F(HistoryURLProviderTest, AdjustOffset) {
-  RunAdjustOffsetTest(WideToUTF16(L"http://www.\uAD50\uC721"), 13);
-  RunAdjustOffsetTest(ASCIIToUTF16("http://spaces.com/path%20with%20spa"), 31);
-  RunAdjustOffsetTest(ASCIIToUTF16("http://ms/c++ s"), 15);
-}
-
 // Make sure the results for the input 'p' don't change between the first and
 // second passes.
 TEST_F(HistoryURLProviderTest, EmptyVisits) {
   // Wait for history to create the in memory DB.
   profile_->BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteInput input(ASCIIToUTF16("p"), string16::npos, string16(), GURL(),
                           false, false, true, AutocompleteInput::ALL_MATCHES);
   autocomplete_->Start(input, false);
   // HistoryURLProvider shouldn't be done (waiting on async results).
@@ skipping 32 matching lines @@
   AutocompleteInput input(ASCIIToUTF16("slash "), string16::npos, string16(),
                           GURL(), false, false, true,
                           AutocompleteInput::ALL_MATCHES);
   autocomplete_->Start(input, false);
   if (!autocomplete_->done())
     base::MessageLoop::current()->Run();
 
   // None of the matches should attempt to autocomplete.
   matches_ = autocomplete_->matches();
   for (size_t i = 0; i < matches_.size(); ++i)
-    EXPECT_EQ(string16::npos, matches_[i].inline_autocomplete_offset);
+    EXPECT_TRUE(matches_[i].inline_autocompletion.empty());
 }
 
 TEST_F(HistoryURLProviderTest, TreatEmailsAsSearches) {
   // Visiting foo.com should not make this string be treated as a navigation.
   // That means the result should be scored around 1200 ("what you typed")
   // and not 1400+.
   const std::string expected[] = {"http://user@foo.com/"};
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("user@foo.com"), string16(),
                                   false, expected, arraysize(expected)));
   EXPECT_LE(1200, matches_[0].relevance);
@@ skipping 269 matching lines @@
       EXPECT_EQ(test_cases[i].offsets[match_index],
                 match.contents_class[match_index].offset);
       EXPECT_EQ(ACMatchClassification::URL |
                 (match_index == test_cases[i].match_classification_index ?
                  ACMatchClassification::MATCH : 0),
                 match.contents_class[match_index].style);
     }
     EXPECT_EQ(npos, test_cases[i].offsets[match.contents_class.size()]);
   }
 }