chrome/browser/tab_contents/spelling_menu_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/spelling_menu_observer.h"
   6
   7 #include <vector>
   8
   9 #include "base/command_line.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/app/chrome_command_ids.h"
  13 #include "chrome/browser/spellchecker/spelling_service_client.h"
  14 #include "chrome/browser/tab_contents/render_view_context_menu.h"
  15 #include "chrome/browser/tab_contents/render_view_context_menu_observer.h"
  16 #include "chrome/common/chrome_switches.h"
  17 #include "chrome/common/pref_names.h"
  18 #include "chrome/test/base/in_process_browser_test.h"
  19 #include "chrome/test/base/testing_profile.h"
  20
  21 using content::RenderViewHost;
  22 using content::WebContents;
  23
  24 namespace {
  25
  26 // A mock context menu used in this test. This class overrides virtual methods
  27 // derived from the RenderViewContextMenuProxy class to monitor calls from the
  28 // SpellingMenuObserver class.
  29 class MockRenderViewContextMenu : public RenderViewContextMenuProxy {
  30  public:
  31   // A menu item used in this test. This test uses a vector of this struct to
  32   // hold menu items added by this test.
  33   struct MockMenuItem {
  34     MockMenuItem()
  35         : command_id(0),
  36           enabled(false),
  37           checked(false),
  38           hidden(true) {
  39     }
  40     int command_id;
  41     bool enabled;
  42     bool checked;
  43     bool hidden;
  44     base::string16 title;
  45   };
  46
  47   explicit MockRenderViewContextMenu(bool incognito);
  48   virtual ~MockRenderViewContextMenu();
  49
  50   // RenderViewContextMenuProxy implementation.
  51   virtual void AddMenuItem(int command_id,
  52                            const base::string16& title) OVERRIDE;
  53   virtual void AddCheckItem(int command_id,
  54                             const base::string16& title) OVERRIDE;
  55   virtual void AddSeparator() OVERRIDE;
  56   virtual void AddSubMenu(int command_id,
  57                           const base::string16& label,
  58                           ui::MenuModel* model) OVERRIDE;
  59   virtual void UpdateMenuItem(int command_id,
  60                               bool enabled,
  61                               bool hidden,
  62                               const base::string16& title) OVERRIDE;
  63   virtual RenderViewHost* GetRenderViewHost() const OVERRIDE;
  64   virtual WebContents* GetWebContents() const OVERRIDE;
  65   virtual Profile* GetProfile() const OVERRIDE;
  66
  67   // Attaches a RenderViewContextMenuObserver to be tested.
  68   void SetObserver(RenderViewContextMenuObserver* observer);
  69
  70   // Returns the number of items added by the test.
  71   size_t GetMenuSize() const;
  72
  73   // Returns the i-th item.
  74   bool GetMenuItem(size_t i, MockMenuItem* item) const;
  75
  76   // Returns the writable profile used in this test.
  77   PrefService* GetPrefs();
  78
  79  private:
  80   // An observer used for initializing the status of menu items added in this
  81   // test. A test should delete this RenderViewContextMenuObserver object.
  82   RenderViewContextMenuObserver* observer_;
  83
  84   // A dummy profile used in this test. Call GetPrefs() when a test needs to
  85   // change this profile and use PrefService methods.
  86   scoped_ptr<TestingProfile> profile_;
  87
  88   // A list of menu items added by the SpellingMenuObserver class.
  89   std::vector<MockMenuItem> items_;
  90
  91   DISALLOW_COPY_AND_ASSIGN(MockRenderViewContextMenu);
  92 };
  93
  94 MockRenderViewContextMenu::MockRenderViewContextMenu(bool incognito)
  95     : observer_(NULL) {
  96   TestingProfile::Builder builder;
  97   if (incognito)
  98     builder.SetIncognito();
  99   profile_ = builder.Build();
 100 }
 101
 102 MockRenderViewContextMenu::~MockRenderViewContextMenu() {
 103 }
 104
 105 void MockRenderViewContextMenu::AddMenuItem(int command_id,
 106                                             const base::string16& title) {
 107   MockMenuItem item;
 108   item.command_id = command_id;
 109   item.enabled = observer_->IsCommandIdEnabled(command_id);
 110   item.checked = false;
 111   item.hidden = false;
 112   item.title = title;
 113   items_.push_back(item);
 114 }
 115
 116 void MockRenderViewContextMenu::AddCheckItem(int command_id,
 117                                              const base::string16& title) {
 118   MockMenuItem item;
 119   item.command_id = command_id;
 120   item.enabled = observer_->IsCommandIdEnabled(command_id);
 121   item.checked = observer_->IsCommandIdChecked(command_id);
 122   item.hidden = false;
 123   item.title = title;
 124   items_.push_back(item);
 125 }
 126
 127 void MockRenderViewContextMenu::AddSeparator() {
 128   MockMenuItem item;
 129   item.command_id = -1;
 130   item.enabled = false;
 131   item.checked = false;
 132   item.hidden = false;
 133   items_.push_back(item);
 134 }
 135
 136 void MockRenderViewContextMenu::AddSubMenu(int command_id,
 137                                            const base::string16& label,
 138                                            ui::MenuModel* model) {
 139   MockMenuItem item;
 140   item.command_id = -1;
 141   item.enabled = false;
 142   item.checked = false;
 143   item.hidden = false;
 144   items_.push_back(item);
 145 }
 146
 147 void MockRenderViewContextMenu::UpdateMenuItem(int command_id,
 148                                                bool enabled,
 149                                                bool hidden,
 150                                                const base::string16& title) {
 151   for (std::vector<MockMenuItem>::iterator it = items_.begin();
 152        it != items_.end(); ++it) {
 153     if (it->command_id == command_id) {
 154       it->enabled = enabled;
 155       it->hidden = hidden;
 156       it->title = title;
 157       return;
 158     }
 159   }
 160
 161   // The SpellingMenuObserver class tries to change a menu item not added by the
 162   // class. This is an unexpected behavior and we should stop now.
 163   FAIL();
 164 }
 165
 166 RenderViewHost* MockRenderViewContextMenu::GetRenderViewHost() const {
 167   return NULL;
 168 }
 169
 170 WebContents* MockRenderViewContextMenu::GetWebContents() const {
 171   return NULL;
 172 }
 173
 174 Profile* MockRenderViewContextMenu::GetProfile() const {
 175   return profile_.get();
 176 }
 177
 178 size_t MockRenderViewContextMenu::GetMenuSize() const {
 179   return items_.size();
 180 }
 181
 182 bool MockRenderViewContextMenu::GetMenuItem(size_t i,
 183                                             MockMenuItem* item) const {
 184   if (i >= items_.size())
 185     return false;
 186   item->command_id = items_[i].command_id;
 187   item->enabled = items_[i].enabled;
 188   item->checked = items_[i].checked;
 189   item->hidden = items_[i].hidden;
 190   item->title = items_[i].title;
 191   return true;
 192 }
 193
 194 void MockRenderViewContextMenu::SetObserver(
 195     RenderViewContextMenuObserver* observer) {
 196   observer_ = observer;
 197 }
 198
 199 PrefService* MockRenderViewContextMenu::GetPrefs() {
 200   return profile_->GetPrefs();
 201 }
 202
 203 // A test class used in this file. This test should be a browser test because it
 204 // accesses resources.
 205 class SpellingMenuObserverTest : public InProcessBrowserTest {
 206  public:
 207   SpellingMenuObserverTest();
 208
 209   virtual void SetUpOnMainThread() OVERRIDE {
 210     Reset(false);
 211   }
 212
 213   virtual void CleanUpOnMainThread() OVERRIDE {
 214     observer_.reset();
 215     menu_.reset();
 216   }
 217
 218   void Reset(bool incognito) {
 219     observer_.reset();
 220     menu_.reset(new MockRenderViewContextMenu(incognito));
 221     observer_.reset(new SpellingMenuObserver(menu_.get()));
 222     menu_->SetObserver(observer_.get());
 223   }
 224
 225   void InitMenu(const char* word, const char* suggestion) {
 226     content::ContextMenuParams params;
 227     params.is_editable = true;
 228     params.misspelled_word = ASCIIToUTF16(word);
 229     params.dictionary_suggestions.clear();
 230     if (suggestion)
 231       params.dictionary_suggestions.push_back(ASCIIToUTF16(suggestion));
 232     observer_->InitMenu(params);
 233   }
 234
 235   virtual ~SpellingMenuObserverTest();
 236   MockRenderViewContextMenu* menu() { return menu_.get(); }
 237   SpellingMenuObserver* observer() { return observer_.get(); }
 238  private:
 239   scoped_ptr<SpellingMenuObserver> observer_;
 240   scoped_ptr<MockRenderViewContextMenu> menu_;
 241   DISALLOW_COPY_AND_ASSIGN(SpellingMenuObserverTest);
 242 };
 243
 244 SpellingMenuObserverTest::SpellingMenuObserverTest() {
 245 }
 246
 247 SpellingMenuObserverTest::~SpellingMenuObserverTest() {
 248 }
 249
 250 }  // namespace
 251
 252 // Tests that right-clicking a correct word does not add any items.
 253 IN_PROC_BROWSER_TEST_F(SpellingMenuObserverTest, InitMenuWithCorrectWord) {
 254   InitMenu("", NULL);
 255   EXPECT_EQ(static_cast<size_t>(0), menu()->GetMenuSize());
 256 }
 257
 258 // Tests that right-clicking a misspelled word adds four items:
 259 // "No spelling suggestions", "Add to dictionary", "Ask Google for suggestions",
 260 // and a separator.
 261 IN_PROC_BROWSER_TEST_F(SpellingMenuObserverTest, InitMenuWithMisspelledWord) {
 262   InitMenu("wiimode", NULL);
 263   EXPECT_EQ(static_cast<size_t>(4), menu()->GetMenuSize());
 264
 265   // Read all the context-menu items added by this test and verify they are
 266   // expected ones. We do not check the item titles to prevent resource changes
 267   // from breaking this test. (I think it is not expected by those who change
 268   // resources.)
 269   MockRenderViewContextMenu::MockMenuItem item;
 270   menu()->GetMenuItem(0, &item);
 271   EXPECT_EQ(IDC_CONTENT_CONTEXT_NO_SPELLING_SUGGESTIONS, item.command_id);
 272   EXPECT_FALSE(item.enabled);
 273   EXPECT_FALSE(item.hidden);
 274   menu()->GetMenuItem(1, &item);
 275   EXPECT_EQ(IDC_SPELLCHECK_ADD_TO_DICTIONARY, item.command_id);
 276   EXPECT_TRUE(item.enabled);
 277   EXPECT_FALSE(item.hidden);
 278   menu()->GetMenuItem(2, &item);
 279   EXPECT_EQ(IDC_CONTENT_CONTEXT_SPELLING_TOGGLE, item.command_id);
 280   EXPECT_TRUE(item.enabled);
 281   EXPECT_FALSE(item.checked);
 282   EXPECT_FALSE(item.hidden);
 283   menu()->GetMenuItem(3, &item);
 284   EXPECT_EQ(-1, item.command_id);
 285   EXPECT_FALSE(item.enabled);
 286   EXPECT_FALSE(item.hidden);
 287 }
 288
 289 // Tests that right-clicking a correct word when we enable spelling-service
 290 // integration to verify an item "Ask Google for suggestions" is checked. Even
 291 // though this meanu itself does not add this item, its sub-menu adds the item
 292 // and calls SpellingMenuObserver::IsChecked() to check it.
 293 IN_PROC_BROWSER_TEST_F(SpellingMenuObserverTest,
 294                        EnableSpellingServiceWithCorrectWord) {
 295   menu()->GetPrefs()->SetBoolean(prefs::kSpellCheckUseSpellingService, true);
 296   InitMenu("", NULL);
 297
 298   EXPECT_TRUE(
 299       observer()->IsCommandIdChecked(IDC_CONTENT_CONTEXT_SPELLING_TOGGLE));
 300 }
 301
 302 // Tests that right-clicking a misspelled word when we enable spelling-service
 303 // integration to verify an item "Ask Google for suggestions" is checked. (This
 304 // test does not actually send JSON-RPC requests to the service because it makes
 305 // this test flaky.)
 306 IN_PROC_BROWSER_TEST_F(SpellingMenuObserverTest, EnableSpellingService) {
 307   menu()->GetPrefs()->SetBoolean(prefs::kSpellCheckUseSpellingService, true);
 308   menu()->GetPrefs()->SetString(prefs::kSpellCheckDictionary, std::string());
 309
 310   InitMenu("wiimode", NULL);
 311   EXPECT_EQ(static_cast<size_t>(4), menu()->GetMenuSize());
 312
 313   // To avoid duplicates, this test reads only the "Ask Google for suggestions"
 314   // item and verifies it is enabled and checked.
 315   MockRenderViewContextMenu::MockMenuItem item;
 316   menu()->GetMenuItem(2, &item);
 317   EXPECT_EQ(IDC_CONTENT_CONTEXT_SPELLING_TOGGLE, item.command_id);
 318   EXPECT_TRUE(item.enabled);
 319   EXPECT_TRUE(item.checked);
 320   EXPECT_FALSE(item.hidden);
 321 }
 322
 323 // Test that there will be a separator after "no suggestions" if
 324 // SpellingServiceClient::SUGGEST is on.
 325 IN_PROC_BROWSER_TEST_F(SpellingMenuObserverTest, SeparatorAfterSuggestions) {
 326   menu()->GetPrefs()->SetBoolean(prefs::kSpellCheckUseSpellingService, true);
 327   CommandLine* command_line = CommandLine::ForCurrentProcess();
 328   command_line->AppendSwitch(switches::kUseSpellingSuggestions);
 329
 330   // Force a non-empty locale so SUGGEST is available.
 331   menu()->GetPrefs()->SetString(prefs::kSpellCheckDictionary, "en");
 332   EXPECT_TRUE(SpellingServiceClient::IsAvailable(menu()->GetProfile(),
 333     SpellingServiceClient::SUGGEST));
 334
 335   InitMenu("jhhj", NULL);
 336
 337   // The test should see a top separator, "No spelling suggestions",
 338   // "No more Google suggestions" (from SpellingService) and a separator
 339   // as the first four items, then possibly more (not relevant here).
 340   EXPECT_LT(4U, menu()->GetMenuSize());
 341
 342   MockRenderViewContextMenu::MockMenuItem item;
 343   menu()->GetMenuItem(0, &item);
 344   EXPECT_EQ(-1, item.command_id);
 345   EXPECT_FALSE(item.enabled);
 346   EXPECT_FALSE(item.hidden);
 347
 348   menu()->GetMenuItem(1, &item);
 349   EXPECT_EQ(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION, item.command_id);
 350   EXPECT_FALSE(item.enabled);
 351   EXPECT_FALSE(item.hidden);
 352
 353   menu()->GetMenuItem(2, &item);
 354   EXPECT_EQ(IDC_CONTENT_CONTEXT_NO_SPELLING_SUGGESTIONS, item.command_id);
 355   EXPECT_FALSE(item.enabled);
 356   EXPECT_FALSE(item.hidden);
 357
 358   menu()->GetMenuItem(3, &item);
 359   EXPECT_EQ(-1, item.command_id);
 360   EXPECT_FALSE(item.enabled);
 361   EXPECT_FALSE(item.hidden);
 362 }
 363
 364 // Test that we don't show "No more suggestions from Google" if the spelling
 365 // service is enabled and that there is only one suggestion.
 366 IN_PROC_BROWSER_TEST_F(SpellingMenuObserverTest,
 367                        NoMoreSuggestionsNotDisplayed) {
 368   menu()->GetPrefs()->SetBoolean(prefs::kSpellCheckUseSpellingService, true);
 369
 370   // Force a non-empty locale so SPELLCHECK is available.
 371   menu()->GetPrefs()->SetString(prefs::kSpellCheckDictionary, "en");
 372   EXPECT_TRUE(SpellingServiceClient::IsAvailable(menu()->GetProfile(),
 373     SpellingServiceClient::SPELLCHECK));
 374   InitMenu("asdfkj", "asdf");
 375
 376   // The test should see a separator, a suggestion and another separator
 377   // as the first two items, then possibly more (not relevant here).
 378   EXPECT_LT(3U, menu()->GetMenuSize());
 379
 380   MockRenderViewContextMenu::MockMenuItem item;
 381   menu()->GetMenuItem(0, &item);
 382   EXPECT_EQ(-1, item.command_id);
 383   EXPECT_FALSE(item.enabled);
 384   EXPECT_FALSE(item.hidden);
 385
 386   menu()->GetMenuItem(1, &item);
 387   EXPECT_EQ(IDC_SPELLCHECK_SUGGESTION_0, item.command_id);
 388   EXPECT_TRUE(item.enabled);
 389   EXPECT_FALSE(item.hidden);
 390
 391   menu()->GetMenuItem(2, &item);
 392   EXPECT_EQ(-1, item.command_id);
 393   EXPECT_FALSE(item.enabled);
 394   EXPECT_FALSE(item.hidden);
 395 }
 396
 397 // Test that "Ask Google For Suggestions" is grayed out when using an
 398 // off the record profile.
 399 // TODO(rlp): Include graying out of autocorrect in this test when autocorrect
 400 // is functional.
 401 IN_PROC_BROWSER_TEST_F(SpellingMenuObserverTest,
 402                        NoSpellingServiceWhenOffTheRecord) {
 403   // Create a menu in an incognito profile.
 404   Reset(true);
 405
 406   // This means spellchecking is allowed. Default is that the service is
 407   // contacted but this test makes sure that if profile is incognito, that
 408   // is not an option.
 409   menu()->GetPrefs()->SetBoolean(prefs::kSpellCheckUseSpellingService, true);
 410
 411   // Force a non-empty locale so SUGGEST normally would be available.
 412   menu()->GetPrefs()->SetString(prefs::kSpellCheckDictionary, "en");
 413   EXPECT_FALSE(SpellingServiceClient::IsAvailable(menu()->GetProfile(),
 414     SpellingServiceClient::SUGGEST));
 415   EXPECT_FALSE(SpellingServiceClient::IsAvailable(menu()->GetProfile(),
 416     SpellingServiceClient::SPELLCHECK));
 417
 418   InitMenu("sjxdjiiiiii", NULL);
 419
 420   // The test should see "No spelling suggestions" (from system checker).
 421   // They should not see "No more Google suggestions" (from SpellingService) or
 422   // a separator. The next 2 items should be "Add to Dictionary" followed
 423   // by "Ask Google for suggestions" which should be disabled.
 424   // TODO(rlp): add autocorrect here when it is functional.
 425   EXPECT_LT(3U, menu()->GetMenuSize());
 426
 427   MockRenderViewContextMenu::MockMenuItem item;
 428   menu()->GetMenuItem(0, &item);
 429   EXPECT_EQ(IDC_CONTENT_CONTEXT_NO_SPELLING_SUGGESTIONS, item.command_id);
 430   EXPECT_FALSE(item.enabled);
 431   EXPECT_FALSE(item.hidden);
 432
 433   menu()->GetMenuItem(1, &item);
 434   EXPECT_EQ(IDC_SPELLCHECK_ADD_TO_DICTIONARY, item.command_id);
 435   EXPECT_TRUE(item.enabled);
 436   EXPECT_FALSE(item.hidden);
 437
 438   menu()->GetMenuItem(2, &item);
 439   EXPECT_EQ(IDC_CONTENT_CONTEXT_SPELLING_TOGGLE, item.command_id);
 440   EXPECT_FALSE(item.enabled);
 441   EXPECT_FALSE(item.hidden);
 442 }
 443
 444 // Test that the menu is preceeded by a separator if there are any suggestions,
 445 // or if the SpellingServiceClient is available
 446 IN_PROC_BROWSER_TEST_F(SpellingMenuObserverTest, SuggestionsForceTopSeparator) {
 447   menu()->GetPrefs()->SetBoolean(prefs::kSpellCheckUseSpellingService, false);
 448
 449   // First case: Misspelled word, no suggestions, no spellcheck service.
 450   InitMenu("asdfkj", NULL);
 451   // See SpellingMenuObserverTest.InitMenuWithMisspelledWord on why 4 items.
 452   EXPECT_EQ(static_cast<size_t>(4), menu()->GetMenuSize());
 453   MockRenderViewContextMenu::MockMenuItem item;
 454   menu()->GetMenuItem(0, &item);
 455   EXPECT_NE(-1, item.command_id);
 456
 457   // Case #2. Misspelled word, suggestions, no spellcheck service.
 458   Reset(false);
 459   menu()->GetPrefs()->SetBoolean(prefs::kSpellCheckUseSpellingService, false);
 460   InitMenu("asdfkj", "asdf");
 461
 462   // Expect at least separator and 4 default entries.
 463   EXPECT_LT(static_cast<size_t>(5), menu()->GetMenuSize());
 464   // This test only cares that the first one is a separator.
 465   menu()->GetMenuItem(0, &item);
 466   EXPECT_EQ(-1, item.command_id);
 467
 468   // Case #3. Misspelled word, suggestion service is on.
 469   Reset(false);
 470   menu()->GetPrefs()->SetBoolean(prefs::kSpellCheckUseSpellingService, true);
 471   CommandLine* command_line = CommandLine::ForCurrentProcess();
 472   command_line->AppendSwitch(switches::kUseSpellingSuggestions);
 473   InitMenu("asdfkj", NULL);
 474
 475   // Should have at least 2 entries. Separator, suggestion.
 476   EXPECT_LT(2U, menu()->GetMenuSize());
 477   menu()->GetMenuItem(0, &item);
 478   EXPECT_EQ(-1, item.command_id);
 479   menu()->GetMenuItem(1, &item);
 480   EXPECT_EQ(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION, item.command_id);
 481 }