1// Copyright (c) 2012 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/browser_command_controller.h"
6
7#include "base/command_line.h"
8#include "chrome/app/chrome_command_ids.h"
9#include "chrome/browser/browser_process.h"
10#include "chrome/browser/command_updater.h"
11#include "chrome/browser/prefs/incognito_mode_prefs.h"
12#include "chrome/browser/profiles/profile_manager.h"
13#include "chrome/browser/profiles/profiles_state.h"
14#include "chrome/browser/ui/browser.h"
15#include "chrome/browser/ui/browser_commands.h"
16#include "chrome/browser/ui/browser_window_state.h"
17#include "chrome/common/chrome_switches.h"
18#include "chrome/common/pref_names.h"
19#include "chrome/test/base/browser_with_test_window_test.h"
20#include "chrome/test/base/test_browser_window.h"
21#include "chrome/test/base/testing_browser_process.h"
22#include "chrome/test/base/testing_profile.h"
23#include "chrome/test/base/testing_profile_manager.h"
24#include "components/signin/core/common/profile_management_switches.h"
25#include "content/public/browser/native_web_keyboard_event.h"
26#include "ui/events/keycodes/keyboard_codes.h"
27
28typedef BrowserWithTestWindowTest BrowserCommandControllerTest;
29
30TEST_F(BrowserCommandControllerTest, IsReservedCommandOrKey) {
31#if defined(OS_CHROMEOS)
32  // F1-3 keys are reserved Chrome accelerators on Chrome OS.
33  EXPECT_TRUE(browser()->command_controller()->IsReservedCommandOrKey(
34      IDC_BACK, content::NativeWebKeyboardEvent(
35          ui::ET_KEY_PRESSED, false, ui::VKEY_BROWSER_BACK, 0, 0)));
36  EXPECT_TRUE(browser()->command_controller()->IsReservedCommandOrKey(
37      IDC_FORWARD, content::NativeWebKeyboardEvent(
38          ui::ET_KEY_PRESSED, false, ui::VKEY_BROWSER_FORWARD, 0, 0)));
39  EXPECT_TRUE(browser()->command_controller()->IsReservedCommandOrKey(
40      IDC_RELOAD, content::NativeWebKeyboardEvent(
41          ui::ET_KEY_PRESSED, false, ui::VKEY_BROWSER_REFRESH, 0, 0)));
42
43  // When there are modifier keys pressed, don't reserve.
44  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
45      IDC_RELOAD_IGNORING_CACHE, content::NativeWebKeyboardEvent(
46          ui::ET_KEY_PRESSED, false, ui::VKEY_F3, ui::EF_SHIFT_DOWN, 0)));
47  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
48      IDC_RELOAD_IGNORING_CACHE, content::NativeWebKeyboardEvent(
49          ui::ET_KEY_PRESSED, false, ui::VKEY_F3, ui::EF_CONTROL_DOWN, 0)));
50  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
51      IDC_FULLSCREEN, content::NativeWebKeyboardEvent(
52          ui::ET_KEY_PRESSED, false, ui::VKEY_F4, ui::EF_SHIFT_DOWN, 0)));
53
54  // F4-10 keys are not reserved since they are Ash accelerators.
55  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
56      -1, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
57                                          ui::VKEY_F4, 0, 0)));
58  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
59      -1, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
60                                          ui::VKEY_F5, 0, 0)));
61  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
62      -1, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
63                                          ui::VKEY_F6, 0, 0)));
64  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
65      -1, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
66                                          ui::VKEY_F7, 0, 0)));
67  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
68      -1, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
69                                          ui::VKEY_F8, 0, 0)));
70  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
71      -1, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
72                                          ui::VKEY_F9, 0, 0)));
73  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
74      -1, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
75                                          ui::VKEY_F10, 0, 0)));
76
77  // Shift+Control+Alt+F3 is also an Ash accelerator. Don't reserve it.
78  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
79      -1, content::NativeWebKeyboardEvent(
80          ui::ET_KEY_PRESSED, false,
81          ui::VKEY_F3,
82          ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, 0)));
83#endif  // OS_CHROMEOS
84
85#if defined(USE_AURA)
86  // Ctrl+n, Ctrl+w are reserved while Ctrl+f is not.
87
88  // The content::NativeWebKeyboardEvent constructor is available only when
89  // USE_AURA is #defined.
90  EXPECT_TRUE(browser()->command_controller()->IsReservedCommandOrKey(
91      IDC_NEW_WINDOW, content::NativeWebKeyboardEvent(
92          ui::ET_KEY_PRESSED, false, ui::VKEY_N, ui::EF_CONTROL_DOWN, 0)));
93  EXPECT_TRUE(browser()->command_controller()->IsReservedCommandOrKey(
94      IDC_CLOSE_TAB, content::NativeWebKeyboardEvent(
95          ui::ET_KEY_PRESSED, false, ui::VKEY_W, ui::EF_CONTROL_DOWN, 0)));
96  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
97      IDC_FIND, content::NativeWebKeyboardEvent(
98          ui::ET_KEY_PRESSED, false, ui::VKEY_F, ui::EF_CONTROL_DOWN, 0)));
99#endif  // USE_AURA
100}
101
102TEST_F(BrowserCommandControllerTest, IsReservedCommandOrKeyIsApp) {
103  browser()->app_name_ = "app";
104  ASSERT_TRUE(browser()->is_app());
105
106  // When is_app(), no keys are reserved.
107#if defined(OS_CHROMEOS)
108  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
109      IDC_BACK, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
110                                                ui::VKEY_F1, 0, 0)));
111  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
112      IDC_FORWARD, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
113                                                   ui::VKEY_F2, 0, 0)));
114  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
115      IDC_RELOAD, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
116                                                  ui::VKEY_F3, 0, 0)));
117  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
118      -1, content::NativeWebKeyboardEvent(ui::ET_KEY_PRESSED, false,
119                                          ui::VKEY_F4, 0, 0)));
120#endif  // OS_CHROMEOS
121
122#if defined(USE_AURA)
123  // The content::NativeWebKeyboardEvent constructor is available only when
124  // USE_AURA is #defined.
125  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
126      IDC_NEW_WINDOW, content::NativeWebKeyboardEvent(
127          ui::ET_KEY_PRESSED, false, ui::VKEY_N, ui::EF_CONTROL_DOWN, 0)));
128  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
129      IDC_CLOSE_TAB, content::NativeWebKeyboardEvent(
130          ui::ET_KEY_PRESSED, false, ui::VKEY_W, ui::EF_CONTROL_DOWN, 0)));
131  EXPECT_FALSE(browser()->command_controller()->IsReservedCommandOrKey(
132      IDC_FIND, content::NativeWebKeyboardEvent(
133          ui::ET_KEY_PRESSED, false, ui::VKEY_F, ui::EF_CONTROL_DOWN, 0)));
134#endif  // USE_AURA
135}
136
137TEST_F(BrowserCommandControllerTest, IncognitoCommands) {
138  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_OPTIONS));
139  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_IMPORT_SETTINGS));
140  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_SHOW_SIGNIN));
141
142  TestingProfile* testprofile = browser()->profile()->AsTestingProfile();
143  EXPECT_TRUE(testprofile);
144  testprofile->SetGuestSession(true);
145  chrome::BrowserCommandController
146    ::UpdateSharedCommandsForIncognitoAvailability(
147      browser()->command_controller()->command_updater(), testprofile);
148  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_OPTIONS));
149  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_IMPORT_SETTINGS));
150  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_SHOW_SIGNIN));
151
152  testprofile->SetGuestSession(false);
153  IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(),
154                                      IncognitoModePrefs::FORCED);
155  chrome::BrowserCommandController
156    ::UpdateSharedCommandsForIncognitoAvailability(
157      browser()->command_controller()->command_updater(), testprofile);
158  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_OPTIONS));
159  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_IMPORT_SETTINGS));
160  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_SHOW_SIGNIN));
161}
162
163TEST_F(BrowserCommandControllerTest, AppFullScreen) {
164  // Enable for tabbed browser.
165  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FULLSCREEN));
166
167  // Enabled for app windows.
168  browser()->app_name_ = "app";
169  ASSERT_TRUE(browser()->is_app());
170  browser()->command_controller()->FullscreenStateChanged();
171  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FULLSCREEN));
172}
173
174TEST_F(BrowserCommandControllerTest, OldAvatarMenuEnabledForOneOrMoreProfiles) {
175  if (!profiles::IsMultipleProfilesEnabled())
176    return;
177
178  // The command line is reset at the end of every test by the test suite.
179  switches::DisableNewAvatarMenuForTesting(CommandLine::ForCurrentProcess());
180  ASSERT_FALSE(switches::IsNewAvatarMenu());
181
182  TestingProfileManager testing_profile_manager(
183      TestingBrowserProcess::GetGlobal());
184  ASSERT_TRUE(testing_profile_manager.SetUp());
185  ProfileManager* profile_manager = testing_profile_manager.profile_manager();
186
187  chrome::BrowserCommandController command_controller(browser());
188  const CommandUpdater* command_updater = command_controller.command_updater();
189
190  bool enabled = true;
191#if defined(OS_CHROMEOS)
192  // Chrome OS uses system tray menu to handle multi-profiles.
193  enabled = false;
194#endif
195
196  testing_profile_manager.CreateTestingProfile("p1");
197  ASSERT_EQ(1U, profile_manager->GetNumberOfProfiles());
198  EXPECT_EQ(enabled, command_updater->IsCommandEnabled(IDC_SHOW_AVATAR_MENU));
199
200  testing_profile_manager.CreateTestingProfile("p2");
201  ASSERT_EQ(2U, profile_manager->GetNumberOfProfiles());
202  EXPECT_EQ(enabled, command_updater->IsCommandEnabled(IDC_SHOW_AVATAR_MENU));
203
204  testing_profile_manager.DeleteTestingProfile("p1");
205  ASSERT_EQ(1U, profile_manager->GetNumberOfProfiles());
206  EXPECT_EQ(enabled, command_updater->IsCommandEnabled(IDC_SHOW_AVATAR_MENU));
207
208  testing_profile_manager.DeleteTestingProfile("p2");
209}
210
211TEST_F(BrowserCommandControllerTest, NewAvatarMenuEnabledWhenOnlyOneProfile) {
212  if (!profiles::IsMultipleProfilesEnabled())
213    return;
214
215  // The command line is reset at the end of every test by the test suite.
216  switches::EnableNewAvatarMenuForTesting(CommandLine::ForCurrentProcess());
217
218  TestingProfileManager testing_profile_manager(
219      TestingBrowserProcess::GetGlobal());
220  ASSERT_TRUE(testing_profile_manager.SetUp());
221  ProfileManager* profile_manager = testing_profile_manager.profile_manager();
222
223  chrome::BrowserCommandController command_controller(browser());
224  const CommandUpdater* command_updater = command_controller.command_updater();
225
226  testing_profile_manager.CreateTestingProfile("p1");
227  ASSERT_EQ(1U, profile_manager->GetNumberOfProfiles());
228#if defined(OS_CHROMEOS)
229  // Chrome OS uses system tray menu to handle multi-profiles.
230  EXPECT_FALSE(command_updater->IsCommandEnabled(IDC_SHOW_AVATAR_MENU));
231#else
232  EXPECT_TRUE(command_updater->IsCommandEnabled(IDC_SHOW_AVATAR_MENU));
233#endif
234  testing_profile_manager.DeleteTestingProfile("p1");
235}
236
237TEST_F(BrowserCommandControllerTest, NewAvatarMenuEnabledInGuestMode) {
238  if (!profiles::IsMultipleProfilesEnabled())
239    return;
240
241  // The command line is reset at the end of every test by the test suite.
242  switches::EnableNewAvatarMenuForTesting(CommandLine::ForCurrentProcess());
243
244  TestingProfileManager testing_profile_manager(
245      TestingBrowserProcess::GetGlobal());
246  ASSERT_TRUE(testing_profile_manager.SetUp());
247
248  // Set up guest a profile.
249  scoped_ptr<TestingProfile> original_profile =
250      TestingProfile::Builder().Build();
251  TestingProfile::Builder guest_builder;
252  guest_builder.SetGuestSession();
253  guest_builder.SetPath(ProfileManager::GetGuestProfilePath());
254  // Browsers in Guest mode must be off the record profiles.
255  TestingProfile* guest_profile =
256      guest_builder.BuildIncognito(original_profile.get());
257
258  ASSERT_TRUE(guest_profile->IsGuestSession());
259
260  // Create a new browser based on the guest profile.
261  Browser::CreateParams profile_params(guest_profile,
262                                       chrome::GetActiveDesktop());
263  scoped_ptr<Browser> guest_browser(
264      chrome::CreateBrowserWithTestWindowForParams(&profile_params));
265  chrome::BrowserCommandController command_controller(guest_browser.get());
266  const CommandUpdater* command_updater = command_controller.command_updater();
267#if defined(OS_CHROMEOS)
268  // Chrome OS uses system tray menu to handle multi-profiles.
269  EXPECT_FALSE(command_updater->IsCommandEnabled(IDC_SHOW_AVATAR_MENU));
270#else
271  EXPECT_TRUE(command_updater->IsCommandEnabled(IDC_SHOW_AVATAR_MENU));
272#endif
273}
274
275TEST_F(BrowserCommandControllerTest, AvatarMenuAlwaysDisabledInIncognitoMode) {
276  if (!profiles::IsMultipleProfilesEnabled())
277    return;
278
279  // Set up a profile with an off the record profile.
280  TestingProfile::Builder normal_builder;
281  scoped_ptr<TestingProfile> original_profile = normal_builder.Build();
282
283  // Create a new browser based on the off the record profile.
284  Browser::CreateParams profile_params(
285      original_profile->GetOffTheRecordProfile(), chrome::GetActiveDesktop());
286  scoped_ptr<Browser> otr_browser(
287      chrome::CreateBrowserWithTestWindowForParams(&profile_params));
288
289  chrome::BrowserCommandController command_controller(otr_browser.get());
290  const CommandUpdater* command_updater = command_controller.command_updater();
291
292  // Both the old style and the new style avatar menu should be disabled.
293  EXPECT_FALSE(command_updater->IsCommandEnabled(IDC_SHOW_AVATAR_MENU));
294  if (switches::IsNewAvatarMenu()) {
295    switches::DisableNewAvatarMenuForTesting(CommandLine::ForCurrentProcess());
296  } else {
297    switches::EnableNewAvatarMenuForTesting(CommandLine::ForCurrentProcess());
298  }
299  EXPECT_FALSE(command_updater->IsCommandEnabled(IDC_SHOW_AVATAR_MENU));
300  // The command line is reset at the end of every test by the test suite.
301}
302
303//////////////////////////////////////////////////////////////////////////////
304
305// A test browser window that can toggle fullscreen state.
306class FullscreenTestBrowserWindow : public TestBrowserWindow {
307 public:
308  FullscreenTestBrowserWindow() : fullscreen_(false) {}
309  virtual ~FullscreenTestBrowserWindow() {}
310
311  // TestBrowserWindow overrides:
312  virtual bool ShouldHideUIForFullscreen() const OVERRIDE {
313    return fullscreen_;
314  }
315  virtual bool IsFullscreen() const OVERRIDE {
316    return fullscreen_;
317  }
318  virtual void EnterFullscreen(
319      const GURL& url, FullscreenExitBubbleType type) OVERRIDE {
320    fullscreen_ = true;
321  }
322  virtual void ExitFullscreen() OVERRIDE {
323    fullscreen_ = false;
324  }
325
326 private:
327  bool fullscreen_;
328
329  DISALLOW_COPY_AND_ASSIGN(FullscreenTestBrowserWindow);
330};
331
332// Test that uses FullscreenTestBrowserWindow for its window.
333class BrowserCommandControllerFullscreenTest
334    : public BrowserWithTestWindowTest {
335 public:
336  BrowserCommandControllerFullscreenTest() {}
337  virtual ~BrowserCommandControllerFullscreenTest() {}
338
339  // BrowserWithTestWindowTest overrides:
340  virtual BrowserWindow* CreateBrowserWindow() OVERRIDE {
341    return new FullscreenTestBrowserWindow;
342  }
343
344 private:
345  DISALLOW_COPY_AND_ASSIGN(BrowserCommandControllerFullscreenTest);
346};
347
348TEST_F(BrowserCommandControllerFullscreenTest,
349       UpdateCommandsForFullscreenMode) {
350  // Defaults for a tabbed browser.
351  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_OPEN_CURRENT_URL));
352  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_SHOW_AS_TAB));
353  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_TOOLBAR));
354  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_LOCATION));
355  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_SEARCH));
356  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_MENU_BAR));
357  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_NEXT_PANE));
358  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_PREVIOUS_PANE));
359  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_BOOKMARKS));
360  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_DEVELOPER_MENU));
361#if defined(GOOGLE_CHROME_BUILD)
362  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FEEDBACK));
363#endif
364  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_OPTIONS));
365  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_IMPORT_SETTINGS));
366  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_EDIT_SEARCH_ENGINES));
367  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_VIEW_PASSWORDS));
368  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_ABOUT));
369  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_SHOW_APP_MENU));
370  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FULLSCREEN));
371
372  // Simulate going fullscreen.
373  chrome::ToggleFullscreenMode(browser());
374  ASSERT_TRUE(browser()->window()->IsFullscreen());
375  browser()->command_controller()->FullscreenStateChanged();
376
377  // Most commands are disabled in fullscreen.
378  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_OPEN_CURRENT_URL));
379  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_SHOW_AS_TAB));
380  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_TOOLBAR));
381  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_LOCATION));
382  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_SEARCH));
383  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_MENU_BAR));
384  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_NEXT_PANE));
385  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_PREVIOUS_PANE));
386  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_BOOKMARKS));
387  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_DEVELOPER_MENU));
388#if defined(GOOGLE_CHROME_BUILD)
389  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_FEEDBACK));
390#endif
391  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_OPTIONS));
392  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_IMPORT_SETTINGS));
393  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_EDIT_SEARCH_ENGINES));
394  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_VIEW_PASSWORDS));
395  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_ABOUT));
396  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_SHOW_APP_MENU));
397  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FULLSCREEN));
398
399  // Exit fullscreen.
400  chrome::ToggleFullscreenMode(browser());
401  ASSERT_FALSE(browser()->window()->IsFullscreen());
402  browser()->command_controller()->FullscreenStateChanged();
403  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_OPEN_CURRENT_URL));
404  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_SHOW_AS_TAB));
405  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_TOOLBAR));
406  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_LOCATION));
407  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_SEARCH));
408  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_MENU_BAR));
409  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_NEXT_PANE));
410  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_PREVIOUS_PANE));
411  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FOCUS_BOOKMARKS));
412  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_DEVELOPER_MENU));
413#if defined(GOOGLE_CHROME_BUILD)
414  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FEEDBACK));
415#endif
416  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_OPTIONS));
417  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_IMPORT_SETTINGS));
418  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_EDIT_SEARCH_ENGINES));
419  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_VIEW_PASSWORDS));
420  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_ABOUT));
421  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_SHOW_APP_MENU));
422  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_FULLSCREEN));
423
424  // Guest Profiles disallow some options.
425  TestingProfile* testprofile = browser()->profile()->AsTestingProfile();
426  EXPECT_TRUE(testprofile);
427  testprofile->SetGuestSession(true);
428
429  browser()->command_controller()->FullscreenStateChanged();
430  EXPECT_TRUE(chrome::IsCommandEnabled(browser(), IDC_OPTIONS));
431  EXPECT_FALSE(chrome::IsCommandEnabled(browser(), IDC_IMPORT_SETTINGS));
432}
433
434TEST_F(BrowserCommandControllerTest, IncognitoModeOnSigninAllowedPrefChange) {
435  // Set up a profile with an off the record profile.
436  scoped_ptr<TestingProfile> profile1 = TestingProfile::Builder().Build();
437  Profile* profile2 = profile1->GetOffTheRecordProfile();
438
439  EXPECT_EQ(profile2->GetOriginalProfile(), profile1.get());
440
441  // Create a new browser based on the off the record profile.
442  Browser::CreateParams profile_params(profile1->GetOffTheRecordProfile(),
443                                       chrome::GetActiveDesktop());
444  scoped_ptr<Browser> browser2(
445      chrome::CreateBrowserWithTestWindowForParams(&profile_params));
446
447  chrome::BrowserCommandController command_controller(browser2.get());
448  const CommandUpdater* command_updater = command_controller.command_updater();
449
450  // Check that the SYNC_SETUP command is updated on preference change.
451  EXPECT_TRUE(command_updater->IsCommandEnabled(IDC_SHOW_SYNC_SETUP));
452  profile1->GetPrefs()->SetBoolean(prefs::kSigninAllowed, false);
453  EXPECT_FALSE(command_updater->IsCommandEnabled(IDC_SHOW_SYNC_SETUP));
454}
455
456TEST_F(BrowserCommandControllerTest, OnSigninAllowedPrefChange) {
457  chrome::BrowserCommandController command_controller(browser());
458  const CommandUpdater* command_updater = command_controller.command_updater();
459
460  // Check that the SYNC_SETUP command is updated on preference change.
461  EXPECT_TRUE(command_updater->IsCommandEnabled(IDC_SHOW_SYNC_SETUP));
462  profile()->GetPrefs()->SetBoolean(prefs::kSigninAllowed, false);
463  EXPECT_FALSE(command_updater->IsCommandEnabled(IDC_SHOW_SYNC_SETUP));
464}
465