Synchronize the check status of the "Check Spelling While Typing" item.

chrome/browser/tab_contents/spellchecker_submenu_observer_browsertest.cc

+// Copyright (c) 2012 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 "chrome/browser/tab_contents/spellchecker_submenu_observer.h"
+
+#include <vector>
+
+#include "base/utf_string_conversions.h"
+#include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/tab_contents/render_view_context_menu.h"
+#include "chrome/browser/tab_contents/render_view_context_menu_observer.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/testing_profile.h"
+
+using content::RenderViewHost;
+
+namespace {
+
+// A mock context menu used in this test. This class overrides virtual methods
+// derived from the RenderViewContextMenuProxy class to monitor calls from the
+// SpellingMenuObserver class.
+class MockRenderViewContextMenu : public ui::SimpleMenuModel::Delegate,
+                                  public RenderViewContextMenuProxy {
+ public:
+  // A menu item used in this test.
+  struct MockMenuItem {
+    MockMenuItem()
+        : command_id(0),
+          enabled(false),
+          checked(false),
+          hidden(true) {
+    }
+    int command_id;
+    bool enabled;
+    bool checked;
+    bool hidden;
+    string16 title;
+  };
+
+  MockRenderViewContextMenu() : observer_(NULL), profile_(new TestingProfile) {
+  }

[jeremy, 2012/06/21 09:48:35]

I think that for these empty functions you can just put the {} on the same line.

+  virtual ~MockRenderViewContextMenu() {
+  }

[jeremy, 2012/06/21 09:48:35]

here too...

+
+  // SimpleMenuModel::Delegate implementation.
+  virtual bool IsCommandIdChecked(int command_id) const OVERRIDE {
+    return observer_->IsCommandIdChecked(command_id);
+  }
+  virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE {
+    return observer_->IsCommandIdEnabled(command_id);
+  }
+  virtual void ExecuteCommand(int command_id) OVERRIDE {
+    observer_->ExecuteCommand(command_id);
+  }
+  virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE {
+  }
+  virtual void MenuWillShow(ui::SimpleMenuModel* source) OVERRIDE {
+  }
+  virtual void MenuClosed(ui::SimpleMenuModel* source) OVERRIDE {
+  }
+  virtual bool GetAcceleratorForCommandId(
+      int command_id,
+      ui::Accelerator* accelerator) OVERRIDE {
+    return false;
+  }
+
+  // RenderViewContextMenuProxy implementation.
+  virtual void AddMenuItem(int command_id, const string16& title) OVERRIDE {
+  }
+  virtual void AddCheckItem(int command_id, const string16& title) OVERRIDE {
+  }
+  virtual void AddSeparator() OVERRIDE {
+  }
+  virtual void AddSubMenu(int command_id,
+                          const string16& label,
+                          ui::MenuModel* model) OVERRIDE {
+  }
+  virtual void UpdateMenuItem(int command_id,
+                              bool enabled,
+                              bool hidden,
+                              const string16& title) OVERRIDE {
+  }
+  virtual RenderViewHost* GetRenderViewHost() const OVERRIDE {
+    return NULL;

[jeremy, 2012/06/21 09:48:35]

I just thought the code would be more readable if the empty methods were
declared in the class definition, leaving the other methods defined outside
seems fine to me.

No need to change this back though...

+  }
+  virtual Profile* GetProfile() const OVERRIDE {
+    return profile_.get();
+  }
+
+  // Attaches a RenderViewContextMenuObserver to be tested.
+  void SetObserver(RenderViewContextMenuObserver* observer) {
+    observer_ = observer;
+  }
+
+  // Returns the number of items added by the test.
+  size_t GetMenuSize() const {
+    return 0;
+  }
+
+  // Returns the i-th item.
+  bool GetMenuItem(size_t i, MockMenuItem* item) const {
+    return false;
+  }
+
+  // Returns the writable profile used in this test.
+  PrefService* GetPrefs() {
+    return profile_->GetPrefs();
+  }
+
+ private:
+  // An observer used for initializing the status of menu items added in this
+  // test. This is a weak pointer, the test is responsible for deleting this
+  // object.
+  RenderViewContextMenuObserver* observer_;
+
+  // A dummy profile used in this test. Call GetPrefs() when a test needs to
+  // change this profile and use PrefService methods.
+  scoped_ptr<TestingProfile> profile_;
+
+  // A list of menu items added by the SpellingMenuObserver class.
+  std::vector<MockMenuItem> items_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockRenderViewContextMenu);
+};
+
+// A test class used in this file. This test should be a browser test because it
+// accesses resources.
+class SpellCheckerSubMenuObserverTest : public InProcessBrowserTest {
+ public:
+  SpellCheckerSubMenuObserverTest() {
+  }

[jeremy, 2012/06/21 09:48:35]

also here.

+  virtual ~SpellCheckerSubMenuObserverTest() {
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SpellCheckerSubMenuObserverTest);
+};
+
+}  // namespace
+
+// Tests that selecting the "Check Spelling While Typing" item toggles the value
+// of the "browser.enable_spellchecking" profile.
+IN_PROC_BROWSER_TEST_F(SpellCheckerSubMenuObserverTest, ToggleSpelling) {
+  // Initialize a menu consisting only of a "Spell-checker Options" submenu.
+  scoped_ptr<MockRenderViewContextMenu> menu(new MockRenderViewContextMenu);
+  scoped_ptr<SpellCheckerSubMenuObserver> observer(
+      new SpellCheckerSubMenuObserver(menu.get(), menu.get(), 1));
+  menu->SetObserver(observer.get());
+  menu->GetPrefs()->SetString(prefs::kAcceptLanguages, "en-US");
+  menu->GetPrefs()->SetString(prefs::kSpellCheckDictionary, "en-US");
+  menu->GetPrefs()->SetBoolean(prefs::kEnableSpellCheck, true);
+  content::ContextMenuParams params;
+  observer->InitMenu(params);
+
+  // Verify this menu has the "Check Spelling While Typing" item and this item
+  // is checked.
+  EXPECT_TRUE(menu->IsCommandIdEnabled(IDC_CHECK_SPELLING_WHILE_TYPING));
+  EXPECT_TRUE(menu->IsCommandIdChecked(IDC_CHECK_SPELLING_WHILE_TYPING));
+
+  // Select this item and verify the "Check Spelling While Typing" item is not
+  // checked. Also, verify the value of "browser.enable_spellchecking" become
+  // false.

[jeremy, 2012/06/21 09:48:35]

nit:
* verify -> verify that
* become -> is now

+  menu->ExecuteCommand(IDC_CHECK_SPELLING_WHILE_TYPING);
+  EXPECT_FALSE(menu->GetPrefs()->GetBoolean(prefs::kEnableSpellCheck));
+  EXPECT_FALSE(menu->IsCommandIdChecked(IDC_CHECK_SPELLING_WHILE_TYPING));
+}