chrome/browser/tab_contents/spellchecker_submenu_observer_browsertest.cc

   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/tab_contents/spellchecker_submenu_observer.h"
   6
   7 #include "base/prefs/pref_service.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "chrome/app/chrome_command_ids.h"
  10 #include "chrome/browser/tab_contents/render_view_context_menu.h"
  11 #include "chrome/browser/tab_contents/render_view_context_menu_observer.h"
  12 #include "chrome/common/pref_names.h"
  13 #include "chrome/test/base/in_process_browser_test.h"
  14 #include "chrome/test/base/testing_profile.h"
  15
  16 using content::RenderViewHost;
  17 using content::WebContents;
  18
  19 namespace {
  20
  21 // A mock context menu used in this test. This class overrides virtual methods
  22 // derived from the RenderViewContextMenuProxy class to monitor calls from the
  23 // SpellingMenuObserver class.
  24 class MockRenderViewContextMenu : public ui::SimpleMenuModel::Delegate,
  25                                   public RenderViewContextMenuProxy {
  26  public:
  27   // A menu item used in this test.
  28   struct MockMenuItem {
  29     MockMenuItem()
  30         : command_id(0),
  31           enabled(false),
  32           checked(false),
  33           hidden(true) {}
  34     int command_id;
  35     bool enabled;
  36     bool checked;
  37     bool hidden;
  38     base::string16 title;
  39   };
  40
  41   MockRenderViewContextMenu() : observer_(NULL), profile_(new TestingProfile) {}
  42   virtual ~MockRenderViewContextMenu() {}
  43
  44   // SimpleMenuModel::Delegate implementation.
  45   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE {
  46     return observer_->IsCommandIdChecked(command_id);
  47   }
  48   virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE {
  49     return observer_->IsCommandIdEnabled(command_id);
  50   }
  51   virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE {
  52     observer_->ExecuteCommand(command_id);
  53   }
  54   virtual void MenuWillShow(ui::SimpleMenuModel* source) OVERRIDE {}
  55   virtual void MenuClosed(ui::SimpleMenuModel* source) OVERRIDE {}
  56   virtual bool GetAcceleratorForCommandId(
  57       int command_id,
  58       ui::Accelerator* accelerator) OVERRIDE {
  59     return false;
  60   }
  61
  62   // RenderViewContextMenuProxy implementation.
  63   virtual void AddMenuItem(int command_id,
  64                            const base::string16& title) OVERRIDE {}
  65   virtual void AddCheckItem(int command_id,
  66                             const base::string16& title) OVERRIDE {}
  67   virtual void AddSeparator() OVERRIDE {}
  68   virtual void AddSubMenu(int command_id,
  69                           const base::string16& label,
  70                           ui::MenuModel* model) OVERRIDE {}
  71   virtual void UpdateMenuItem(int command_id,
  72                               bool enabled,
  73                               bool hidden,
  74                               const base::string16& title) OVERRIDE {}
  75   virtual RenderViewHost* GetRenderViewHost() const OVERRIDE {
  76     return NULL;
  77   }
  78   virtual Profile* GetProfile() const OVERRIDE {
  79     return profile_.get();
  80   }
  81   virtual content::WebContents* GetWebContents() const OVERRIDE {
  82     return NULL;
  83   }
  84
  85   // Attaches a RenderViewContextMenuObserver to be tested.
  86   void SetObserver(RenderViewContextMenuObserver* observer) {
  87     observer_ = observer;
  88   }
  89
  90   // Returns the number of items added by the test.
  91   size_t GetMenuSize() const {
  92     return 0;
  93   }
  94
  95   // Returns the i-th item.
  96   bool GetMenuItem(size_t i, MockMenuItem* item) const {
  97     return false;
  98   }
  99
 100   // Returns the writable profile used in this test.
 101   PrefService* GetPrefs() {
 102     return profile_->GetPrefs();
 103   }
 104
 105  private:
 106   // An observer used for initializing the status of menu items added in this
 107   // test. This is a weak pointer, the test is responsible for deleting this
 108   // object.
 109   RenderViewContextMenuObserver* observer_;
 110
 111   // A dummy profile used in this test. Call GetPrefs() when a test needs to
 112   // change this profile and use PrefService methods.
 113   scoped_ptr<TestingProfile> profile_;
 114
 115   DISALLOW_COPY_AND_ASSIGN(MockRenderViewContextMenu);
 116 };
 117
 118 // A test class used in this file. This test should be a browser test because it
 119 // accesses resources.
 120 class SpellCheckerSubMenuObserverTest : public InProcessBrowserTest {
 121  public:
 122   SpellCheckerSubMenuObserverTest() {}
 123   virtual ~SpellCheckerSubMenuObserverTest() {}
 124
 125  private:
 126   DISALLOW_COPY_AND_ASSIGN(SpellCheckerSubMenuObserverTest);
 127 };
 128
 129 }  // namespace
 130
 131 // Tests that selecting the "Check Spelling While Typing" item toggles the value
 132 // of the "browser.enable_spellchecking" profile.
 133 IN_PROC_BROWSER_TEST_F(SpellCheckerSubMenuObserverTest, ToggleSpelling) {
 134   // Initialize a menu consisting only of a "Spell-checker Options" submenu.
 135   scoped_ptr<MockRenderViewContextMenu> menu(new MockRenderViewContextMenu);
 136   scoped_ptr<SpellCheckerSubMenuObserver> observer(
 137       new SpellCheckerSubMenuObserver(menu.get(), menu.get(), 1));
 138   menu->SetObserver(observer.get());
 139   menu->GetPrefs()->SetString(prefs::kAcceptLanguages, "en-US");
 140   menu->GetPrefs()->SetString(prefs::kSpellCheckDictionary, "en-US");
 141   menu->GetPrefs()->SetBoolean(prefs::kEnableContinuousSpellcheck, true);
 142   content::ContextMenuParams params;
 143   observer->InitMenu(params);
 144
 145   // Verify this menu has the "Check Spelling While Typing" item and this item
 146   // is checked.
 147   EXPECT_TRUE(menu->IsCommandIdEnabled(IDC_CHECK_SPELLING_WHILE_TYPING));
 148   EXPECT_TRUE(menu->IsCommandIdChecked(IDC_CHECK_SPELLING_WHILE_TYPING));
 149
 150   // Select this item and verify that the "Check Spelling While Typing" item is
 151   // not checked. Also, verify that the value of "browser.enable_spellchecking"
 152   // is now false.
 153   menu->ExecuteCommand(IDC_CHECK_SPELLING_WHILE_TYPING, 0);
 154   EXPECT_FALSE(
 155       menu->GetPrefs()->GetBoolean(prefs::kEnableContinuousSpellcheck));
 156   EXPECT_FALSE(menu->IsCommandIdChecked(IDC_CHECK_SPELLING_WHILE_TYPING));
 157 }