chrome/browser/extensions/extension_toolbar_model_unittest.cc

   1 // Copyright 2014 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 "base/files/file_util.h"
   6 #include "base/macros.h"
   7 #include "base/memory/ref_counted.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
  11 #include "chrome/browser/extensions/extension_action_manager.h"
  12 #include "chrome/browser/extensions/extension_action_test_util.h"
  13 #include "chrome/browser/extensions/extension_service.h"
  14 #include "chrome/browser/extensions/extension_service_test_base.h"
  15 #include "chrome/browser/extensions/extension_toolbar_model.h"
  16 #include "chrome/browser/extensions/extension_util.h"
  17 #include "chrome/browser/extensions/test_extension_dir.h"
  18 #include "chrome/browser/extensions/test_extension_system.h"
  19 #include "chrome/browser/extensions/unpacked_installer.h"
  20 #include "chrome/browser/profiles/profile.h"
  21 #include "chrome/browser/sessions/session_tab_helper.h"
  22 #include "chrome/browser/ui/extensions/extension_toolbar_icon_surfacing_bubble_delegate.h"
  23 #include "chrome/common/extensions/api/extension_action/action_info.h"
  24 #include "components/crx_file/id_util.h"
  25 #include "content/public/test/test_renderer_host.h"
  26 #include "content/public/test/web_contents_tester.h"
  27 #include "extensions/browser/extension_prefs.h"
  28 #include "extensions/browser/extension_registry.h"
  29 #include "extensions/browser/extension_system.h"
  30 #include "extensions/browser/pref_names.h"
  31 #include "extensions/browser/test_extension_registry_observer.h"
  32 #include "extensions/common/extension.h"
  33 #include "extensions/common/extension_builder.h"
  34 #include "extensions/common/feature_switch.h"
  35 #include "extensions/common/value_builder.h"
  36
  37 namespace extensions {
  38
  39 namespace {
  40
  41 // A simple observer that tracks the number of times certain events occur.
  42 class ExtensionToolbarModelTestObserver
  43     : public ExtensionToolbarModel::Observer {
  44  public:
  45   explicit ExtensionToolbarModelTestObserver(ExtensionToolbarModel* model);
  46   ~ExtensionToolbarModelTestObserver() override;
  47
  48   size_t inserted_count() const { return inserted_count_; }
  49   size_t removed_count() const { return removed_count_; }
  50   size_t moved_count() const { return moved_count_; }
  51   int highlight_mode_count() const { return highlight_mode_count_; }
  52   size_t initialized_count() const { return initialized_count_; }
  53
  54  private:
  55   // ExtensionToolbarModel::Observer:
  56   void OnToolbarExtensionAdded(const Extension* extension, int index) override {
  57     ++inserted_count_;
  58   }
  59
  60   void OnToolbarExtensionRemoved(const Extension* extension) override {
  61     ++removed_count_;
  62   }
  63
  64   void OnToolbarExtensionMoved(const Extension* extension, int index) override {
  65     ++moved_count_;
  66   }
  67
  68   void OnToolbarExtensionUpdated(const Extension* extension) override {}
  69
  70   bool ShowExtensionActionPopup(const Extension* extension,
  71                                 bool grant_active_tab) override {
  72     return false;
  73   }
  74
  75   void OnToolbarVisibleCountChanged() override {}
  76
  77   void OnToolbarHighlightModeChanged(bool is_highlighting) override {
  78     // Add one if highlighting, subtract one if not.
  79     highlight_mode_count_ += is_highlighting ? 1 : -1;
  80   }
  81
  82   void OnToolbarModelInitialized() override { ++initialized_count_; }
  83
  84   Browser* GetBrowser() override { return NULL; }
  85
  86   ExtensionToolbarModel* model_;
  87
  88   size_t inserted_count_;
  89   size_t removed_count_;
  90   size_t moved_count_;
  91   // Int because it could become negative (if something goes wrong).
  92   int highlight_mode_count_;
  93   size_t initialized_count_;
  94
  95   DISALLOW_COPY_AND_ASSIGN(ExtensionToolbarModelTestObserver);
  96 };
  97
  98 ExtensionToolbarModelTestObserver::ExtensionToolbarModelTestObserver(
  99     ExtensionToolbarModel* model) : model_(model),
 100                                     inserted_count_(0),
 101                                     removed_count_(0),
 102                                     moved_count_(0),
 103                                     highlight_mode_count_(0),
 104                                     initialized_count_(0) {
 105   model_->AddObserver(this);
 106 }
 107
 108 ExtensionToolbarModelTestObserver::~ExtensionToolbarModelTestObserver() {
 109   model_->RemoveObserver(this);
 110 }
 111
 112 }  // namespace
 113
 114 class ExtensionToolbarModelUnitTest : public ExtensionServiceTestBase {
 115  protected:
 116   // Initialize the ExtensionService, ExtensionToolbarModel, and
 117   // ExtensionSystem.
 118   void Init();
 119
 120   void TearDown() override;
 121
 122   // Adds or removes the given |extension| and verify success.
 123   testing::AssertionResult AddExtension(
 124       const scoped_refptr<const Extension>& extension) WARN_UNUSED_RESULT;
 125   testing::AssertionResult RemoveExtension(
 126       const scoped_refptr<const Extension>& extension) WARN_UNUSED_RESULT;
 127
 128   // Adds three extensions, all with browser actions.
 129   testing::AssertionResult AddBrowserActionExtensions() WARN_UNUSED_RESULT;
 130
 131   // Adds three extensions, one each for browser action, page action, and no
 132   // action, and are added in that order.
 133   testing::AssertionResult AddActionExtensions() WARN_UNUSED_RESULT;
 134
 135   // Returns the extension at the given index in the toolbar model, or NULL
 136   // if one does not exist.
 137   // If |model| is specified, it is used. Otherwise, this defaults to
 138   // |toolbar_model_|.
 139   const Extension* GetExtensionAtIndex(
 140       size_t index, const ExtensionToolbarModel* model) const;
 141   const Extension* GetExtensionAtIndex(size_t index) const;
 142
 143   ExtensionToolbarModel* toolbar_model() { return toolbar_model_; }
 144
 145   const ExtensionToolbarModelTestObserver* observer() const {
 146     return model_observer_.get();
 147   }
 148   size_t num_toolbar_items() const {
 149     return toolbar_model_->toolbar_items().size();
 150   }
 151   const Extension* browser_action_a() const { return browser_action_a_.get(); }
 152   const Extension* browser_action_b() const { return browser_action_b_.get(); }
 153   const Extension* browser_action_c() const { return browser_action_c_.get(); }
 154   const Extension* browser_action() const {
 155     return browser_action_extension_.get();
 156   }
 157   const Extension* page_action() const { return page_action_extension_.get(); }
 158   const Extension* no_action() const { return no_action_extension_.get(); }
 159
 160  private:
 161   // Verifies that all extensions in |extensions| are added successfully.
 162   testing::AssertionResult AddAndVerifyExtensions(
 163       const ExtensionList& extensions);
 164
 165   // The toolbar model associated with the testing profile.
 166   ExtensionToolbarModel* toolbar_model_;
 167
 168   // The test observer to track events. Must come after toolbar_model_ so that
 169   // it is destroyed and removes itself as an observer first.
 170   scoped_ptr<ExtensionToolbarModelTestObserver> model_observer_;
 171
 172   // Sample extensions with only browser actions.
 173   scoped_refptr<const Extension> browser_action_a_;
 174   scoped_refptr<const Extension> browser_action_b_;
 175   scoped_refptr<const Extension> browser_action_c_;
 176
 177   // Sample extensions with different kinds of actions.
 178   scoped_refptr<const Extension> browser_action_extension_;
 179   scoped_refptr<const Extension> page_action_extension_;
 180   scoped_refptr<const Extension> no_action_extension_;
 181 };
 182
 183 void ExtensionToolbarModelUnitTest::Init() {
 184   InitializeEmptyExtensionService();
 185   toolbar_model_ =
 186       extension_action_test_util::CreateToolbarModelForProfile(profile());
 187   model_observer_.reset(new ExtensionToolbarModelTestObserver(toolbar_model_));
 188 }
 189
 190 void ExtensionToolbarModelUnitTest::TearDown() {
 191   model_observer_.reset();
 192   ExtensionServiceTestBase::TearDown();
 193 }
 194
 195 testing::AssertionResult ExtensionToolbarModelUnitTest::AddExtension(
 196     const scoped_refptr<const Extension>& extension) {
 197   if (registry()->enabled_extensions().GetByID(extension->id())) {
 198     return testing::AssertionFailure() << "Extension " << extension->name() <<
 199         " already installed!";
 200   }
 201   service()->AddExtension(extension.get());
 202   if (!registry()->enabled_extensions().GetByID(extension->id())) {
 203     return testing::AssertionFailure() << "Failed to install extension: " <<
 204         extension->name();
 205   }
 206   return testing::AssertionSuccess();
 207 }
 208
 209 testing::AssertionResult ExtensionToolbarModelUnitTest::RemoveExtension(
 210     const scoped_refptr<const Extension>& extension) {
 211   if (!registry()->enabled_extensions().GetByID(extension->id())) {
 212     return testing::AssertionFailure() << "Extension " << extension->name() <<
 213         " not installed!";
 214   }
 215   service()->UnloadExtension(extension->id(),
 216                              UnloadedExtensionInfo::REASON_DISABLE);
 217   if (registry()->enabled_extensions().GetByID(extension->id())) {
 218     return testing::AssertionFailure() << "Failed to unload extension: " <<
 219         extension->name();
 220   }
 221   return testing::AssertionSuccess();
 222 }
 223
 224 testing::AssertionResult ExtensionToolbarModelUnitTest::AddActionExtensions() {
 225   browser_action_extension_ = extension_action_test_util::CreateActionExtension(
 226       "browser_action", extension_action_test_util::BROWSER_ACTION);
 227   page_action_extension_ = extension_action_test_util::CreateActionExtension(
 228       "page_action", extension_action_test_util::PAGE_ACTION);
 229   no_action_extension_ = extension_action_test_util::CreateActionExtension(
 230       "no_action", extension_action_test_util::NO_ACTION);
 231
 232   ExtensionList extensions;
 233   extensions.push_back(browser_action_extension_);
 234   extensions.push_back(page_action_extension_);
 235   extensions.push_back(no_action_extension_);
 236
 237   return AddAndVerifyExtensions(extensions);
 238 }
 239
 240 testing::AssertionResult
 241 ExtensionToolbarModelUnitTest::AddBrowserActionExtensions() {
 242   browser_action_a_ = extension_action_test_util::CreateActionExtension(
 243       "browser_actionA", extension_action_test_util::BROWSER_ACTION);
 244   browser_action_b_ = extension_action_test_util::CreateActionExtension(
 245       "browser_actionB", extension_action_test_util::BROWSER_ACTION);
 246   browser_action_c_ = extension_action_test_util::CreateActionExtension(
 247       "browser_actionC", extension_action_test_util::BROWSER_ACTION);
 248
 249   ExtensionList extensions;
 250   extensions.push_back(browser_action_a_);
 251   extensions.push_back(browser_action_b_);
 252   extensions.push_back(browser_action_c_);
 253
 254   return AddAndVerifyExtensions(extensions);
 255 }
 256
 257 const Extension* ExtensionToolbarModelUnitTest::GetExtensionAtIndex(
 258     size_t index, const ExtensionToolbarModel* model) const {
 259   return index < model->toolbar_items().size()
 260              ? model->toolbar_items()[index].get()
 261              : NULL;
 262 }
 263
 264 const Extension* ExtensionToolbarModelUnitTest::GetExtensionAtIndex(
 265     size_t index) const {
 266   return GetExtensionAtIndex(index, toolbar_model_);
 267 }
 268
 269 testing::AssertionResult ExtensionToolbarModelUnitTest::AddAndVerifyExtensions(
 270     const ExtensionList& extensions) {
 271   for (ExtensionList::const_iterator iter = extensions.begin();
 272        iter != extensions.end(); ++iter) {
 273     if (!AddExtension(*iter)) {
 274       return testing::AssertionFailure() << "Failed to install extension: " <<
 275           (*iter)->name();
 276     }
 277   }
 278   return testing::AssertionSuccess();
 279 }
 280
 281 // A basic test for extensions with browser actions showing up in the toolbar.
 282 TEST_F(ExtensionToolbarModelUnitTest, BasicExtensionToolbarModelTest) {
 283   Init();
 284
 285   // Load an extension with no browser action.
 286   scoped_refptr<const Extension> extension1 =
 287       extension_action_test_util::CreateActionExtension(
 288           "no_action", extension_action_test_util::NO_ACTION);
 289   ASSERT_TRUE(AddExtension(extension1));
 290
 291   // This extension should not be in the model (has no browser action).
 292   EXPECT_EQ(0u, observer()->inserted_count());
 293   EXPECT_EQ(0u, num_toolbar_items());
 294   EXPECT_EQ(NULL, GetExtensionAtIndex(0u));
 295
 296   // Load an extension with a browser action.
 297   scoped_refptr<const Extension> extension2 =
 298       extension_action_test_util::CreateActionExtension(
 299           "browser_action", extension_action_test_util::BROWSER_ACTION);
 300   ASSERT_TRUE(AddExtension(extension2));
 301
 302   // We should now find our extension in the model.
 303   EXPECT_EQ(1u, observer()->inserted_count());
 304   EXPECT_EQ(1u, num_toolbar_items());
 305   EXPECT_EQ(extension2.get(), GetExtensionAtIndex(0u));
 306
 307   // Should be a no-op, but still fires the events.
 308   toolbar_model()->MoveExtensionIcon(extension2->id(), 0);
 309   EXPECT_EQ(1u, observer()->moved_count());
 310   EXPECT_EQ(1u, num_toolbar_items());
 311   EXPECT_EQ(extension2.get(), GetExtensionAtIndex(0u));
 312
 313   // Remove the extension and verify.
 314   ASSERT_TRUE(RemoveExtension(extension2));
 315   EXPECT_EQ(1u, observer()->removed_count());
 316   EXPECT_EQ(0u, num_toolbar_items());
 317   EXPECT_EQ(NULL, GetExtensionAtIndex(0u));
 318 }
 319
 320 // Test various different reorderings, removals, and reinsertions.
 321 TEST_F(ExtensionToolbarModelUnitTest, ExtensionToolbarReorderAndReinsert) {
 322   Init();
 323
 324   // Add the three browser action extensions.
 325   ASSERT_TRUE(AddBrowserActionExtensions());
 326
 327   // Verify the three extensions are in the model in the proper order.
 328   EXPECT_EQ(3u, num_toolbar_items());
 329   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 330   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 331   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2u));
 332
 333   // Order is now A, B, C. Let's put C first.
 334   toolbar_model()->MoveExtensionIcon(browser_action_c()->id(), 0);
 335   EXPECT_EQ(1u, observer()->moved_count());
 336   EXPECT_EQ(3u, num_toolbar_items());
 337   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(0u));
 338   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(1u));
 339   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(2u));
 340
 341   // Order is now C, A, B. Let's put A last.
 342   toolbar_model()->MoveExtensionIcon(browser_action_a()->id(), 2);
 343   EXPECT_EQ(2u, observer()->moved_count());
 344   EXPECT_EQ(3u, num_toolbar_items());
 345   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(0u));
 346   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 347   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(2u));
 348
 349   // Order is now C, B, A. Let's remove B.
 350   ASSERT_TRUE(RemoveExtension(browser_action_b()));
 351   EXPECT_EQ(1u, observer()->removed_count());
 352   EXPECT_EQ(2u, num_toolbar_items());
 353   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(0u));
 354   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(1u));
 355
 356   // Load extension B again.
 357   ASSERT_TRUE(AddExtension(browser_action_b()));
 358
 359   // Extension B loaded again.
 360   EXPECT_EQ(4u, observer()->inserted_count());
 361   EXPECT_EQ(3u, num_toolbar_items());
 362   // Make sure it gets its old spot in the list.
 363   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 364
 365   // Unload B again.
 366   ASSERT_TRUE(RemoveExtension(browser_action_b()));
 367   EXPECT_EQ(2u, observer()->removed_count());
 368   EXPECT_EQ(2u, num_toolbar_items());
 369
 370   // Order is now C, A. Flip it.
 371   toolbar_model()->MoveExtensionIcon(browser_action_a()->id(), 0);
 372   EXPECT_EQ(3u, observer()->moved_count());
 373   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 374   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(1u));
 375
 376   // Move A to the location it already occupies.
 377   toolbar_model()->MoveExtensionIcon(browser_action_a()->id(), 0);
 378   EXPECT_EQ(4u, observer()->moved_count());
 379   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 380   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(1u));
 381
 382   // Order is now A, C. Remove C.
 383   ASSERT_TRUE(RemoveExtension(browser_action_c()));
 384   EXPECT_EQ(3u, observer()->removed_count());
 385   EXPECT_EQ(1u, num_toolbar_items());
 386   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 387
 388   // Load extension C again.
 389   ASSERT_TRUE(AddExtension(browser_action_c()));
 390
 391   // Extension C loaded again.
 392   EXPECT_EQ(5u, observer()->inserted_count());
 393   EXPECT_EQ(2u, num_toolbar_items());
 394   // Make sure it gets its old spot in the list (at the very end).
 395   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(1u));
 396 }
 397
 398 // Test that order persists after unloading and disabling, but not across
 399 // uninstallation.
 400 TEST_F(ExtensionToolbarModelUnitTest,
 401        ExtensionToolbarUnloadDisableAndUninstall) {
 402   Init();
 403
 404   // Add the three browser action extensions.
 405   ASSERT_TRUE(AddBrowserActionExtensions());
 406
 407   // Verify the three extensions are in the model in the proper order: A, B, C.
 408   EXPECT_EQ(3u, num_toolbar_items());
 409   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 410   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 411   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2u));
 412
 413   // Unload B, then C, then A, and then reload C, then A, then B.
 414   ASSERT_TRUE(RemoveExtension(browser_action_b()));
 415   ASSERT_TRUE(RemoveExtension(browser_action_c()));
 416   ASSERT_TRUE(RemoveExtension(browser_action_a()));
 417   EXPECT_EQ(0u, num_toolbar_items());  // Sanity check: all gone?
 418   ASSERT_TRUE(AddExtension(browser_action_c()));
 419   ASSERT_TRUE(AddExtension(browser_action_a()));
 420   ASSERT_TRUE(AddExtension(browser_action_b()));
 421   EXPECT_EQ(3u, num_toolbar_items());  // Sanity check: all back?
 422   EXPECT_EQ(0u, observer()->moved_count());
 423
 424   // Even though we unloaded and reloaded in a different order, the original
 425   // order (A, B, C) should be preserved.
 426   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 427   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 428   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2u));
 429
 430   // Disabling extensions should also preserve order.
 431   service()->DisableExtension(browser_action_b()->id(),
 432                               Extension::DISABLE_USER_ACTION);
 433   service()->DisableExtension(browser_action_c()->id(),
 434                               Extension::DISABLE_USER_ACTION);
 435   service()->DisableExtension(browser_action_a()->id(),
 436                               Extension::DISABLE_USER_ACTION);
 437   service()->EnableExtension(browser_action_c()->id());
 438   service()->EnableExtension(browser_action_a()->id());
 439   service()->EnableExtension(browser_action_b()->id());
 440
 441   // Make sure we still get the original A, B, C order.
 442   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 443   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 444   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2u));
 445
 446   // Move browser_action_b() to be first.
 447   toolbar_model()->MoveExtensionIcon(browser_action_b()->id(), 0);
 448   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(0u));
 449
 450   // Uninstall Extension B.
 451   service()->UninstallExtension(browser_action_b()->id(),
 452                                 UNINSTALL_REASON_FOR_TESTING,
 453                                 base::Bind(&base::DoNothing),
 454                                 NULL);  // Ignore error.
 455   // List contains only A and C now. Validate that.
 456   EXPECT_EQ(2u, num_toolbar_items());
 457   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 458   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(1u));
 459
 460   ASSERT_TRUE(AddExtension(browser_action_b()));
 461
 462   // Make sure Extension B is _not_ first (its old position should have been
 463   // forgotten at uninstall time). Order should be A, C, B.
 464   EXPECT_EQ(3u, num_toolbar_items());
 465   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 466   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(1u));
 467   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(2u));
 468 }
 469
 470 TEST_F(ExtensionToolbarModelUnitTest, ReorderOnPrefChange) {
 471   Init();
 472
 473   // Add the three browser action extensions.
 474   ASSERT_TRUE(AddBrowserActionExtensions());
 475   EXPECT_EQ(3u, num_toolbar_items());
 476
 477   // Change the value of the toolbar preference.
 478   ExtensionIdList new_order;
 479   new_order.push_back(browser_action_c()->id());
 480   new_order.push_back(browser_action_b()->id());
 481   ExtensionPrefs::Get(profile())->SetToolbarOrder(new_order);
 482
 483   // Verify order is changed.
 484   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(0u));
 485   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 486   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(2u));
 487 }
 488
 489 // Test that new extensions are always visible on installation and inserted at
 490 // the "end" of the visible section.
 491 TEST_F(ExtensionToolbarModelUnitTest, NewToolbarExtensionsAreVisible) {
 492   Init();
 493
 494   // Three extensions with actions.
 495   scoped_refptr<const Extension> extension_a =
 496       extension_action_test_util::CreateActionExtension(
 497           "a", extension_action_test_util::BROWSER_ACTION);
 498   scoped_refptr<const Extension> extension_b =
 499       extension_action_test_util::CreateActionExtension(
 500           "b", extension_action_test_util::BROWSER_ACTION);
 501   scoped_refptr<const Extension> extension_c =
 502       extension_action_test_util::CreateActionExtension(
 503           "c", extension_action_test_util::BROWSER_ACTION);
 504   scoped_refptr<const Extension> extension_d =
 505       extension_action_test_util::CreateActionExtension(
 506           "d", extension_action_test_util::BROWSER_ACTION);
 507
 508   // We should start off without any extensions.
 509   EXPECT_EQ(0u, num_toolbar_items());
 510   EXPECT_EQ(0u, toolbar_model()->visible_icon_count());
 511
 512   // Add one extension. It should be visible.
 513   service()->AddExtension(extension_a.get());
 514   EXPECT_EQ(1u, num_toolbar_items());
 515   EXPECT_EQ(1u, toolbar_model()->visible_icon_count());
 516   EXPECT_EQ(extension_a.get(), GetExtensionAtIndex(0u));
 517
 518   // Hide all extensions.
 519   toolbar_model()->SetVisibleIconCount(0);
 520   EXPECT_EQ(0u, toolbar_model()->visible_icon_count());
 521
 522   // Add a new extension - it should be visible, so it should be in the first
 523   // index. The other extension should remain hidden.
 524   service()->AddExtension(extension_b.get());
 525   EXPECT_EQ(2u, num_toolbar_items());
 526   EXPECT_EQ(1u, toolbar_model()->visible_icon_count());
 527   EXPECT_EQ(extension_b.get(), GetExtensionAtIndex(0u));
 528   EXPECT_EQ(extension_a.get(), GetExtensionAtIndex(1u));
 529
 530   // Show all extensions.
 531   toolbar_model()->SetVisibleIconCount(2);
 532   EXPECT_EQ(2u, toolbar_model()->visible_icon_count());
 533   EXPECT_TRUE(toolbar_model()->all_icons_visible());
 534
 535   // Add the third extension. Since all extensions are visible, it should go in
 536   // the last index.
 537   service()->AddExtension(extension_c.get());
 538   EXPECT_EQ(3u, num_toolbar_items());
 539   EXPECT_EQ(3u, toolbar_model()->visible_icon_count());
 540   EXPECT_TRUE(toolbar_model()->all_icons_visible());
 541   EXPECT_EQ(extension_b.get(), GetExtensionAtIndex(0u));
 542   EXPECT_EQ(extension_a.get(), GetExtensionAtIndex(1u));
 543   EXPECT_EQ(extension_c.get(), GetExtensionAtIndex(2u));
 544
 545   // Hide one extension (two remaining visible).
 546   toolbar_model()->SetVisibleIconCount(2);
 547   EXPECT_EQ(2u, toolbar_model()->visible_icon_count());
 548
 549   // Add a fourth extension. It should go at the end of the visible section and
 550   // be visible, so it increases visible count by 1, and goes into the third
 551   // index. The hidden extension should remain hidden.
 552   service()->AddExtension(extension_d.get());
 553   EXPECT_EQ(4u, num_toolbar_items());
 554   EXPECT_EQ(3u, toolbar_model()->visible_icon_count());
 555   EXPECT_EQ(extension_b.get(), GetExtensionAtIndex(0u));
 556   EXPECT_EQ(extension_a.get(), GetExtensionAtIndex(1u));
 557   EXPECT_EQ(extension_d.get(), GetExtensionAtIndex(2u));
 558   EXPECT_EQ(extension_c.get(), GetExtensionAtIndex(3u));
 559 }
 560
 561 TEST_F(ExtensionToolbarModelUnitTest, ExtensionToolbarHighlightMode) {
 562   Init();
 563
 564   EXPECT_FALSE(toolbar_model()->HighlightExtensions(
 565       ExtensionIdList(), ExtensionToolbarModel::HIGHLIGHT_WARNING));
 566   EXPECT_EQ(0, observer()->highlight_mode_count());
 567
 568   // Add the three browser action extensions.
 569   ASSERT_TRUE(AddBrowserActionExtensions());
 570   EXPECT_EQ(3u, num_toolbar_items());
 571
 572   // Start with a visible count of 2 (non-zero, and not all).
 573   toolbar_model()->SetVisibleIconCount(2u);
 574
 575   // Highlight one extension.
 576   ExtensionIdList extension_ids;
 577   extension_ids.push_back(browser_action_b()->id());
 578   toolbar_model()->HighlightExtensions(
 579       extension_ids, ExtensionToolbarModel::HIGHLIGHT_WARNING);
 580   EXPECT_EQ(1, observer()->highlight_mode_count());
 581   EXPECT_TRUE(toolbar_model()->is_highlighting());
 582
 583   EXPECT_EQ(1u, num_toolbar_items());
 584   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(0u));
 585   EXPECT_EQ(1u, toolbar_model()->visible_icon_count());
 586
 587   // Stop highlighting.
 588   toolbar_model()->StopHighlighting();
 589   EXPECT_EQ(0, observer()->highlight_mode_count());
 590   EXPECT_FALSE(toolbar_model()->is_highlighting());
 591
 592   // Verify that the extensions are back to normal.
 593   EXPECT_EQ(3u, num_toolbar_items());
 594   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 595   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 596   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2u));
 597   EXPECT_EQ(2u, toolbar_model()->visible_icon_count());
 598
 599   // Call stop highlighting a second time (shouldn't be notified).
 600   toolbar_model()->StopHighlighting();
 601   EXPECT_EQ(0, observer()->highlight_mode_count());
 602   EXPECT_FALSE(toolbar_model()->is_highlighting());
 603
 604   // Highlight all extensions.
 605   extension_ids.clear();
 606   extension_ids.push_back(browser_action_a()->id());
 607   extension_ids.push_back(browser_action_b()->id());
 608   extension_ids.push_back(browser_action_c()->id());
 609   toolbar_model()->HighlightExtensions(
 610       extension_ids, ExtensionToolbarModel::HIGHLIGHT_WARNING);
 611   EXPECT_EQ(1, observer()->highlight_mode_count());
 612   EXPECT_EQ(3u, num_toolbar_items());
 613   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 614   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 615   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2u));
 616   EXPECT_EQ(3u, toolbar_model()->visible_icon_count());
 617   // Even though the visible count is 3, we shouldn't adjust the stored
 618   // preference.
 619   EXPECT_EQ(2, profile()->GetPrefs()->GetInteger(pref_names::kToolbarSize));
 620
 621   // Highlight only extension b (shrink the highlight list).
 622   extension_ids.clear();
 623   extension_ids.push_back(browser_action_b()->id());
 624   toolbar_model()->HighlightExtensions(
 625       extension_ids, ExtensionToolbarModel::HIGHLIGHT_WARNING);
 626   EXPECT_EQ(2, observer()->highlight_mode_count());
 627   EXPECT_EQ(1u, num_toolbar_items());
 628   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(0u));
 629
 630   // Highlight extensions a and b (grow the highlight list).
 631   extension_ids.clear();
 632   extension_ids.push_back(browser_action_a()->id());
 633   extension_ids.push_back(browser_action_b()->id());
 634   toolbar_model()->HighlightExtensions(
 635       extension_ids, ExtensionToolbarModel::HIGHLIGHT_WARNING);
 636   EXPECT_EQ(3, observer()->highlight_mode_count());
 637   EXPECT_EQ(2u, num_toolbar_items());
 638   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 639   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 640
 641   // Highlight no extensions (empty the highlight list).
 642   extension_ids.clear();
 643   toolbar_model()->HighlightExtensions(
 644       extension_ids, ExtensionToolbarModel::HIGHLIGHT_WARNING);
 645   EXPECT_EQ(2, observer()->highlight_mode_count());
 646   EXPECT_FALSE(toolbar_model()->is_highlighting());
 647   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 648   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 649   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2u));
 650
 651   // Our toolbar size should be back to normal.
 652   EXPECT_EQ(2u, toolbar_model()->visible_icon_count());
 653   EXPECT_EQ(2, profile()->GetPrefs()->GetInteger(pref_names::kToolbarSize));
 654 }
 655
 656 TEST_F(ExtensionToolbarModelUnitTest, ExtensionToolbarHighlightModeRemove) {
 657   Init();
 658
 659   // Add the three browser action extensions.
 660   ASSERT_TRUE(AddBrowserActionExtensions());
 661   EXPECT_EQ(3u, num_toolbar_items());
 662
 663   // Highlight two of the extensions.
 664   ExtensionIdList extension_ids;
 665   extension_ids.push_back(browser_action_a()->id());
 666   extension_ids.push_back(browser_action_b()->id());
 667   toolbar_model()->HighlightExtensions(
 668       extension_ids, ExtensionToolbarModel::HIGHLIGHT_WARNING);
 669   EXPECT_TRUE(toolbar_model()->is_highlighting());
 670   EXPECT_EQ(1, observer()->highlight_mode_count());
 671   EXPECT_EQ(2u, num_toolbar_items());
 672
 673   // Disable one of them - only one should remain highlighted.
 674   service()->DisableExtension(browser_action_a()->id(),
 675                               Extension::DISABLE_USER_ACTION);
 676   EXPECT_TRUE(toolbar_model()->is_highlighting());
 677   EXPECT_EQ(1u, num_toolbar_items());
 678   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(0u));
 679
 680   // Uninstall the remaining highlighted extension. This should result in
 681   // highlight mode exiting.
 682   service()->UninstallExtension(browser_action_b()->id(),
 683                                 UNINSTALL_REASON_FOR_TESTING,
 684                                 base::Bind(&base::DoNothing),
 685                                 NULL);  // Ignore error.
 686   EXPECT_FALSE(toolbar_model()->is_highlighting());
 687   EXPECT_EQ(0, observer()->highlight_mode_count());
 688   EXPECT_EQ(1u, num_toolbar_items());
 689   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(0u));
 690
 691   // Test that removing an unhighlighted extension still works.
 692   // Reinstall extension b, and then highlight extension c.
 693   ASSERT_TRUE(AddExtension(browser_action_b()));
 694   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 695   extension_ids.clear();
 696   extension_ids.push_back(browser_action_c()->id());
 697   toolbar_model()->HighlightExtensions(
 698       extension_ids, ExtensionToolbarModel::HIGHLIGHT_WARNING);
 699   EXPECT_EQ(1, observer()->highlight_mode_count());
 700   EXPECT_TRUE(toolbar_model()->is_highlighting());
 701   EXPECT_EQ(1u, num_toolbar_items());
 702   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(0u));
 703
 704   // Uninstalling b should not have visible impact.
 705   service()->UninstallExtension(browser_action_b()->id(),
 706                                 UNINSTALL_REASON_FOR_TESTING,
 707                                 base::Bind(&base::DoNothing),
 708                                 NULL);  // Ignore error.
 709   EXPECT_TRUE(toolbar_model()->is_highlighting());
 710   EXPECT_EQ(1, observer()->highlight_mode_count());
 711   EXPECT_EQ(1u, num_toolbar_items());
 712   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(0u));
 713
 714   // When we stop, only extension c should remain.
 715   toolbar_model()->StopHighlighting();
 716   EXPECT_FALSE(toolbar_model()->is_highlighting());
 717   EXPECT_EQ(0, observer()->highlight_mode_count());
 718   EXPECT_EQ(1u, num_toolbar_items());
 719   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(0u));
 720 }
 721
 722 TEST_F(ExtensionToolbarModelUnitTest, ExtensionToolbarHighlightModeAdd) {
 723   Init();
 724
 725   // Add the three browser action extensions.
 726   ASSERT_TRUE(AddBrowserActionExtensions());
 727   EXPECT_EQ(3u, num_toolbar_items());
 728
 729   // Remove one (down to two).
 730   ASSERT_TRUE(RemoveExtension(browser_action_c()));
 731
 732   // Highlight one of the two extensions.
 733   ExtensionIdList extension_ids;
 734   extension_ids.push_back(browser_action_a()->id());
 735   toolbar_model()->HighlightExtensions(
 736       extension_ids, ExtensionToolbarModel::HIGHLIGHT_WARNING);
 737   EXPECT_TRUE(toolbar_model()->is_highlighting());
 738   EXPECT_EQ(1u, num_toolbar_items());
 739   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 740
 741   // Adding a new extension should have no visible effect.
 742   ASSERT_TRUE(AddExtension(browser_action_c()));
 743   EXPECT_TRUE(toolbar_model()->is_highlighting());
 744   EXPECT_EQ(1u, num_toolbar_items());
 745   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 746
 747   // When we stop highlighting, we should see the new extension show up.
 748   toolbar_model()->StopHighlighting();
 749   EXPECT_FALSE(toolbar_model()->is_highlighting());
 750   EXPECT_EQ(3u, num_toolbar_items());
 751   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 752   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 753   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2u));
 754 }
 755
 756 // Test that the extension toolbar maintains the proper size, even after a pref
 757 // change.
 758 TEST_F(ExtensionToolbarModelUnitTest, ExtensionToolbarSizeAfterPrefChange) {
 759   Init();
 760
 761   // Add the three browser action extensions.
 762   ASSERT_TRUE(AddBrowserActionExtensions());
 763   EXPECT_EQ(3u, num_toolbar_items());
 764
 765   // Should be at max size.
 766   EXPECT_TRUE(toolbar_model()->all_icons_visible());
 767   EXPECT_EQ(num_toolbar_items(), toolbar_model()->visible_icon_count());
 768   toolbar_model()->OnExtensionToolbarPrefChange();
 769   // Should still be at max size.
 770   EXPECT_TRUE(toolbar_model()->all_icons_visible());
 771   EXPECT_EQ(num_toolbar_items(), toolbar_model()->visible_icon_count());
 772 }
 773
 774 // Test that, in the absence of the extension-action-redesign switch, the
 775 // model only contains extensions with browser actions.
 776 TEST_F(ExtensionToolbarModelUnitTest, TestToolbarExtensionTypesNoSwitch) {
 777   Init();
 778   ASSERT_TRUE(AddActionExtensions());
 779
 780   EXPECT_EQ(1u, num_toolbar_items());
 781   EXPECT_EQ(browser_action(), GetExtensionAtIndex(0u));
 782 }
 783
 784 // Test that, with the extension-action-redesign switch, the model contains
 785 // all types of extensions, except those which should not be displayed on the
 786 // toolbar (like component extensions).
 787 TEST_F(ExtensionToolbarModelUnitTest, TestToolbarExtensionTypesSwitch) {
 788   FeatureSwitch::ScopedOverride enable_redesign(
 789       FeatureSwitch::extension_action_redesign(), true);
 790   Init();
 791   ASSERT_TRUE(AddActionExtensions());
 792
 793   // With the switch on, extensions with page actions and no action should also
 794   // be displayed in the toolbar.
 795   EXPECT_EQ(3u, num_toolbar_items());
 796   EXPECT_EQ(browser_action(), GetExtensionAtIndex(0u));
 797   EXPECT_EQ(page_action(), GetExtensionAtIndex(1u));
 798   EXPECT_EQ(no_action(), GetExtensionAtIndex(2u));
 799 }
 800
 801 // Test that hiding actions on the toolbar results in their removal from the
 802 // model when the redesign switch is not enabled.
 803 TEST_F(ExtensionToolbarModelUnitTest,
 804        ExtensionToolbarActionsVisibilityNoSwitch) {
 805   Init();
 806
 807   ExtensionActionAPI* action_api = ExtensionActionAPI::Get(profile());
 808
 809   ASSERT_TRUE(AddBrowserActionExtensions());
 810   // Sanity check: Order should start as A B C.
 811   EXPECT_EQ(3u, num_toolbar_items());
 812   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 813   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 814   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2u));
 815
 816   // By default, all actions should be visible.
 817   EXPECT_TRUE(action_api->GetBrowserActionVisibility(browser_action_a()->id()));
 818   EXPECT_TRUE(action_api->GetBrowserActionVisibility(browser_action_b()->id()));
 819   EXPECT_TRUE(action_api->GetBrowserActionVisibility(browser_action_c()->id()));
 820
 821   // Hiding an action should result in its removal from the toolbar.
 822   action_api->SetBrowserActionVisibility(browser_action_b()->id(), false);
 823   EXPECT_FALSE(action_api->GetBrowserActionVisibility(
 824       browser_action_b()->id()));
 825   // Thus, there should now only be two items on the toolbar - A and C.
 826   EXPECT_EQ(2u, num_toolbar_items());
 827   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 828   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(1u));
 829
 830   // Resetting the visibility to 'true' should result in the extension being
 831   // added back at its original position.
 832   action_api->SetBrowserActionVisibility(browser_action_b()->id(), true);
 833   EXPECT_TRUE(action_api->GetBrowserActionVisibility(browser_action_b()->id()));
 834   // So the toolbar order should be A B C.
 835   EXPECT_EQ(3u, num_toolbar_items());
 836   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 837   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u));
 838   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2u));
 839 }
 840
 841 TEST_F(ExtensionToolbarModelUnitTest, ExtensionToolbarIncognitoModeTest) {
 842   Init();
 843   ASSERT_TRUE(AddBrowserActionExtensions());
 844
 845   // Give two extensions incognito access.
 846   // Note: We use ExtensionPrefs::SetIsIncognitoEnabled instead of
 847   // util::SetIsIncognitoEnabled because the latter tries to reload the
 848   // extension, which requries a filepath associated with the extension (and,
 849   // for this test, reloading the extension is irrelevant to us).
 850   ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile());
 851   extension_prefs->SetIsIncognitoEnabled(browser_action_b()->id(), true);
 852   extension_prefs->SetIsIncognitoEnabled(browser_action_c()->id(), true);
 853
 854   util::SetIsIncognitoEnabled(browser_action_b()->id(), profile(), true);
 855   util::SetIsIncognitoEnabled(browser_action_c()->id(), profile(), true);
 856
 857   // Move C to the second index.
 858   toolbar_model()->MoveExtensionIcon(browser_action_c()->id(), 1u);
 859   // Set visible count to 2 so that c is overflowed. State is A C [B].
 860   toolbar_model()->SetVisibleIconCount(2);
 861   EXPECT_EQ(1u, observer()->moved_count());
 862
 863   // Get an incognito profile and toolbar.
 864   ExtensionToolbarModel* incognito_model =
 865       extension_action_test_util::CreateToolbarModelForProfile(
 866           profile()->GetOffTheRecordProfile());
 867
 868   ExtensionToolbarModelTestObserver incognito_observer(incognito_model);
 869   EXPECT_EQ(0u, incognito_observer.moved_count());
 870
 871   // We should have two items, C and B, and the order should be preserved from
 872   // the original model.
 873   EXPECT_EQ(2u, incognito_model->toolbar_items().size());
 874   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(0u, incognito_model));
 875   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1u, incognito_model));
 876
 877   // Extensions in the overflow menu in the regular toolbar should remain in
 878   // overflow in the incognito toolbar. So, we should have C [B].
 879   EXPECT_EQ(1u, incognito_model->visible_icon_count());
 880   // The regular model should still have two icons visible.
 881   EXPECT_EQ(2u, toolbar_model()->visible_icon_count());
 882
 883   // Changing the incognito model size should not affect the regular model.
 884   incognito_model->SetVisibleIconCount(0);
 885   EXPECT_EQ(0u, incognito_model->visible_icon_count());
 886   EXPECT_EQ(2u, toolbar_model()->visible_icon_count());
 887
 888   // Expanding the incognito model to 2 should register as "all icons"
 889   // since it is all of the incognito-enabled extensions.
 890   incognito_model->SetVisibleIconCount(2u);
 891   EXPECT_EQ(2u, incognito_model->visible_icon_count());
 892   EXPECT_TRUE(incognito_model->all_icons_visible());
 893
 894   // Moving icons in the incognito toolbar should not affect the regular
 895   // toolbar. Incognito currently has C B...
 896   incognito_model->MoveExtensionIcon(browser_action_b()->id(), 0u);
 897   // So now it should be B C...
 898   EXPECT_EQ(1u, incognito_observer.moved_count());
 899   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(0u, incognito_model));
 900   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(1u, incognito_model));
 901   // ... and the regular toolbar should be unaffected.
 902   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0u));
 903   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(1u));
 904   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(2u));
 905
 906   // Similarly, the observer for the regular model should not have received
 907   // any updates.
 908   EXPECT_EQ(1u, observer()->moved_count());
 909
 910   // And performing moves on the regular model should have no effect on the
 911   // incognito model or its observers.
 912   toolbar_model()->MoveExtensionIcon(browser_action_c()->id(), 2u);
 913   EXPECT_EQ(2u, observer()->moved_count());
 914   EXPECT_EQ(1u, incognito_observer.moved_count());
 915 }
 916
 917 // Test that enabling extensions incognito with an active incognito profile
 918 // works.
 919 TEST_F(ExtensionToolbarModelUnitTest,
 920        ExtensionToolbarIncognitoEnableExtension) {
 921   Init();
 922
 923   const char* kManifest =
 924       "{"
 925       "  \"name\": \"%s\","
 926       "  \"version\": \"1.0\","
 927       "  \"manifest_version\": 2,"
 928       "  \"browser_action\": {}"
 929       "}";
 930
 931   // For this test, we need to have "real" extension files, because we need to
 932   // be able to reload them during the incognito process. Since the toolbar
 933   // needs to be notified of the reload, we need it this time (as opposed to
 934   // above, where we simply set the prefs before the incognito bar was
 935   // created.
 936   TestExtensionDir dir1;
 937   dir1.WriteManifest(base::StringPrintf(kManifest, "incognito1"));
 938   TestExtensionDir dir2;
 939   dir2.WriteManifest(base::StringPrintf(kManifest, "incognito2"));
 940
 941   TestExtensionDir* dirs[] = { &dir1, &dir2 };
 942   const Extension* extensions[] = { nullptr, nullptr };
 943   for (size_t i = 0; i < arraysize(dirs); ++i) {
 944     // The extension id will be calculated from the file path; we need this to
 945     // wait for the extension to load.
 946     base::FilePath path_for_id =
 947         base::MakeAbsoluteFilePath(dirs[i]->unpacked_path());
 948     std::string id = crx_file::id_util::GenerateIdForPath(path_for_id);
 949     TestExtensionRegistryObserver observer(registry(), id);
 950     UnpackedInstaller::Create(service())->Load(dirs[i]->unpacked_path());
 951     observer.WaitForExtensionLoaded();
 952     extensions[i] = registry()->enabled_extensions().GetByID(id);
 953     ASSERT_TRUE(extensions[i]);
 954   }
 955
 956   // For readability, alias to A and B. Since we'll be reloading these
 957   // extensions, we also can't rely on pointers.
 958   std::string extension_a = extensions[0]->id();
 959   std::string extension_b = extensions[1]->id();
 960
 961   // The first model should have both extensions visible.
 962   EXPECT_EQ(2u, toolbar_model()->toolbar_items().size());
 963   EXPECT_EQ(extension_a, GetExtensionAtIndex(0)->id());
 964   EXPECT_EQ(extension_b, GetExtensionAtIndex(1)->id());
 965
 966   // Set the model to only show one extension, so the order is A [B].
 967   toolbar_model()->SetVisibleIconCount(1u);
 968
 969   // Get an incognito profile and toolbar.
 970   ExtensionToolbarModel* incognito_model =
 971       extension_action_test_util::CreateToolbarModelForProfile(
 972           profile()->GetOffTheRecordProfile());
 973   ExtensionToolbarModelTestObserver incognito_observer(incognito_model);
 974
 975   // Right now, no extensions are enabled in incognito mode.
 976   EXPECT_EQ(0u, incognito_model->toolbar_items().size());
 977
 978   // Set extension b (which is overflowed) to be enabled in incognito. This
 979   // results in b reloading, so wait for it.
 980   {
 981     TestExtensionRegistryObserver observer(registry(), extension_b);
 982     util::SetIsIncognitoEnabled(extension_b, profile(), true);
 983     observer.WaitForExtensionLoaded();
 984   }
 985
 986   // Now, we should have one icon in the incognito bar. But, since B is
 987   // overflowed in the main bar, it shouldn't be visible.
 988   EXPECT_EQ(1u, incognito_model->toolbar_items().size());
 989   EXPECT_EQ(extension_b, GetExtensionAtIndex(0u, incognito_model)->id());
 990   EXPECT_EQ(0u, incognito_model->visible_icon_count());
 991
 992   // Also enable extension a for incognito (again, wait for the reload).
 993   {
 994     TestExtensionRegistryObserver observer(registry(), extension_a);
 995     util::SetIsIncognitoEnabled(extension_a, profile(), true);
 996     observer.WaitForExtensionLoaded();
 997   }
 998
 999   // Now, both extensions should be enabled in incognito mode. In addition, the
1000   // incognito toolbar should have expanded to show extension a (since it isn't
1001   // overflowed in the main bar).
1002   EXPECT_EQ(2u, incognito_model->toolbar_items().size());
1003   EXPECT_EQ(extension_a, GetExtensionAtIndex(0u, incognito_model)->id());
1004   EXPECT_EQ(extension_b, GetExtensionAtIndex(1u, incognito_model)->id());
1005   EXPECT_EQ(1u, incognito_model->visible_icon_count());
1006 }
1007
1008 // Test that hiding actions on the toolbar results in sending them to the
1009 // overflow menu when the redesign switch is enabled.
1010 TEST_F(ExtensionToolbarModelUnitTest,
1011        ExtensionToolbarActionsVisibilityWithSwitch) {
1012   FeatureSwitch::ScopedOverride enable_redesign(
1013       FeatureSwitch::extension_action_redesign(), true);
1014   Init();
1015
1016   // We choose to use all types of extensions here, since the misnamed
1017   // BrowserActionVisibility is now for toolbar visibility.
1018   ASSERT_TRUE(AddActionExtensions());
1019
1020   // For readability, alias extensions A B C.
1021   const Extension* extension_a = browser_action();
1022   const Extension* extension_b = page_action();
1023   const Extension* extension_c = no_action();
1024
1025   // Sanity check: Order should start as A B C, with all three visible.
1026   EXPECT_EQ(3u, num_toolbar_items());
1027   EXPECT_TRUE(toolbar_model()->all_icons_visible());
1028   EXPECT_EQ(extension_a, GetExtensionAtIndex(0u));
1029   EXPECT_EQ(extension_b, GetExtensionAtIndex(1u));
1030   EXPECT_EQ(extension_c, GetExtensionAtIndex(2u));
1031
1032   ExtensionActionAPI* action_api = ExtensionActionAPI::Get(profile());
1033
1034   // By default, all actions should be visible.
1035   EXPECT_TRUE(action_api->GetBrowserActionVisibility(extension_a->id()));
1036   EXPECT_TRUE(action_api->GetBrowserActionVisibility(extension_c->id()));
1037   EXPECT_TRUE(action_api->GetBrowserActionVisibility(extension_b->id()));
1038
1039   // Hiding an action should result in it being sent to the overflow menu.
1040   action_api->SetBrowserActionVisibility(extension_b->id(), false);
1041
1042   // Thus, the order should be A C B, with B in the overflow.
1043   EXPECT_EQ(3u, num_toolbar_items());
1044   EXPECT_EQ(2u, toolbar_model()->visible_icon_count());
1045   EXPECT_EQ(extension_a, GetExtensionAtIndex(0u));
1046   EXPECT_EQ(extension_c, GetExtensionAtIndex(1u));
1047   EXPECT_EQ(extension_b, GetExtensionAtIndex(2u));
1048
1049   // Hiding an extension's action should result in it being sent to the overflow
1050   // as well, but as the _first_ extension in the overflow.
1051   action_api->SetBrowserActionVisibility(extension_a->id(), false);
1052   // Thus, the order should be C A B, with A and B in the overflow.
1053   EXPECT_EQ(3u, num_toolbar_items());
1054   EXPECT_EQ(1u, toolbar_model()->visible_icon_count());
1055   EXPECT_EQ(extension_c, GetExtensionAtIndex(0u));
1056   EXPECT_EQ(extension_a, GetExtensionAtIndex(1u));
1057   EXPECT_EQ(extension_b, GetExtensionAtIndex(2u));
1058
1059   // Resetting A's visibility to true should send it back to the visible icons
1060   // (and should grow visible icons by 1), but it should be added to the end of
1061   // the visible icon list (not to its original position).
1062   action_api->SetBrowserActionVisibility(extension_a->id(), true);
1063   // So order is C A B, with only B in the overflow.
1064   EXPECT_EQ(3u, num_toolbar_items());
1065   EXPECT_EQ(2u, toolbar_model()->visible_icon_count());
1066   EXPECT_EQ(extension_c, GetExtensionAtIndex(0u));
1067   EXPECT_EQ(extension_a, GetExtensionAtIndex(1u));
1068   EXPECT_EQ(extension_b, GetExtensionAtIndex(2u));
1069
1070   // Resetting B to be visible should make the order C A B, with no overflow.
1071   action_api->SetBrowserActionVisibility(extension_b->id(), true);
1072   EXPECT_EQ(3u, num_toolbar_items());
1073   EXPECT_TRUE(toolbar_model()->all_icons_visible());
1074   EXPECT_EQ(extension_c, GetExtensionAtIndex(0u));
1075   EXPECT_EQ(extension_a, GetExtensionAtIndex(1u));
1076   EXPECT_EQ(extension_b, GetExtensionAtIndex(2u));
1077
1078   // Regression test for crbug.com/515963. Check that an extension's visibility
1079   // is updated when it is moved out because another extension was removed.
1080   toolbar_model()->SetVisibleIconCount(1);
1081   base::RunLoop().RunUntilIdle();
1082   EXPECT_FALSE(action_api->GetBrowserActionVisibility(extension_a->id()));
1083   service()->DisableExtension(extension_c->id(),
1084                               Extension::DISABLE_USER_ACTION);
1085   EXPECT_EQ(1u, toolbar_model()->visible_icon_count());
1086   EXPECT_TRUE(action_api->GetBrowserActionVisibility(extension_a->id()));
1087 }
1088
1089 // Test that observers receive no Added notifications until after the
1090 // ExtensionSystem has initialized.
1091 TEST_F(ExtensionToolbarModelUnitTest, ModelWaitsForExtensionSystemReady) {
1092   InitializeEmptyExtensionService();
1093   ExtensionToolbarModel* toolbar_model =
1094        extension_action_test_util::
1095            CreateToolbarModelForProfileWithoutWaitingForReady(profile());
1096   ExtensionToolbarModelTestObserver model_observer(toolbar_model);
1097   EXPECT_TRUE(AddBrowserActionExtensions());
1098
1099   // Since the model hasn't been initialized (the ExtensionSystem::ready task
1100   // hasn't been run), there should be no insertion notifications.
1101   EXPECT_EQ(0u, model_observer.inserted_count());
1102   EXPECT_EQ(0u, model_observer.initialized_count());
1103   EXPECT_FALSE(toolbar_model->extensions_initialized());
1104
1105   // Run the ready task.
1106   static_cast<TestExtensionSystem*>(ExtensionSystem::Get(profile()))->
1107       SetReady();
1108   // Run tasks posted to TestExtensionSystem.
1109   base::RunLoop().RunUntilIdle();
1110
1111   // We should still have no insertions, but should have an initialized count.
1112   EXPECT_TRUE(toolbar_model->extensions_initialized());
1113   EXPECT_EQ(0u, model_observer.inserted_count());
1114   EXPECT_EQ(1u, model_observer.initialized_count());
1115 }
1116
1117 // Check that the toolbar model correctly clears and reorders when it detects
1118 // a preference change.
1119 TEST_F(ExtensionToolbarModelUnitTest, ToolbarModelPrefChange) {
1120   Init();
1121
1122   ASSERT_TRUE(AddBrowserActionExtensions());
1123
1124   // We should start in the basic A B C order.
1125   ASSERT_TRUE(browser_action_a());
1126   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0));
1127   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1));
1128   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2));
1129   // Record the difference between the inserted and removed counts. The actual
1130   // value of the counts is not important, but we need to be sure that if we
1131   // call to remove any, we also add them back.
1132   size_t inserted_and_removed_difference =
1133       observer()->inserted_count() - observer()->removed_count();
1134
1135   // Assign a new order, B C A, and write it in the prefs.
1136   ExtensionIdList new_order;
1137   new_order.push_back(browser_action_b()->id());
1138   new_order.push_back(browser_action_c()->id());
1139   new_order.push_back(browser_action_a()->id());
1140   ExtensionPrefs::Get(profile())->SetToolbarOrder(new_order);
1141
1142   // Ensure everything has time to run.
1143   base::RunLoop().RunUntilIdle();
1144
1145   // The new order should be reflected in the model.
1146   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(0));
1147   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(1));
1148   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(2));
1149   EXPECT_EQ(inserted_and_removed_difference,
1150             observer()->inserted_count() - observer()->removed_count());
1151 }
1152
1153 TEST_F(ExtensionToolbarModelUnitTest, ComponentExtesionsAddedToEnd) {
1154   Init();
1155
1156   ASSERT_TRUE(AddBrowserActionExtensions());
1157
1158   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(0));
1159   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(1));
1160   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(2));
1161
1162   const char kName[] = "component";
1163   DictionaryBuilder manifest;
1164   manifest.Set("name", kName)
1165           .Set("description", "An extension")
1166           .Set("manifest_version", 2)
1167           .Set("version", "1.0.0")
1168           .Set("browser_action", DictionaryBuilder().Pass());
1169   scoped_refptr<const Extension> component_extension =
1170       ExtensionBuilder().SetManifest(manifest.Pass())
1171                         .SetID(crx_file::id_util::GenerateId(kName))
1172                         .SetLocation(Manifest::COMPONENT)
1173                         .Build();
1174   service()->AddExtension(component_extension.get());
1175
1176   EXPECT_EQ(component_extension.get(), GetExtensionAtIndex(0));
1177   EXPECT_EQ(browser_action_a(), GetExtensionAtIndex(1));
1178   EXPECT_EQ(browser_action_b(), GetExtensionAtIndex(2));
1179   EXPECT_EQ(browser_action_c(), GetExtensionAtIndex(3));
1180 }
1181
1182 TEST_F(ExtensionToolbarModelUnitTest,
1183        ToolbarModelHighlightsForToolbarRedesign) {
1184   FeatureSwitch::ScopedOverride enable_redesign(
1185       FeatureSwitch::extension_action_redesign(), true);
1186   InitializeEmptyExtensionService();
1187   EXPECT_TRUE(AddActionExtensions());
1188   ExtensionToolbarModel* toolbar_model =
1189       extension_action_test_util::CreateToolbarModelForProfile(profile());
1190   EXPECT_TRUE(toolbar_model);
1191   base::RunLoop().RunUntilIdle();
1192
1193   EXPECT_TRUE(ExtensionToolbarIconSurfacingBubbleDelegate::ShouldShowForProfile(
1194       profile()));
1195   EXPECT_TRUE(toolbar_model->is_highlighting());
1196   EXPECT_EQ(ExtensionToolbarModel::HIGHLIGHT_INFO,
1197             toolbar_model->highlight_type());
1198   EXPECT_EQ(3u, toolbar_model->visible_icon_count());
1199   EXPECT_EQ(3u, toolbar_model->toolbar_items().size());
1200
1201   scoped_ptr<ToolbarActionsBarBubbleDelegate> bubble(
1202       new ExtensionToolbarIconSurfacingBubbleDelegate(profile()));
1203   bubble->OnBubbleClosed(ToolbarActionsBarBubbleDelegate::CLOSE_DISMISS);
1204
1205   EXPECT_FALSE(toolbar_model->is_highlighting());
1206   EXPECT_EQ(ExtensionToolbarModel::HIGHLIGHT_NONE,
1207             toolbar_model->highlight_type());
1208 }
1209
1210 }  // namespace extensions