Add title to current page in zero suggest.

components/omnibox/browser/bookmark_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 "components/omnibox/browser/bookmark_provider.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 261 matching lines @@
     {"foo foobar",            1, {{{0, 6}, {7, 13}, {0, 0}}}},
     // This ensures that leading whitespace in the title is not removed.
     {"hello",                 1, {{{1, 6}, {9, 14}, {0, 0}}}},
     // This ensures that empty titles yield empty classifications.
     {"emptytitle",            1, {}},
   };
 
   for (size_t i = 0; i < arraysize(query_data); ++i) {
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, std::string(), GURL(),
+                            base::string16(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true, false, TestSchemeClassifier());
     provider_->Start(input, false);
     const ACMatches& matches(provider_->matches());
     // Validate number of results is as expected.
     EXPECT_LE(matches.size(), query_data[i].match_count)
         << "One or more of the following matches were unexpected:\n"
         << MatchesAsString16(matches)
         << "For query '" << query_data[i].query << "'.";
     EXPECT_GE(matches.size(), query_data[i].match_count)
@@ skipping 60 matching lines @@
                       "burning worms #2"}},  // not boosted
     // A query of "worm burn" will have the same results.
     {"worm burn", 3, {"burning worms #1",    // boosted
                       "worming burns #10",   // boosted but longer title
                       "burning worms #2"}},  // not boosted
   };
 
   for (size_t i = 0; i < arraysize(query_data); ++i) {
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, std::string(), GURL(),
+                            base::string16(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true, false, TestSchemeClassifier());
     provider_->Start(input, false);
     const ACMatches& matches(provider_->matches());
     // Validate number and content of results is as expected.
     for (size_t j = 0; j < std::max(query_data[i].match_count, matches.size());
          ++j) {
       EXPECT_LT(j, query_data[i].match_count) << "    Unexpected match '"
           << base::UTF16ToUTF8(matches[j].description) << "' for query: '"
           <<  query_data[i].query << "'.";
@@ skipping 36 matching lines @@
     // need to be in the bookmarks list because BookmarkProvider's
     // TitleMatchToACMatch() has an assertion that verifies the URL is
     // actually bookmarked.
   };
 
   for (size_t i = 0; i < arraysize(query_data); ++i) {
     const std::string description = "for query=" + query_data[i].query +
         " and url=" + query_data[i].url;
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, std::string(), GURL(),
+                            base::string16(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true, false, TestSchemeClassifier());
     const base::string16 fixed_up_input(
         provider_->FixupUserInput(input).second);
     BookmarkNode node(GURL(query_data[i].url));
     node.SetTitle(base::ASCIIToUTF16(query_data[i].url));
     TitledUrlMatch bookmark_match;
     bookmark_match.node = &node;
     int relevance = provider_->CalculateBookmarkMatchRelevance(bookmark_match);
     const AutocompleteMatch& ac_match = TitledUrlMatchToAutocompleteMatch(
@@ skipping 24 matching lines @@
     { "dom http",  "http://www.domain.com/http/",
       "0:3,4:1,11:3,14:1,22:3,26:1"                                      },
     { "rep",       "www.repeat.com/1/repeat/2/", "0:1,4:3,7:1,17:3,20:1" },
     { "versi",     "chrome://version",           "0:1,9:3,14:1"          }
   };
 
   for (size_t i = 0; i < arraysize(query_data); ++i) {
     std::string description = "for query=" + query_data[i].query;
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, std::string(), GURL(),
+                            base::string16(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true, false, TestSchemeClassifier());
     provider_->Start(input, false);
     const ACMatches& matches(provider_->matches());
     ASSERT_EQ(1U, matches.size()) << description;
     const AutocompleteMatch& match = matches[0];
     EXPECT_EQ(base::ASCIIToUTF16(query_data[i].expected_contents),
               match.contents) << description;
     std::vector<std::string> class_strings = base::SplitString(
         query_data[i].expected_contents_class, ",",
         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     ASSERT_EQ(class_strings.size(), match.contents_class.size())
         << description;
     for (size_t i = 0; i < class_strings.size(); ++i) {
       std::vector<std::string> chunks = base::SplitString(
           class_strings[i], ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       ASSERT_EQ(2U, chunks.size()) << description;
       size_t offset;
       EXPECT_TRUE(base::StringToSizeT(chunks[0], &offset)) << description;
       EXPECT_EQ(offset, match.contents_class[i].offset) << description;
       int style;
       EXPECT_TRUE(base::StringToInt(chunks[1], &style)) << description;
       EXPECT_EQ(style, match.contents_class[i].style) << description;
     }
   }
 }
 
 TEST_F(BookmarkProviderTest, DoesNotProvideMatchesOnFocus) {
   AutocompleteInput input(base::ASCIIToUTF16("foo"), base::string16::npos,
-                          std::string(), GURL(),
+                          std::string(), GURL(), base::string16(),
                           metrics::OmniboxEventProto::INVALID_SPEC, false,
                           false, false, true, true, TestSchemeClassifier());
   provider_->Start(input, false);
   EXPECT_TRUE(provider_->matches().empty());
 }