Home | History | Annotate | Download | only in tab_contents 
      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     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, const string16& title) OVERRIDE {}
     64   virtual void AddCheckItem(int command_id, const string16& title) OVERRIDE {}
     65   virtual void AddSeparator() OVERRIDE {}
     66   virtual void AddSubMenu(int command_id,
     67                           const string16& label,
     68                           ui::MenuModel* model) OVERRIDE {}
     69   virtual void UpdateMenuItem(int command_id,
     70                               bool enabled,
     71                               bool hidden,
     72                               const string16& title) OVERRIDE {}
     73   virtual RenderViewHost* GetRenderViewHost() const OVERRIDE {
     74     return NULL;
     75   }
     76   virtual Profile* GetProfile() const OVERRIDE {
     77     return profile_.get();
     78   }
     79   virtual content::WebContents* GetWebContents() const OVERRIDE {
     80     return NULL;
     81   }
     82 
     83   // Attaches a RenderViewContextMenuObserver to be tested.
     84   void SetObserver(RenderViewContextMenuObserver* observer) {
     85     observer_ = observer;
     86   }
     87 
     88   // Returns the number of items added by the test.
     89   size_t GetMenuSize() const {
     90     return 0;
     91   }
     92 
     93   // Returns the i-th item.
     94   bool GetMenuItem(size_t i, MockMenuItem* item) const {
     95     return false;
     96   }
     97 
     98   // Returns the writable profile used in this test.
     99   PrefService* GetPrefs() {
    100     return profile_->GetPrefs();
    101   }
    102 
    103  private:
    104   // An observer used for initializing the status of menu items added in this
    105   // test. This is a weak pointer, the test is responsible for deleting this
    106   // object.
    107   RenderViewContextMenuObserver* observer_;
    108 
    109   // A dummy profile used in this test. Call GetPrefs() when a test needs to
    110   // change this profile and use PrefService methods.
    111   scoped_ptr<TestingProfile> profile_;
    112 
    113   DISALLOW_COPY_AND_ASSIGN(MockRenderViewContextMenu);
    114 };
    115 
    116 // A test class used in this file. This test should be a browser test because it
    117 // accesses resources.
    118 class SpellCheckerSubMenuObserverTest : public InProcessBrowserTest {
    119  public:
    120   SpellCheckerSubMenuObserverTest() {}
    121   virtual ~SpellCheckerSubMenuObserverTest() {}
    122 
    123  private:
    124   DISALLOW_COPY_AND_ASSIGN(SpellCheckerSubMenuObserverTest);
    125 };
    126 
    127 }  // namespace
    128 
    129 // Tests that selecting the "Check Spelling While Typing" item toggles the value
    130 // of the "browser.enable_spellchecking" profile.
    131 IN_PROC_BROWSER_TEST_F(SpellCheckerSubMenuObserverTest, ToggleSpelling) {
    132   // Initialize a menu consisting only of a "Spell-checker Options" submenu.
    133   scoped_ptr<MockRenderViewContextMenu> menu(new MockRenderViewContextMenu);
    134   scoped_ptr<SpellCheckerSubMenuObserver> observer(
    135       new SpellCheckerSubMenuObserver(menu.get(), menu.get(), 1));
    136   menu->SetObserver(observer.get());
    137   menu->GetPrefs()->SetString(prefs::kAcceptLanguages, "en-US");
    138   menu->GetPrefs()->SetString(prefs::kSpellCheckDictionary, "en-US");
    139   menu->GetPrefs()->SetBoolean(prefs::kEnableContinuousSpellcheck, true);
    140   content::ContextMenuParams params;
    141   observer->InitMenu(params);
    142 
    143   // Verify this menu has the "Check Spelling While Typing" item and this item
    144   // is checked.
    145   EXPECT_TRUE(menu->IsCommandIdEnabled(IDC_CHECK_SPELLING_WHILE_TYPING));
    146   EXPECT_TRUE(menu->IsCommandIdChecked(IDC_CHECK_SPELLING_WHILE_TYPING));
    147 
    148   // Select this item and verify that the "Check Spelling While Typing" item is
    149   // not checked. Also, verify that the value of "browser.enable_spellchecking"
    150   // is now false.
    151   menu->ExecuteCommand(IDC_CHECK_SPELLING_WHILE_TYPING, 0);
    152   EXPECT_FALSE(
    153       menu->GetPrefs()->GetBoolean(prefs::kEnableContinuousSpellcheck));
    154   EXPECT_FALSE(menu->IsCommandIdChecked(IDC_CHECK_SPELLING_WHILE_TYPING));
    155 }
    156