Stop depending on InstantService from BaseSearchProvider

components/search_engines/template_url_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 "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
@@ skipping 12 matching lines @@
  public:
   explicit TestSearchTermsData(const std::string& google_base_url);
 
   virtual std::string GoogleBaseURLValue() const OVERRIDE;
   virtual base::string16 GetRlzParameterValue(
       bool from_app_list) const OVERRIDE;
   virtual std::string GetSearchClient() const OVERRIDE;
   virtual std::string GoogleImageSearchSource() const OVERRIDE;
   virtual bool EnableAnswersInSuggest() const OVERRIDE;
   virtual bool IsShowingSearchTermsOnSearchResultsPages() const OVERRIDE;
+  virtual int OmniboxStartMargin() const OVERRIDE;
 
   void set_google_base_url(const std::string& google_base_url) {
     google_base_url_ = google_base_url;
   }
   void set_search_client(const std::string& search_client) {
     search_client_ = search_client;
   }
   void set_enable_answers_in_suggest(bool enable_answers_in_suggest) {
     enable_answers_in_suggest_ = enable_answers_in_suggest;
   }
   void set_is_showing_search_terms_on_search_results_pages(bool value) {
     is_showing_search_terms_on_search_results_pages_ = value;
   }
+  void set_omnibox_start_margin(int omnibox_start_margin) {
+    omnibox_start_margin_ = omnibox_start_margin;
+  }
 
  private:
   std::string google_base_url_;
   std::string search_client_;
   bool enable_answers_in_suggest_;
   bool is_showing_search_terms_on_search_results_pages_;
+  int omnibox_start_margin_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSearchTermsData);
 };
 
 TestSearchTermsData::TestSearchTermsData(const std::string& google_base_url)
     : google_base_url_(google_base_url),
       enable_answers_in_suggest_(false),
       is_showing_search_terms_on_search_results_pages_(false) {
 }
 
@@ skipping 16 matching lines @@
 }
 
 bool TestSearchTermsData::EnableAnswersInSuggest() const {
   return enable_answers_in_suggest_;
 }
 
 bool TestSearchTermsData::IsShowingSearchTermsOnSearchResultsPages() const {
   return is_showing_search_terms_on_search_results_pages_;
 }
 
+int TestSearchTermsData::OmniboxStartMargin() const {
+  return omnibox_start_margin_;
+}
+
 // TemplateURLTest ------------------------------------------------------------
 
 class TemplateURLTest : public testing::Test {
  public:
   TemplateURLTest() : search_terms_data_("http://www.google.com/") {}
   void CheckSuggestBaseURL(const std::string& base_url,
                            const std::string& base_suggest_url) const;
 
   TestSearchTermsData search_terms_data_;
 };
@@ skipping 600 matching lines @@
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.current_page_url = test_data[i].current_page_url;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
 }
 
+TEST_F(TemplateURLTest, OmniboxStartmargin) {
+  struct TestData {
+    const bool enable_omnibox_start_margin;
+    const int omnibox_start_margin;
+    const std::string expected_result;
+  } test_data[] = {
+    { false,
+      0,
+      "http://bar/foo?q=foobar" },
+    { true,
+      0,
+      "http://bar/foo?es_sm=0&q=foobar" },
+    { true,
+      42,
+      "http://bar/foo?es_sm=42&q=foobar" },
+  };
+  TemplateURLData data;
+  data.SetURL("http://bar/foo?{google:omniboxStartMarginParameter}"
+              "q={searchTerms}");
+  data.input_encodings.push_back("UTF-8");
+  TemplateURL url(data);
+  EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
+  ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+    TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foobar"));
+    search_terms_args.enable_omnibox_start_margin =
+        test_data[i].enable_omnibox_start_margin;
+    search_terms_data_.set_omnibox_start_margin(
+        test_data[i].omnibox_start_margin);
+    GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
+                                                 search_terms_data_));
+    ASSERT_TRUE(result.is_valid());
+    EXPECT_EQ(test_data[i].expected_result, result.spec());
+  }
+}
+
 TEST_F(TemplateURLTest, Suggestions) {
   struct TestData {
     const int accepted_suggestion;
     const base::string16 original_query_for_suggestion;
     const std::string expected_result;
   } test_data[] = {
     { TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, base::string16(),
       "http://bar/foo?q=foobar" },
     { TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, ASCIIToUTF16("foo"),
       "http://bar/foo?q=foobar" },
@@ skipping 812 matching lines @@
   EXPECT_EQ("http://bar/search?q=foo&pfq=full%20query%20text&qha=2338&xssi=t",
             result);
 
   TemplateURL url2(data);
   search_terms_args.prefetch_query.clear();
   search_terms_args.prefetch_query_type.clear();
   result =
       url2.url_ref().ReplaceSearchTerms(search_terms_args, search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&xssi=t", result);
 }