chrome/browser/ui/search/search_ipc_router_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/search/search_ipc_router.h"
   6
   7 #include <vector>
   8
   9 #include "base/command_line.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/metrics/field_trial.h"
  12 #include "base/strings/string16.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/tuple.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/browser/search/search.h"
  17 #include "chrome/browser/search_engines/template_url_service.h"
  18 #include "chrome/browser/search_engines/template_url_service_factory.h"
  19 #include "chrome/browser/ui/search/search_ipc_router_policy_impl.h"
  20 #include "chrome/browser/ui/search/search_tab_helper.h"
  21 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  22 #include "chrome/common/chrome_switches.h"
  23 #include "chrome/common/instant_types.h"
  24 #include "chrome/common/ntp_logging_events.h"
  25 #include "chrome/common/omnibox_focus_state.h"
  26 #include "chrome/common/render_messages.h"
  27 #include "chrome/common/url_constants.h"
  28 #include "chrome/test/base/browser_with_test_window_test.h"
  29 #include "chrome/test/base/ui_test_utils.h"
  30 #include "content/public/browser/navigation_controller.h"
  31 #include "content/public/browser/navigation_entry.h"
  32 #include "content/public/browser/web_contents.h"
  33 #include "content/public/test/mock_render_process_host.h"
  34 #include "ipc/ipc_message.h"
  35 #include "ipc/ipc_test_sink.h"
  36 #include "testing/gmock/include/gmock/gmock.h"
  37 #include "testing/gtest/include/gtest/gtest.h"
  38 #include "ui/base/window_open_disposition.h"
  39 #include "url/gurl.h"
  40
  41 namespace {
  42
  43 class MockSearchIPCRouterDelegate : public SearchIPCRouter::Delegate {
  44  public:
  45   virtual ~MockSearchIPCRouterDelegate() {}
  46
  47   MOCK_METHOD1(OnInstantSupportDetermined, void(bool supports_instant));
  48   MOCK_METHOD1(OnSetVoiceSearchSupport, void(bool supports_voice_search));
  49   MOCK_METHOD1(FocusOmnibox, void(OmniboxFocusState state));
  50   MOCK_METHOD3(NavigateToURL, void(const GURL&, WindowOpenDisposition, bool));
  51   MOCK_METHOD1(OnDeleteMostVisitedItem, void(const GURL& url));
  52   MOCK_METHOD1(OnUndoMostVisitedDeletion, void(const GURL& url));
  53   MOCK_METHOD0(OnUndoAllMostVisitedDeletions, void());
  54   MOCK_METHOD1(OnLogEvent, void(NTPLoggingEventType event));
  55   MOCK_METHOD2(OnLogImpression, void(int position,
  56                                      const base::string16& provider));
  57   MOCK_METHOD1(PasteIntoOmnibox, void(const base::string16&));
  58   MOCK_METHOD1(OnChromeIdentityCheck, void(const base::string16& identity));
  59 };
  60
  61 class MockSearchIPCRouterPolicy : public SearchIPCRouter::Policy {
  62  public:
  63   virtual ~MockSearchIPCRouterPolicy() {}
  64
  65   MOCK_METHOD0(ShouldProcessSetVoiceSearchSupport, bool());
  66   MOCK_METHOD1(ShouldProcessFocusOmnibox, bool(bool));
  67   MOCK_METHOD1(ShouldProcessNavigateToURL, bool(bool));
  68   MOCK_METHOD0(ShouldProcessDeleteMostVisitedItem, bool());
  69   MOCK_METHOD0(ShouldProcessUndoMostVisitedDeletion, bool());
  70   MOCK_METHOD0(ShouldProcessUndoAllMostVisitedDeletions, bool());
  71   MOCK_METHOD0(ShouldProcessLogEvent, bool());
  72   MOCK_METHOD1(ShouldProcessPasteIntoOmnibox, bool(bool));
  73   MOCK_METHOD0(ShouldProcessChromeIdentityCheck, bool());
  74   MOCK_METHOD0(ShouldSendSetPromoInformation, bool());
  75   MOCK_METHOD0(ShouldSendSetDisplayInstantResults, bool());
  76   MOCK_METHOD0(ShouldSendSetSuggestionToPrefetch, bool());
  77   MOCK_METHOD0(ShouldSendSetOmniboxStartMargin, bool());
  78   MOCK_METHOD0(ShouldSendMostVisitedItems, bool());
  79   MOCK_METHOD0(ShouldSendThemeBackgroundInfo, bool());
  80   MOCK_METHOD0(ShouldSendToggleVoiceSearch, bool());
  81   MOCK_METHOD0(ShouldSubmitQuery, bool());
  82 };
  83
  84 }  // namespace
  85
  86 class SearchIPCRouterTest : public BrowserWithTestWindowTest {
  87  public:
  88   SearchIPCRouterTest() : field_trial_list_(NULL) {}
  89
  90   virtual void SetUp() {
  91     BrowserWithTestWindowTest::SetUp();
  92     AddTab(browser(), GURL("chrome://blank"));
  93     SearchTabHelper::CreateForWebContents(web_contents());
  94
  95     TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
  96         profile(),
  97         &TemplateURLServiceFactory::BuildInstanceFor);
  98     TemplateURLService* template_url_service =
  99         TemplateURLServiceFactory::GetForProfile(profile());
 100     ui_test_utils::WaitForTemplateURLServiceToLoad(template_url_service);
 101
 102     TemplateURLData data;
 103     data.SetURL("http://foo.com/url?bar={searchTerms}");
 104     data.instant_url = "http://foo.com/instant?"
 105         "{google:omniboxStartMarginParameter}foo=foo#foo=foo&espv";
 106     data.new_tab_url = "https://foo.com/newtab?espv";
 107     data.alternate_urls.push_back("http://foo.com/alt#quux={searchTerms}");
 108     data.search_terms_replacement_key = "espv";
 109
 110     TemplateURL* template_url = new TemplateURL(profile(), data);
 111     // Takes ownership of |template_url|.
 112     template_url_service->Add(template_url);
 113     template_url_service->SetDefaultSearchProvider(template_url);
 114     process()->sink().ClearMessages();
 115   }
 116
 117   content::WebContents* web_contents() {
 118     return browser()->tab_strip_model()->GetActiveWebContents();
 119   }
 120
 121   content::MockRenderProcessHost* process() {
 122     return static_cast<content::MockRenderProcessHost*>(
 123         web_contents()->GetRenderViewHost()->GetProcess());
 124   }
 125
 126   SearchTabHelper* GetSearchTabHelper(
 127       content::WebContents* web_contents) {
 128     EXPECT_NE(static_cast<content::WebContents*>(NULL), web_contents);
 129     return SearchTabHelper::FromWebContents(web_contents);
 130   }
 131
 132   void SetupMockDelegateAndPolicy() {
 133     content::WebContents* contents = web_contents();
 134     ASSERT_NE(static_cast<content::WebContents*>(NULL), contents);
 135     SearchTabHelper* search_tab_helper = GetSearchTabHelper(contents);
 136     ASSERT_NE(static_cast<SearchTabHelper*>(NULL), search_tab_helper);
 137     search_tab_helper->ipc_router().set_delegate(mock_delegate());
 138     search_tab_helper->ipc_router().set_policy(
 139         make_scoped_ptr(new MockSearchIPCRouterPolicy)
 140             .PassAs<SearchIPCRouter::Policy>());
 141   }
 142
 143   bool MessageWasSent(uint32 id) {
 144     return process()->sink().GetFirstMessageMatching(id) != NULL;
 145   }
 146
 147   void VerifyDisplayInstantResultsMsg(bool expected_param_value) {
 148     SetupMockDelegateAndPolicy();
 149     MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 150     EXPECT_CALL(*policy, ShouldSendSetDisplayInstantResults()).Times(1)
 151         .WillOnce(testing::Return(true));
 152
 153     GetSearchIPCRouter().SetDisplayInstantResults();
 154     const IPC::Message* message = process()->sink().GetFirstMessageMatching(
 155         ChromeViewMsg_SearchBoxSetDisplayInstantResults::ID);
 156     EXPECT_NE(static_cast<const IPC::Message*>(NULL), message);
 157     Tuple1<bool> display_instant_results_param;
 158     ChromeViewMsg_SearchBoxSetDisplayInstantResults::Read(
 159         message, &display_instant_results_param);
 160     EXPECT_EQ(expected_param_value, display_instant_results_param.a);
 161   }
 162
 163   MockSearchIPCRouterDelegate* mock_delegate() { return &delegate_; }
 164
 165   MockSearchIPCRouterPolicy* GetSearchIPCRouterPolicy() {
 166     content::WebContents* contents = web_contents();
 167     EXPECT_NE(static_cast<content::WebContents*>(NULL), contents);
 168     SearchTabHelper* search_tab_helper = GetSearchTabHelper(contents);
 169     EXPECT_NE(static_cast<SearchTabHelper*>(NULL), search_tab_helper);
 170     return static_cast<MockSearchIPCRouterPolicy*>(
 171         search_tab_helper->ipc_router().policy());
 172   }
 173
 174   SearchIPCRouter& GetSearchIPCRouter() {
 175     return GetSearchTabHelper(web_contents())->ipc_router();
 176   }
 177
 178   void OnMessageReceived(const IPC::Message& message) {
 179     GetSearchIPCRouter().OnMessageReceived(message);
 180   }
 181
 182   bool IsActiveTab(content::WebContents* contents) {
 183     return GetSearchTabHelper(contents)->ipc_router().is_active_tab_;
 184   }
 185
 186  private:
 187   MockSearchIPCRouterDelegate delegate_;
 188   base::FieldTrialList field_trial_list_;
 189 };
 190
 191 TEST_F(SearchIPCRouterTest, ProcessVoiceSearchSupportMsg) {
 192   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 193   SetupMockDelegateAndPolicy();
 194   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 195   EXPECT_CALL(*mock_delegate(), OnSetVoiceSearchSupport(true)).Times(1);
 196   EXPECT_CALL(*(policy), ShouldProcessSetVoiceSearchSupport()).Times(1)
 197       .WillOnce(testing::Return(true));
 198
 199   content::WebContents* contents = web_contents();
 200   scoped_ptr<IPC::Message> message(
 201       new ChromeViewHostMsg_SetVoiceSearchSupported(
 202           contents->GetRoutingID(),
 203           contents->GetController().GetVisibleEntry()->GetPageID(),
 204           true));
 205   OnMessageReceived(*message);
 206 }
 207
 208 TEST_F(SearchIPCRouterTest, IgnoreVoiceSearchSupportMsg) {
 209   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 210   EXPECT_CALL(*mock_delegate(), OnSetVoiceSearchSupport(true)).Times(0);
 211   SetupMockDelegateAndPolicy();
 212   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 213   EXPECT_CALL(*policy, ShouldProcessSetVoiceSearchSupport()).Times(1)
 214       .WillOnce(testing::Return(false));
 215
 216   content::WebContents* contents = web_contents();
 217   scoped_ptr<IPC::Message> message(
 218       new ChromeViewHostMsg_SetVoiceSearchSupported(
 219           contents->GetRoutingID(),
 220           contents->GetController().GetVisibleEntry()->GetPageID(),
 221           true));
 222   OnMessageReceived(*message);
 223 }
 224
 225 TEST_F(SearchIPCRouterTest, ProcessFocusOmniboxMsg) {
 226   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 227   SetupMockDelegateAndPolicy();
 228   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 229   EXPECT_CALL(*mock_delegate(), FocusOmnibox(OMNIBOX_FOCUS_VISIBLE)).Times(1);
 230
 231   content::WebContents* contents = web_contents();
 232   bool is_active_tab = IsActiveTab(contents);
 233   EXPECT_TRUE(is_active_tab);
 234   EXPECT_CALL(*policy, ShouldProcessFocusOmnibox(is_active_tab)).Times(1)
 235       .WillOnce(testing::Return(true));
 236
 237   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_FocusOmnibox(
 238       contents->GetRoutingID(),
 239       contents->GetController().GetVisibleEntry()->GetPageID(),
 240       OMNIBOX_FOCUS_VISIBLE));
 241   OnMessageReceived(*message);
 242 }
 243
 244 TEST_F(SearchIPCRouterTest, IgnoreFocusOmniboxMsg) {
 245   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 246   SetupMockDelegateAndPolicy();
 247   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 248   EXPECT_CALL(*mock_delegate(), FocusOmnibox(OMNIBOX_FOCUS_VISIBLE)).Times(0);
 249
 250   content::WebContents* contents = web_contents();
 251   bool is_active_tab = IsActiveTab(contents);
 252   EXPECT_TRUE(is_active_tab);
 253   EXPECT_CALL(*policy, ShouldProcessFocusOmnibox(is_active_tab)).Times(1)
 254       .WillOnce(testing::Return(false));
 255
 256   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_FocusOmnibox(
 257       contents->GetRoutingID(),
 258       contents->GetController().GetVisibleEntry()->GetPageID(),
 259       OMNIBOX_FOCUS_VISIBLE));
 260   OnMessageReceived(*message);
 261 }
 262
 263 TEST_F(SearchIPCRouterTest, HandleTabChangedEvents) {
 264   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 265   content::WebContents* contents = web_contents();
 266   EXPECT_EQ(0, browser()->tab_strip_model()->GetIndexOfWebContents(contents));
 267   EXPECT_TRUE(IsActiveTab(contents));
 268
 269   // Add a new tab to deactivate the current tab.
 270   AddTab(browser(), GURL(content::kAboutBlankURL));
 271   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 272   EXPECT_EQ(1, browser()->tab_strip_model()->GetIndexOfWebContents(contents));
 273   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
 274   EXPECT_FALSE(IsActiveTab(contents));
 275
 276   // Activate the first tab.
 277   browser()->tab_strip_model()->ActivateTabAt(1, false);
 278   EXPECT_EQ(browser()->tab_strip_model()->active_index(),
 279             browser()->tab_strip_model()->GetIndexOfWebContents(contents));
 280   EXPECT_TRUE(IsActiveTab(contents));
 281 }
 282
 283 TEST_F(SearchIPCRouterTest, ProcessNavigateToURLMsg) {
 284   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 285   SetupMockDelegateAndPolicy();
 286   GURL destination_url("www.foo.com");
 287   EXPECT_CALL(*mock_delegate(), NavigateToURL(destination_url, CURRENT_TAB,
 288                                               true)).Times(1);
 289   content::WebContents* contents = web_contents();
 290   bool is_active_tab = IsActiveTab(contents);
 291   EXPECT_TRUE(is_active_tab);
 292
 293   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 294   EXPECT_CALL(*policy, ShouldProcessNavigateToURL(is_active_tab)).Times(1)
 295       .WillOnce(testing::Return(true));
 296
 297   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_SearchBoxNavigate(
 298       contents->GetRoutingID(),
 299       contents->GetController().GetVisibleEntry()->GetPageID(),
 300       destination_url, CURRENT_TAB, true));
 301   OnMessageReceived(*message);
 302 }
 303
 304 TEST_F(SearchIPCRouterTest, IgnoreNavigateToURLMsg) {
 305   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 306   SetupMockDelegateAndPolicy();
 307   GURL destination_url("www.foo.com");
 308   EXPECT_CALL(*mock_delegate(), NavigateToURL(destination_url, CURRENT_TAB,
 309                                               true)).Times(0);
 310   content::WebContents* contents = web_contents();
 311   bool is_active_tab = IsActiveTab(contents);
 312   EXPECT_TRUE(is_active_tab);
 313
 314   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 315   EXPECT_CALL(*policy, ShouldProcessNavigateToURL(is_active_tab)).Times(1)
 316       .WillOnce(testing::Return(false));
 317
 318   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_SearchBoxNavigate(
 319       contents->GetRoutingID(),
 320       contents->GetController().GetVisibleEntry()->GetPageID(),
 321       destination_url, CURRENT_TAB, true));
 322   OnMessageReceived(*message);
 323 }
 324
 325 TEST_F(SearchIPCRouterTest, ProcessLogEventMsg) {
 326   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 327   SetupMockDelegateAndPolicy();
 328   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 329   EXPECT_CALL(*mock_delegate(), OnLogEvent(NTP_MOUSEOVER)).Times(1);
 330   EXPECT_CALL(*policy, ShouldProcessLogEvent()).Times(1)
 331       .WillOnce(testing::Return(true));
 332
 333   content::WebContents* contents = web_contents();
 334   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_LogEvent(
 335       contents->GetRoutingID(),
 336       contents->GetController().GetVisibleEntry()->GetPageID(),
 337       NTP_MOUSEOVER));
 338   OnMessageReceived(*message);
 339 }
 340
 341 TEST_F(SearchIPCRouterTest, IgnoreLogEventMsg) {
 342   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 343   SetupMockDelegateAndPolicy();
 344   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 345   EXPECT_CALL(*mock_delegate(), OnLogEvent(NTP_MOUSEOVER)).Times(0);
 346   EXPECT_CALL(*policy, ShouldProcessLogEvent()).Times(1)
 347       .WillOnce(testing::Return(false));
 348
 349   content::WebContents* contents = web_contents();
 350   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_LogEvent(
 351       contents->GetRoutingID(),
 352       contents->GetController().GetVisibleEntry()->GetPageID(),
 353       NTP_MOUSEOVER));
 354   OnMessageReceived(*message);
 355 }
 356
 357 TEST_F(SearchIPCRouterTest, ProcessLogImpressionMsg) {
 358   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 359   SetupMockDelegateAndPolicy();
 360   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 361   EXPECT_CALL(*mock_delegate(),
 362               OnLogImpression(3, base::ASCIIToUTF16("Server"))).Times(1);
 363   EXPECT_CALL(*policy, ShouldProcessLogEvent()).Times(1)
 364       .WillOnce(testing::Return(true));
 365
 366   content::WebContents* contents = web_contents();
 367   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_LogImpression(
 368       contents->GetRoutingID(),
 369       contents->GetController().GetVisibleEntry()->GetPageID(),
 370       3,
 371       base::ASCIIToUTF16("Server")));
 372   OnMessageReceived(*message);
 373 }
 374
 375 TEST_F(SearchIPCRouterTest, ProcessChromeIdentityCheckMsg) {
 376   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 377   SetupMockDelegateAndPolicy();
 378   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 379   const base::string16 test_identity = base::ASCIIToUTF16("foo@bar.com");
 380   EXPECT_CALL(*mock_delegate(), OnChromeIdentityCheck(test_identity)).Times(1);
 381   EXPECT_CALL(*policy, ShouldProcessChromeIdentityCheck()).Times(1)
 382       .WillOnce(testing::Return(true));
 383
 384   content::WebContents* contents = web_contents();
 385   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_ChromeIdentityCheck(
 386       contents->GetRoutingID(),
 387       contents->GetController().GetVisibleEntry()->GetPageID(),
 388       test_identity));
 389   OnMessageReceived(*message);
 390 }
 391
 392 TEST_F(SearchIPCRouterTest, IgnoreChromeIdentityCheckMsg) {
 393   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 394   SetupMockDelegateAndPolicy();
 395   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 396
 397   const base::string16 test_identity = base::ASCIIToUTF16("foo@bar.com");
 398   EXPECT_CALL(*mock_delegate(), OnChromeIdentityCheck(test_identity)).Times(0);
 399   EXPECT_CALL(*policy, ShouldProcessChromeIdentityCheck()).Times(1)
 400       .WillOnce(testing::Return(false));
 401
 402   content::WebContents* contents = web_contents();
 403   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_ChromeIdentityCheck(
 404       contents->GetRoutingID(),
 405       contents->GetController().GetVisibleEntry()->GetPageID(),
 406       test_identity));
 407   OnMessageReceived(*message);
 408 }
 409
 410 TEST_F(SearchIPCRouterTest, ProcessDeleteMostVisitedItemMsg) {
 411   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 412   SetupMockDelegateAndPolicy();
 413   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 414   GURL item_url("www.foo.com");
 415   EXPECT_CALL(*mock_delegate(), OnDeleteMostVisitedItem(item_url)).Times(1);
 416   EXPECT_CALL(*policy, ShouldProcessDeleteMostVisitedItem()).Times(1)
 417       .WillOnce(testing::Return(true));
 418
 419   content::WebContents* contents = web_contents();
 420   scoped_ptr<IPC::Message> message(
 421       new ChromeViewHostMsg_SearchBoxDeleteMostVisitedItem(
 422           contents->GetRoutingID(),
 423           contents->GetController().GetVisibleEntry()->GetPageID(),
 424           item_url));
 425   OnMessageReceived(*message);
 426 }
 427
 428 TEST_F(SearchIPCRouterTest, IgnoreDeleteMostVisitedItemMsg) {
 429   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 430   SetupMockDelegateAndPolicy();
 431   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 432   GURL item_url("www.foo.com");
 433   EXPECT_CALL(*mock_delegate(), OnDeleteMostVisitedItem(item_url)).Times(0);
 434   EXPECT_CALL(*policy, ShouldProcessDeleteMostVisitedItem()).Times(1)
 435       .WillOnce(testing::Return(false));
 436
 437   content::WebContents* contents = web_contents();
 438   scoped_ptr<IPC::Message> message(
 439       new ChromeViewHostMsg_SearchBoxDeleteMostVisitedItem(
 440           contents->GetRoutingID(),
 441           contents->GetController().GetVisibleEntry()->GetPageID(),
 442           item_url));
 443   OnMessageReceived(*message);
 444 }
 445
 446 TEST_F(SearchIPCRouterTest, ProcessUndoMostVisitedDeletionMsg) {
 447   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 448   SetupMockDelegateAndPolicy();
 449   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 450   GURL item_url("www.foo.com");
 451   EXPECT_CALL(*mock_delegate(), OnUndoMostVisitedDeletion(item_url)).Times(1);
 452   EXPECT_CALL(*policy, ShouldProcessUndoMostVisitedDeletion()).Times(1)
 453       .WillOnce(testing::Return(true));
 454
 455   content::WebContents* contents = web_contents();
 456   scoped_ptr<IPC::Message> message(
 457       new ChromeViewHostMsg_SearchBoxUndoMostVisitedDeletion(
 458           contents->GetRoutingID(),
 459           contents->GetController().GetVisibleEntry()->GetPageID(),
 460           item_url));
 461   OnMessageReceived(*message);
 462 }
 463
 464 TEST_F(SearchIPCRouterTest, IgnoreUndoMostVisitedDeletionMsg) {
 465   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 466   SetupMockDelegateAndPolicy();
 467   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 468   GURL item_url("www.foo.com");
 469   EXPECT_CALL(*mock_delegate(), OnUndoMostVisitedDeletion(item_url)).Times(0);
 470   EXPECT_CALL(*policy, ShouldProcessUndoMostVisitedDeletion()).Times(1)
 471       .WillOnce(testing::Return(false));
 472
 473   content::WebContents* contents = web_contents();
 474   scoped_ptr<IPC::Message> message(
 475       new ChromeViewHostMsg_SearchBoxUndoMostVisitedDeletion(
 476           contents->GetRoutingID(),
 477           contents->GetController().GetVisibleEntry()->GetPageID(),
 478           item_url));
 479   OnMessageReceived(*message);
 480 }
 481
 482 TEST_F(SearchIPCRouterTest, ProcessUndoAllMostVisitedDeletionsMsg) {
 483   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 484   SetupMockDelegateAndPolicy();
 485   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 486   EXPECT_CALL(*mock_delegate(), OnUndoAllMostVisitedDeletions()).Times(1);
 487   EXPECT_CALL(*policy, ShouldProcessUndoAllMostVisitedDeletions()).Times(1)
 488       .WillOnce(testing::Return(true));
 489
 490   content::WebContents* contents = web_contents();
 491   scoped_ptr<IPC::Message> message(
 492       new ChromeViewHostMsg_SearchBoxUndoAllMostVisitedDeletions(
 493           contents->GetRoutingID(),
 494           contents->GetController().GetVisibleEntry()->GetPageID()));
 495   OnMessageReceived(*message);
 496 }
 497
 498 TEST_F(SearchIPCRouterTest, IgnoreUndoAllMostVisitedDeletionsMsg) {
 499   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 500   SetupMockDelegateAndPolicy();
 501   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 502   EXPECT_CALL(*mock_delegate(), OnUndoAllMostVisitedDeletions()).Times(0);
 503   EXPECT_CALL(*policy, ShouldProcessUndoAllMostVisitedDeletions()).Times(1)
 504       .WillOnce(testing::Return(false));
 505
 506   content::WebContents* contents = web_contents();
 507   scoped_ptr<IPC::Message> message(
 508       new ChromeViewHostMsg_SearchBoxUndoAllMostVisitedDeletions(
 509           contents->GetRoutingID(),
 510           contents->GetController().GetVisibleEntry()->GetPageID()));
 511   OnMessageReceived(*message);
 512 }
 513
 514 TEST_F(SearchIPCRouterTest, IgnoreMessageIfThePageIsNotActive) {
 515   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 516   SetupMockDelegateAndPolicy();
 517   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 518
 519   content::WebContents* contents = web_contents();
 520   bool is_active_tab = IsActiveTab(contents);
 521   int invalid_page_id = 1000;
 522   GURL item_url("www.foo.com");
 523   EXPECT_CALL(*mock_delegate(), NavigateToURL(item_url, CURRENT_TAB,
 524                                               true)).Times(0);
 525   EXPECT_CALL(*policy, ShouldProcessNavigateToURL(is_active_tab)).Times(0);
 526
 527   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_SearchBoxNavigate(
 528       contents->GetRoutingID(), invalid_page_id, item_url, CURRENT_TAB,
 529       true));
 530   OnMessageReceived(*message);
 531
 532   EXPECT_CALL(*mock_delegate(), OnDeleteMostVisitedItem(item_url)).Times(0);
 533   EXPECT_CALL(*policy, ShouldProcessDeleteMostVisitedItem()).Times(0);
 534   message.reset(new ChromeViewHostMsg_SearchBoxDeleteMostVisitedItem(
 535       contents->GetRoutingID(), invalid_page_id, item_url));
 536   OnMessageReceived(*message);
 537
 538   EXPECT_CALL(*mock_delegate(), OnUndoMostVisitedDeletion(item_url)).Times(0);
 539   EXPECT_CALL(*policy, ShouldProcessUndoMostVisitedDeletion()).Times(0);
 540   message.reset(new ChromeViewHostMsg_SearchBoxUndoMostVisitedDeletion(
 541       contents->GetRoutingID(), invalid_page_id, item_url));
 542   OnMessageReceived(*message);
 543
 544   EXPECT_CALL(*mock_delegate(), OnUndoAllMostVisitedDeletions()).Times(0);
 545   EXPECT_CALL(*policy, ShouldProcessUndoAllMostVisitedDeletions()).Times(0);
 546   message.reset(new ChromeViewHostMsg_SearchBoxUndoAllMostVisitedDeletions(
 547       contents->GetRoutingID(), invalid_page_id));
 548   OnMessageReceived(*message);
 549
 550   EXPECT_CALL(*mock_delegate(), FocusOmnibox(OMNIBOX_FOCUS_VISIBLE)).Times(0);
 551   EXPECT_CALL(*policy, ShouldProcessFocusOmnibox(is_active_tab)).Times(0);
 552   message.reset(new ChromeViewHostMsg_FocusOmnibox(
 553       contents->GetRoutingID(), invalid_page_id, OMNIBOX_FOCUS_VISIBLE));
 554   OnMessageReceived(*message);
 555
 556   EXPECT_CALL(*mock_delegate(), OnLogEvent(NTP_MOUSEOVER)).Times(0);
 557   EXPECT_CALL(*policy, ShouldProcessLogEvent()).Times(0);
 558   message.reset(new ChromeViewHostMsg_LogEvent(contents->GetRoutingID(),
 559                                                invalid_page_id, NTP_MOUSEOVER));
 560   OnMessageReceived(*message);
 561
 562   base::string16 text;
 563   EXPECT_CALL(*mock_delegate(), PasteIntoOmnibox(text)).Times(0);
 564   EXPECT_CALL(*policy, ShouldProcessPasteIntoOmnibox(is_active_tab)).Times(0);
 565   message.reset(new ChromeViewHostMsg_PasteAndOpenDropdown(
 566       contents->GetRoutingID(), invalid_page_id, text));
 567   OnMessageReceived(*message);
 568 }
 569
 570 TEST_F(SearchIPCRouterTest, ProcessPasteAndOpenDropdownMsg) {
 571   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 572   SetupMockDelegateAndPolicy();
 573   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 574
 575   content::WebContents* contents = web_contents();
 576   bool is_active_tab = IsActiveTab(contents);
 577   EXPECT_TRUE(is_active_tab);
 578
 579   base::string16 text;
 580   EXPECT_CALL(*mock_delegate(), PasteIntoOmnibox(text)).Times(1);
 581   EXPECT_CALL(*policy, ShouldProcessPasteIntoOmnibox(is_active_tab)).Times(1)
 582       .WillOnce(testing::Return(true));
 583   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_PasteAndOpenDropdown(
 584       contents->GetRoutingID(),
 585       contents->GetController().GetVisibleEntry()->GetPageID(), text));
 586   OnMessageReceived(*message);
 587 }
 588
 589 TEST_F(SearchIPCRouterTest, IgnorePasteAndOpenDropdownMsg) {
 590   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 591   SetupMockDelegateAndPolicy();
 592   base::string16 text;
 593   EXPECT_CALL(*mock_delegate(), PasteIntoOmnibox(text)).Times(0);
 594
 595   content::WebContents* contents = web_contents();
 596   bool is_active_tab = IsActiveTab(contents);
 597   EXPECT_TRUE(is_active_tab);
 598
 599   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 600   EXPECT_CALL(*policy, ShouldProcessPasteIntoOmnibox(is_active_tab)).Times(1)
 601       .WillOnce(testing::Return(false));
 602
 603   scoped_ptr<IPC::Message> message(new ChromeViewHostMsg_PasteAndOpenDropdown(
 604       contents->GetRoutingID(),
 605       contents->GetController().GetVisibleEntry()->GetPageID(), text));
 606   OnMessageReceived(*message);
 607 }
 608
 609 TEST_F(SearchIPCRouterTest, SendSetPromoInformationMsg) {
 610   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 611   SetupMockDelegateAndPolicy();
 612   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 613   EXPECT_CALL(*policy, ShouldSendSetPromoInformation()).Times(1)
 614       .WillOnce(testing::Return(true));
 615
 616   GetSearchIPCRouter().SetPromoInformation(true);
 617   EXPECT_TRUE(MessageWasSent(ChromeViewMsg_SearchBoxPromoInformation::ID));
 618 }
 619
 620 TEST_F(SearchIPCRouterTest, DoNotSendSetPromoInformationMsg) {
 621   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 622   SetupMockDelegateAndPolicy();
 623   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 624   EXPECT_CALL(*policy, ShouldSendSetPromoInformation()).Times(1)
 625       .WillOnce(testing::Return(false));
 626
 627   GetSearchIPCRouter().SetPromoInformation(false);
 628   EXPECT_FALSE(MessageWasSent(ChromeViewMsg_SearchBoxPromoInformation::ID));
 629 }
 630
 631 TEST_F(SearchIPCRouterTest,
 632        SendSetDisplayInstantResultsMsg_EnableInstantOnResultsPage) {
 633   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
 634       "EmbeddedSearch",
 635       "Group1 espv:42 query_extraction:1 prefetch_results_srp:1"));
 636   NavigateAndCommitActiveTab(GURL("https://foo.com/url?espv&bar=abc"));
 637
 638   // Make sure ChromeViewMsg_SearchBoxSetDisplayInstantResults message param is
 639   // set to true if the underlying page is a results page and
 640   // "prefetch_results_srp" flag is enabled via field trials.
 641   VerifyDisplayInstantResultsMsg(true);
 642 }
 643
 644 TEST_F(SearchIPCRouterTest,
 645        SendSetDisplayInstantResultsMsg_DisableInstantOnResultsPage) {
 646   // |prefetch_results_srp" flag is disabled via field trials.
 647   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
 648       "EmbeddedSearch", "Group1 espv:42 prefetch_results_srp:0"));
 649   NavigateAndCommitActiveTab(GURL("https://foo.com/url?espv&bar=abc"));
 650
 651   // Make sure ChromeViewMsg_SearchBoxSetDisplayInstantResults message param is
 652   // set to false.
 653   VerifyDisplayInstantResultsMsg(false);
 654 }
 655
 656 TEST_F(SearchIPCRouterTest,
 657        SendSetDisplayInstantResultsMsg_DisableInstantOutsideResultsPage) {
 658   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
 659       "EmbeddedSearch", "Group1 espv:42 prefetch_results_srp:1"));
 660   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 661
 662   // Make sure ChromeViewMsg_SearchBoxSetDisplayInstantResults param is set to
 663   // false if the underlying page is not a search results page.
 664   VerifyDisplayInstantResultsMsg(false);
 665 }
 666
 667 TEST_F(SearchIPCRouterTest,
 668        SendSetDisplayInstantResultsMsg_InstantSearchEnabled) {
 669   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
 670       "EmbeddedSearch",
 671       "Group1 espv:42 prefetch_results:1 use_cacheable_ntp:1"));
 672   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 673
 674   // If the "prefetch_results" flag is enabled via field trials, then
 675   // ChromeViewMsg_SearchBoxSetDisplayInstantResults message param is set to
 676   // true irrespective of the underlying page.
 677   VerifyDisplayInstantResultsMsg(true);
 678 }
 679
 680 TEST_F(SearchIPCRouterTest,
 681        SendSetDisplayInstantResultsMsg_InstantSearchDisabled) {
 682   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
 683       "EmbeddedSearch",
 684       "Group1 espv:42 use_cacheable_ntp:1 prefetch_results:0"));
 685   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 686
 687   // Make sure ChromeViewMsg_SearchBoxSetDisplayInstantResults param is set to
 688   // false if the "prefetch_results" flag is disabled via field trials.
 689   VerifyDisplayInstantResultsMsg(false);
 690 }
 691
 692 TEST_F(SearchIPCRouterTest, DoNotSendSetDisplayInstantResultsMsg) {
 693   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 694   SetupMockDelegateAndPolicy();
 695   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 696   EXPECT_CALL(*policy, ShouldSendSetDisplayInstantResults()).Times(1)
 697       .WillOnce(testing::Return(false));
 698
 699   process()->sink().ClearMessages();
 700   GetSearchIPCRouter().SetDisplayInstantResults();
 701   EXPECT_FALSE(MessageWasSent(
 702       ChromeViewMsg_SearchBoxSetDisplayInstantResults::ID));
 703 }
 704
 705 TEST_F(SearchIPCRouterTest, SendSetSuggestionToPrefetch) {
 706   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 707   SetupMockDelegateAndPolicy();
 708   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 709   EXPECT_CALL(*policy, ShouldSendSetSuggestionToPrefetch()).Times(1)
 710       .WillOnce(testing::Return(true));
 711
 712   process()->sink().ClearMessages();
 713   content::WebContents* contents = web_contents();
 714   GetSearchTabHelper(contents)->SetSuggestionToPrefetch(InstantSuggestion());
 715   EXPECT_TRUE(MessageWasSent(
 716       ChromeViewMsg_SearchBoxSetSuggestionToPrefetch::ID));
 717 }
 718
 719 TEST_F(SearchIPCRouterTest, DoNotSendSetSuggestionToPrefetch) {
 720   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 721   SetupMockDelegateAndPolicy();
 722   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 723   EXPECT_CALL(*policy, ShouldSendSetSuggestionToPrefetch()).Times(1)
 724       .WillOnce(testing::Return(false));
 725
 726   process()->sink().ClearMessages();
 727   content::WebContents* contents = web_contents();
 728   GetSearchTabHelper(contents)->SetSuggestionToPrefetch(InstantSuggestion());
 729   EXPECT_FALSE(MessageWasSent(
 730       ChromeViewMsg_SearchBoxSetSuggestionToPrefetch::ID));
 731 }
 732
 733 TEST_F(SearchIPCRouterTest, SendSetOmniboxStartMargin) {
 734   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 735   SetupMockDelegateAndPolicy();
 736   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 737   EXPECT_CALL(*policy, ShouldSendSetOmniboxStartMargin()).Times(1)
 738       .WillOnce(testing::Return(true));
 739
 740   process()->sink().ClearMessages();
 741   GetSearchIPCRouter().SetOmniboxStartMargin(92);
 742   EXPECT_TRUE(MessageWasSent(ChromeViewMsg_SearchBoxMarginChange::ID));
 743 }
 744
 745 TEST_F(SearchIPCRouterTest, DoNotSendSetOmniboxStartMargin) {
 746   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 747   SetupMockDelegateAndPolicy();
 748   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 749   EXPECT_CALL(*policy, ShouldSendSetOmniboxStartMargin()).Times(1)
 750       .WillOnce(testing::Return(false));
 751
 752   process()->sink().ClearMessages();
 753   GetSearchIPCRouter().SetOmniboxStartMargin(92);
 754   EXPECT_FALSE(MessageWasSent(ChromeViewMsg_SearchBoxMarginChange::ID));
 755 }
 756
 757 TEST_F(SearchIPCRouterTest, SendMostVisitedItemsMsg) {
 758   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 759   SetupMockDelegateAndPolicy();
 760   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 761   EXPECT_CALL(*policy, ShouldSendMostVisitedItems()).Times(1)
 762       .WillOnce(testing::Return(true));
 763
 764   process()->sink().ClearMessages();
 765   GetSearchIPCRouter().SendMostVisitedItems(
 766       std::vector<InstantMostVisitedItem>());
 767   EXPECT_TRUE(MessageWasSent(
 768       ChromeViewMsg_SearchBoxMostVisitedItemsChanged::ID));
 769 }
 770
 771 TEST_F(SearchIPCRouterTest, DoNotSendMostVisitedItemsMsg) {
 772   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 773   SetupMockDelegateAndPolicy();
 774   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 775   EXPECT_CALL(*policy, ShouldSendMostVisitedItems()).Times(1)
 776       .WillOnce(testing::Return(false));
 777
 778   process()->sink().ClearMessages();
 779   GetSearchIPCRouter().SendMostVisitedItems(
 780       std::vector<InstantMostVisitedItem>());
 781   EXPECT_FALSE(MessageWasSent(
 782       ChromeViewMsg_SearchBoxMostVisitedItemsChanged::ID));
 783 }
 784
 785 TEST_F(SearchIPCRouterTest, SendThemeBackgroundInfoMsg) {
 786   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 787   SetupMockDelegateAndPolicy();
 788   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 789   EXPECT_CALL(*policy, ShouldSendThemeBackgroundInfo()).Times(1)
 790       .WillOnce(testing::Return(true));
 791
 792   process()->sink().ClearMessages();
 793   GetSearchIPCRouter().SendThemeBackgroundInfo(ThemeBackgroundInfo());
 794   EXPECT_TRUE(MessageWasSent(ChromeViewMsg_SearchBoxThemeChanged::ID));
 795 }
 796
 797 TEST_F(SearchIPCRouterTest, DoNotSendThemeBackgroundInfoMsg) {
 798   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 799   SetupMockDelegateAndPolicy();
 800   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 801   EXPECT_CALL(*policy, ShouldSendThemeBackgroundInfo()).Times(1)
 802       .WillOnce(testing::Return(false));
 803
 804   process()->sink().ClearMessages();
 805   GetSearchIPCRouter().SendThemeBackgroundInfo(ThemeBackgroundInfo());
 806   EXPECT_FALSE(MessageWasSent(ChromeViewMsg_SearchBoxThemeChanged::ID));
 807 }
 808
 809 TEST_F(SearchIPCRouterTest, SendSubmitMsg) {
 810   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 811   SetupMockDelegateAndPolicy();
 812   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 813   EXPECT_CALL(*policy, ShouldSubmitQuery()).Times(1)
 814       .WillOnce(testing::Return(true));
 815
 816   process()->sink().ClearMessages();
 817   GetSearchIPCRouter().Submit(base::string16());
 818   EXPECT_TRUE(MessageWasSent(ChromeViewMsg_SearchBoxSubmit::ID));
 819 }
 820
 821 TEST_F(SearchIPCRouterTest, DoNotSendSubmitMsg) {
 822   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
 823   SetupMockDelegateAndPolicy();
 824   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 825   EXPECT_CALL(*policy, ShouldSubmitQuery()).Times(1)
 826       .WillOnce(testing::Return(false));
 827
 828   process()->sink().ClearMessages();
 829   GetSearchIPCRouter().Submit(base::string16());
 830   EXPECT_FALSE(MessageWasSent(ChromeViewMsg_SearchBoxSubmit::ID));
 831 }
 832
 833 TEST_F(SearchIPCRouterTest, SendToggleVoiceSearch) {
 834   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 835   SetupMockDelegateAndPolicy();
 836   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 837   EXPECT_CALL(*policy, ShouldSendToggleVoiceSearch()).Times(1)
 838       .WillOnce(testing::Return(true));
 839
 840   process()->sink().ClearMessages();
 841   GetSearchIPCRouter().ToggleVoiceSearch();
 842   EXPECT_TRUE(MessageWasSent(ChromeViewMsg_SearchBoxToggleVoiceSearch::ID));
 843 }
 844
 845 TEST_F(SearchIPCRouterTest, DoNotSendToggleVoiceSearch) {
 846   NavigateAndCommitActiveTab(GURL("chrome-search://foo/bar"));
 847   SetupMockDelegateAndPolicy();
 848   MockSearchIPCRouterPolicy* policy = GetSearchIPCRouterPolicy();
 849   EXPECT_CALL(*policy, ShouldSendToggleVoiceSearch()).Times(1)
 850       .WillOnce(testing::Return(false));
 851
 852   process()->sink().ClearMessages();
 853   GetSearchIPCRouter().ToggleVoiceSearch();
 854   EXPECT_FALSE(MessageWasSent(ChromeViewMsg_SearchBoxToggleVoiceSearch::ID));
 855 }