[AiS] Merge answers into highest-scoring result

components/omnibox/base_search_provider_unittest.cc

+// Copyright 2014 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/base_search_provider.h"
+
+#include "base/strings/string16.h"
+#include "base/strings/utf_string_conversions.h"
+#include "components/omnibox/autocomplete_match.h"
+#include "components/omnibox/autocomplete_match_type.h"
+#include "components/omnibox/autocomplete_provider_client.h"
+#include "components/omnibox/autocomplete_scheme_classifier.h"
+#include "components/omnibox/search_suggestion_parser.h"
+#include "components/search_engines/search_terms_data.h"
+#include "components/search_engines/template_url_service.h"
+#include "components/search_engines/template_url_service_client.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::NiceMock;
+using testing::Return;
+using testing::_;
+
+class MockAutocompleteProviderClient : public AutocompleteProviderClient {
+ public:
+  MockAutocompleteProviderClient() {}
+  MOCK_METHOD0(RequestContext, net::URLRequestContextGetter*());
+  MOCK_METHOD0(IsOffTheRecord, bool());
+  MOCK_METHOD0(AcceptLanguages, std::string());
+  MOCK_METHOD0(SearchSuggestEnabled, bool());
+  MOCK_METHOD0(ShowBookmarkBar, bool());
+  MOCK_METHOD0(SchemeClassifier, const AutocompleteSchemeClassifier&());
+  MOCK_METHOD6(
+      Classify,
+      void(const base::string16& text,
+           bool prefer_keyword,
+           bool allow_exact_keyword_match,
+           metrics::OmniboxEventProto::PageClassification page_classification,
+           AutocompleteMatch* match,
+           GURL* alternate_nav_url));
+  MOCK_METHOD0(InMemoryDatabase, history::URLDatabase*());
+  MOCK_METHOD2(DeleteMatchingURLsForKeywordFromHistory,
+               void(history::KeywordID keyword_id, const base::string16& term));
+  MOCK_METHOD0(TabSyncEnabledAndUnencrypted, bool());
+  MOCK_METHOD1(PrefetchImage, void(const GURL& url));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockAutocompleteProviderClient);
+};
+
+class TestBaseSearchProvider : public BaseSearchProvider {
+ public:
+  typedef BaseSearchProvider::MatchMap MatchMap;
+
+  // Note: Takes ownership of client. scoped_ptr<> would be the right way to
+  // express that, but NiceMock<> can't forward a scoped_ptr.
+  TestBaseSearchProvider(TemplateURLService* template_url_service,
+                         AutocompleteProviderClient* client,
+                         AutocompleteProvider::Type type)
+      : BaseSearchProvider(template_url_service,
+                           scoped_ptr<AutocompleteProviderClient>(client),
+                           type) {}
+  MOCK_METHOD1(DeleteMatch, void(const AutocompleteMatch& match));
+  MOCK_CONST_METHOD1(AddProviderInfo, void(ProvidersInfo* provider_info));
+  MOCK_CONST_METHOD1(GetTemplateURL, const TemplateURL*(bool is_keyword));
+  MOCK_CONST_METHOD1(GetInput, const AutocompleteInput(bool is_keyword));
+  MOCK_CONST_METHOD1(ShouldAppendExtraParams,
+                     bool(const SearchSuggestionParser::SuggestResult& result));
+  MOCK_METHOD1(RecordDeletionResult, void(bool success));
+
+  MOCK_METHOD2(Start,
+               void(const AutocompleteInput& input, bool minimal_changes));
+  void AddMatchToMap(const SearchSuggestionParser::SuggestResult& result,
+                     const std::string& metadata,
+                     int accepted_suggestion,
+                     bool mark_as_deletable,
+                     bool in_keyword_mode,
+                     MatchMap* map) {
+    BaseSearchProvider::AddMatchToMap(result,
+                                      metadata,
+                                      accepted_suggestion,
+                                      mark_as_deletable,
+                                      in_keyword_mode,
+                                      map);
+  }
+
+ protected:
+  virtual ~TestBaseSearchProvider() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestBaseSearchProvider);
+};
+
+class BaseSearchProviderTest : public testing::Test {
+ public:
+  virtual ~BaseSearchProviderTest() {}
+
+ protected:
+  virtual void SetUp() {
+    service_.reset(new TemplateURLService(
+        NULL,
+        scoped_ptr<SearchTermsData>(new SearchTermsData),
+        NULL,
+        scoped_ptr<TemplateURLServiceClient>(),

[Mark P, 2014/09/22 23:54:06]

Not sure about style considerations, but if this is () is the same as passing in
NULL, please do it explicitly.

[groby-ooo-7-16, 2014/09/23 03:34:00]

It is not, unfortunately - the ctor wants a scoped_ptr, not NULL. And you can't
pass NULL to a scoped_ptr without casting, which looks somewhat ridiculous:
 
scoped_ptr<TemplateURLServiceClient>(reinterpret_cast<TemplateURLServiceClient>(NULL));

std::nullptr can't come soon enough :)

+        NULL,
+        NULL,
+        base::Closure()));
+    provider_ = new NiceMock<TestBaseSearchProvider>(
+        service_.get(),
+        new NiceMock<MockAutocompleteProviderClient>,
+        AutocompleteProvider::TYPE_SEARCH);
+  }
+
+  scoped_refptr<NiceMock<TestBaseSearchProvider> > provider_;
+  scoped_ptr<TemplateURLService> service_;
+};
+
+TEST_F(BaseSearchProviderTest, PreserveAnswersWhenDeduplicating) {
+  TemplateURLData data;
+  data.SetURL("http://foo.com/url?bar={searchTerms}");
+  TemplateURL* template_url = new TemplateURL(data);
+
+  TestBaseSearchProvider::MatchMap map;
+  base::string16 query = base::ASCIIToUTF16("weather los angeles");
+  base::string16 answer_contents = base::ASCIIToUTF16("some answer content");
+  base::string16 answer_type = base::ASCIIToUTF16("2334");
+
+  EXPECT_CALL(*provider_, GetInput(_))
+      .WillRepeatedly(Return(AutocompleteInput()));
+  EXPECT_CALL(*provider_, GetTemplateURL(_))
+      .WillRepeatedly(Return(template_url));
+
+  SearchSuggestionParser::SuggestResult more_relevant(
+      query, AutocompleteMatchType::SEARCH_HISTORY, query, base::string16(),
+      base::string16(), base::string16(), base::string16(), std::string(),
+      std::string(), false, 1300, true, false, query);
+  provider_->AddMatchToMap(
+      more_relevant, std::string(), TemplateURLRef::NO_SUGGESTION_CHOSEN,
+      false, false, &map);
+
+  SearchSuggestionParser::SuggestResult less_relevant(
+      query, AutocompleteMatchType::SEARCH_SUGGEST, query, base::string16(),
+      base::string16(), answer_contents, answer_type, std::string(),
+      std::string(), false, 850, true, false, query);
+  provider_->AddMatchToMap(
+      less_relevant, std::string(), TemplateURLRef::NO_SUGGESTION_CHOSEN,
+      false, false, &map);
+
+  ASSERT_EQ(1U, map.size());
+  AutocompleteMatch match = map.begin()->second;
+  ASSERT_EQ(1U, match.duplicate_matches.size());
+  AutocompleteMatch duplicate = match.duplicate_matches[0];
+
+  EXPECT_EQ(answer_contents, match.answer_contents);
+  EXPECT_EQ(answer_type, match.answer_type);
+  EXPECT_EQ(AutocompleteMatchType::SEARCH_HISTORY, match.type);
+  EXPECT_EQ(1300, match.relevance);
+
+  EXPECT_EQ(answer_contents, duplicate.answer_contents);
+  EXPECT_EQ(answer_type, duplicate.answer_type);
+  EXPECT_EQ(AutocompleteMatchType::SEARCH_SUGGEST, duplicate.type);
+  EXPECT_EQ(850, duplicate.relevance);
+}