chrome/browser/extensions/extension_toolbar_model_browsertest.cc

   1 // Copyright (c) 2011 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/macros.h"
   6 #include "chrome/browser/extensions/extension_browsertest.h"
   7 #include "chrome/browser/extensions/extension_toolbar_model.h"
   8 #include "chrome/browser/profiles/profile.h"
   9 #include "chrome/browser/ui/browser.h"
  10 #include "chrome/test/base/in_process_browser_test.h"
  11
  12 namespace extensions {
  13
  14 // An InProcessBrowserTest for testing the ExtensionToolbarModel.
  15 // TODO(erikkay) It's unfortunate that this needs to be an in-proc browser test.
  16 // It would be nice to refactor things so that ExtensionService could run
  17 // without so much of the browser in place.
  18 class ExtensionToolbarModelTest : public ExtensionBrowserTest,
  19                                   public ExtensionToolbarModel::Observer {
  20  public:
  21   virtual void SetUp() {
  22     inserted_count_ = 0;
  23     removed_count_ = 0;
  24     moved_count_ = 0;
  25     highlight_mode_count_ = 0;
  26
  27     ExtensionBrowserTest::SetUp();
  28   }
  29
  30   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  31     ExtensionBrowserTest::SetUpCommandLine(command_line);
  32 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
  33     command_line->AppendSwitchNative(
  34         "vmodule", "*extension_toolbar_model*=4,*browser_actions_container*=4");
  35 #endif  // defined(OS_LINUX) || defined(OS_CHROMEOS)
  36   }
  37
  38   virtual void SetUpOnMainThread() OVERRIDE {
  39     model_ = ExtensionToolbarModel::Get(browser()->profile());
  40     model_->AddObserver(this);
  41   }
  42
  43   virtual void CleanUpOnMainThread() OVERRIDE {
  44     model_->RemoveObserver(this);
  45   }
  46
  47   virtual void BrowserActionAdded(const Extension* extension,
  48                                   int index) OVERRIDE {
  49     inserted_count_++;
  50   }
  51
  52   virtual void BrowserActionRemoved(const Extension* extension) OVERRIDE {
  53     removed_count_++;
  54   }
  55
  56   virtual void BrowserActionMoved(const Extension* extension,
  57                                   int index) OVERRIDE {
  58     moved_count_++;
  59   }
  60
  61   virtual void HighlightModeChanged(bool is_highlighting) OVERRIDE {
  62     // Add one if highlighting, subtract one if not.
  63     highlight_mode_count_ += is_highlighting ? 1 : -1;
  64   }
  65
  66   const Extension* ExtensionAt(int index) {
  67     const ExtensionList& toolbar_items = model_->toolbar_items();
  68     for (ExtensionList::const_iterator i = toolbar_items.begin();
  69          i < toolbar_items.end(); ++i) {
  70       if (index-- == 0)
  71         return i->get();
  72     }
  73     return NULL;
  74   }
  75
  76  protected:
  77   ExtensionToolbarModel* model_;
  78
  79   int inserted_count_;
  80   int removed_count_;
  81   int moved_count_;
  82   int highlight_mode_count_;
  83 };
  84
  85 IN_PROC_BROWSER_TEST_F(ExtensionToolbarModelTest, Basic) {
  86   // Load an extension with no browser action.
  87   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("api_test")
  88                                           .AppendASCII("browser_action")
  89                                           .AppendASCII("none")));
  90
  91   // This extension should not be in the model (has no browser action).
  92   EXPECT_EQ(0, inserted_count_);
  93   EXPECT_EQ(0u, model_->toolbar_items().size());
  94   ASSERT_EQ(NULL, ExtensionAt(0));
  95
  96   // Load an extension with a browser action.
  97   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("api_test")
  98                                           .AppendASCII("browser_action")
  99                                           .AppendASCII("basics")));
 100
 101   // We should now find our extension in the model.
 102   EXPECT_EQ(1, inserted_count_);
 103   EXPECT_EQ(1u, model_->toolbar_items().size());
 104   const Extension* extension = ExtensionAt(0);
 105   ASSERT_TRUE(NULL != extension);
 106   EXPECT_STREQ("A browser action with no icon that makes the page red",
 107                extension->name().c_str());
 108
 109   // Should be a no-op, but still fires the events.
 110   model_->MoveBrowserAction(extension, 0);
 111   EXPECT_EQ(1, moved_count_);
 112   EXPECT_EQ(1u, model_->toolbar_items().size());
 113   const Extension* extension2 = ExtensionAt(0);
 114   EXPECT_EQ(extension, extension2);
 115
 116   UnloadExtension(extension->id());
 117   EXPECT_EQ(1, removed_count_);
 118   EXPECT_EQ(0u, model_->toolbar_items().size());
 119   EXPECT_EQ(NULL, ExtensionAt(0));
 120 }
 121
 122 #if defined(OS_MACOSX)
 123 // Flaky on Mac 10.8 Blink canary bots: http://crbug.com/166580
 124 #define MAYBE_ReorderAndReinsert DISABLED_ReorderAndReinsert
 125 #else
 126 #define MAYBE_ReorderAndReinsert ReorderAndReinsert
 127 #endif
 128 IN_PROC_BROWSER_TEST_F(ExtensionToolbarModelTest, MAYBE_ReorderAndReinsert) {
 129   // Load an extension with a browser action.
 130   base::FilePath extension_a_path(test_data_dir_.AppendASCII("api_test")
 131                                           .AppendASCII("browser_action")
 132                                           .AppendASCII("basics"));
 133   ASSERT_TRUE(LoadExtension(extension_a_path));
 134
 135   // First extension loaded.
 136   EXPECT_EQ(1, inserted_count_);
 137   EXPECT_EQ(1u, model_->toolbar_items().size());
 138   const Extension* extensionA = ExtensionAt(0);
 139   ASSERT_TRUE(NULL != extensionA);
 140   EXPECT_STREQ("A browser action with no icon that makes the page red",
 141                extensionA->name().c_str());
 142
 143   // Load another extension with a browser action.
 144   base::FilePath extension_b_path(test_data_dir_.AppendASCII("api_test")
 145                                           .AppendASCII("browser_action")
 146                                           .AppendASCII("popup"));
 147   ASSERT_TRUE(LoadExtension(extension_b_path));
 148
 149   // Second extension loaded.
 150   EXPECT_EQ(2, inserted_count_);
 151   EXPECT_EQ(2u, model_->toolbar_items().size());
 152   const Extension* extensionB = ExtensionAt(1);
 153   ASSERT_TRUE(NULL != extensionB);
 154   EXPECT_STREQ("Popup tester", extensionB->name().c_str());
 155
 156   // Load yet another extension with a browser action.
 157   base::FilePath extension_c_path(test_data_dir_.AppendASCII("api_test")
 158                                           .AppendASCII("browser_action")
 159                                           .AppendASCII("remove_popup"));
 160   ASSERT_TRUE(LoadExtension(extension_c_path));
 161
 162   // Third extension loaded.
 163   EXPECT_EQ(3, inserted_count_);
 164   EXPECT_EQ(3u, model_->toolbar_items().size());
 165   const Extension* extensionC = ExtensionAt(2);
 166   ASSERT_TRUE(NULL != extensionC);
 167   EXPECT_STREQ("A page action which removes a popup.",
 168                extensionC->name().c_str());
 169
 170   // Order is now A, B, C. Let's put C first.
 171   model_->MoveBrowserAction(extensionC, 0);
 172   EXPECT_EQ(1, moved_count_);
 173   EXPECT_EQ(3u, model_->toolbar_items().size());
 174   EXPECT_EQ(extensionC, ExtensionAt(0));
 175   EXPECT_EQ(extensionA, ExtensionAt(1));
 176   EXPECT_EQ(extensionB, ExtensionAt(2));
 177   EXPECT_EQ(NULL, ExtensionAt(3));
 178
 179   // Order is now C, A, B. Let's put A last.
 180   model_->MoveBrowserAction(extensionA, 2);
 181   EXPECT_EQ(2, moved_count_);
 182   EXPECT_EQ(3u, model_->toolbar_items().size());
 183   EXPECT_EQ(extensionC, ExtensionAt(0));
 184   EXPECT_EQ(extensionB, ExtensionAt(1));
 185   EXPECT_EQ(extensionA, ExtensionAt(2));
 186   EXPECT_EQ(NULL, ExtensionAt(3));
 187
 188   // Order is now C, B, A. Let's remove B.
 189   std::string idB = extensionB->id();
 190   UnloadExtension(idB);
 191   EXPECT_EQ(1, removed_count_);
 192   EXPECT_EQ(2u, model_->toolbar_items().size());
 193   EXPECT_EQ(extensionC, ExtensionAt(0));
 194   EXPECT_EQ(extensionA, ExtensionAt(1));
 195   EXPECT_EQ(NULL, ExtensionAt(2));
 196
 197   // Load extension B again.
 198   ASSERT_TRUE(LoadExtension(extension_b_path));
 199
 200   // Extension B loaded again.
 201   EXPECT_EQ(4, inserted_count_);
 202   EXPECT_EQ(3u, model_->toolbar_items().size());
 203   // Make sure it gets its old spot in the list. We should get the same
 204   // extension again, otherwise the order has changed.
 205   ASSERT_STREQ(idB.c_str(), ExtensionAt(1)->id().c_str());
 206
 207   // Unload B again.
 208   UnloadExtension(idB);
 209   EXPECT_EQ(2, removed_count_);
 210   EXPECT_EQ(2u, model_->toolbar_items().size());
 211   EXPECT_EQ(extensionC, ExtensionAt(0));
 212   EXPECT_EQ(extensionA, ExtensionAt(1));
 213   EXPECT_EQ(NULL, ExtensionAt(2));
 214
 215   // Order is now C, A. Flip it.
 216   model_->MoveBrowserAction(extensionA, 0);
 217   EXPECT_EQ(3, moved_count_);
 218   EXPECT_EQ(2u, model_->toolbar_items().size());
 219   EXPECT_EQ(extensionA, ExtensionAt(0));
 220   EXPECT_EQ(extensionC, ExtensionAt(1));
 221   EXPECT_EQ(NULL, ExtensionAt(2));
 222
 223   // Move A to the location it already occupies.
 224   model_->MoveBrowserAction(extensionA, 0);
 225   EXPECT_EQ(4, moved_count_);
 226   EXPECT_EQ(2u, model_->toolbar_items().size());
 227   EXPECT_EQ(extensionA, ExtensionAt(0));
 228   EXPECT_EQ(extensionC, ExtensionAt(1));
 229   EXPECT_EQ(NULL, ExtensionAt(2));
 230
 231   // Order is now A, C. Remove C.
 232   std::string idC = extensionC->id();
 233   UnloadExtension(idC);
 234   EXPECT_EQ(3, removed_count_);
 235   EXPECT_EQ(1u, model_->toolbar_items().size());
 236   EXPECT_EQ(extensionA, ExtensionAt(0));
 237   EXPECT_EQ(NULL, ExtensionAt(1));
 238
 239   // Load extension C again.
 240   ASSERT_TRUE(LoadExtension(extension_c_path));
 241
 242   // Extension C loaded again.
 243   EXPECT_EQ(5, inserted_count_);
 244   EXPECT_EQ(2u, model_->toolbar_items().size());
 245   // Make sure it gets its old spot in the list (at the very end).
 246   ASSERT_STREQ(idC.c_str(), ExtensionAt(1)->id().c_str());
 247 }
 248
 249 IN_PROC_BROWSER_TEST_F(ExtensionToolbarModelTest, UnloadAndDisableMultiple) {
 250   // Load three extensions with browser action.
 251   base::FilePath extension_a_path(test_data_dir_.AppendASCII("api_test")
 252                                                 .AppendASCII("browser_action")
 253                                                 .AppendASCII("basics"));
 254   ASSERT_TRUE(LoadExtension(extension_a_path));
 255   base::FilePath extension_b_path(test_data_dir_.AppendASCII("api_test")
 256                                                 .AppendASCII("browser_action")
 257                                                 .AppendASCII("popup"));
 258   ASSERT_TRUE(LoadExtension(extension_b_path));
 259   base::FilePath extension_c_path(test_data_dir_.AppendASCII("api_test")
 260                                                 .AppendASCII("browser_action")
 261                                                 .AppendASCII("remove_popup"));
 262   ASSERT_TRUE(LoadExtension(extension_c_path));
 263
 264   // Verify we got the three we asked for and that they are ordered as: A, B, C.
 265   const Extension* extensionA = ExtensionAt(0);
 266   const Extension* extensionB = ExtensionAt(1);
 267   const Extension* extensionC = ExtensionAt(2);
 268   std::string idA = extensionA->id();
 269   std::string idB = extensionB->id();
 270   std::string idC = extensionC->id();
 271   EXPECT_STREQ("A browser action with no icon that makes the page red",
 272                extensionA->name().c_str());
 273   EXPECT_STREQ("Popup tester", extensionB->name().c_str());
 274   EXPECT_STREQ("A page action which removes a popup.",
 275                extensionC->name().c_str());
 276
 277   // Unload B, then C, then A.
 278   UnloadExtension(idB);
 279   UnloadExtension(idC);
 280   UnloadExtension(idA);
 281
 282   // Load C, then A, then B.
 283   ASSERT_TRUE(LoadExtension(extension_c_path));
 284   ASSERT_TRUE(LoadExtension(extension_a_path));
 285   ASSERT_TRUE(LoadExtension(extension_b_path));
 286   EXPECT_EQ(0, moved_count_);
 287
 288   extensionA = ExtensionAt(0);
 289   extensionB = ExtensionAt(1);
 290   extensionC = ExtensionAt(2);
 291
 292   // Make sure we get the order we started with (A, B, C).
 293   EXPECT_STREQ(idA.c_str(), extensionA->id().c_str());
 294   EXPECT_STREQ(idB.c_str(), extensionB->id().c_str());
 295   EXPECT_STREQ(idC.c_str(), extensionC->id().c_str());
 296
 297   // Put C in the middle and A to the end.
 298   model_->MoveBrowserAction(extensionC, 1);
 299   model_->MoveBrowserAction(extensionA, 2);
 300
 301   // Make sure we get this order (C, B, A).
 302   EXPECT_STREQ(idC.c_str(), ExtensionAt(0)->id().c_str());
 303   EXPECT_STREQ(idB.c_str(), ExtensionAt(1)->id().c_str());
 304   EXPECT_STREQ(idA.c_str(), ExtensionAt(2)->id().c_str());
 305
 306   // Disable B, then C, then A.
 307   DisableExtension(idB);
 308   DisableExtension(idC);
 309   DisableExtension(idA);
 310
 311   // Enable C, then A, then B.
 312   EnableExtension(idA);
 313   EnableExtension(idB);
 314   EnableExtension(idC);
 315
 316   // Make sure we get the order we started with.
 317   EXPECT_STREQ(idC.c_str(), ExtensionAt(0)->id().c_str());
 318   EXPECT_STREQ(idB.c_str(), ExtensionAt(1)->id().c_str());
 319   EXPECT_STREQ(idA.c_str(), ExtensionAt(2)->id().c_str());
 320 }
 321
 322 IN_PROC_BROWSER_TEST_F(ExtensionToolbarModelTest, Uninstall) {
 323   // Load two extensions with browser action.
 324   base::FilePath extension_a_path(test_data_dir_.AppendASCII("api_test")
 325                                                 .AppendASCII("browser_action")
 326                                                 .AppendASCII("basics"));
 327   ASSERT_TRUE(LoadExtension(extension_a_path));
 328   base::FilePath extension_b_path(test_data_dir_.AppendASCII("api_test")
 329                                                 .AppendASCII("browser_action")
 330                                                 .AppendASCII("popup"));
 331   ASSERT_TRUE(LoadExtension(extension_b_path));
 332
 333   // Verify we got what we came for.
 334   const Extension* extensionA = ExtensionAt(0);
 335   const Extension* extensionB = ExtensionAt(1);
 336   std::string idA = extensionA->id();
 337   std::string idB = extensionB->id();
 338   EXPECT_STREQ("A browser action with no icon that makes the page red",
 339                extensionA->name().c_str());
 340   EXPECT_STREQ("Popup tester", extensionB->name().c_str());
 341
 342   // Order is now A, B. Make B first.
 343   model_->MoveBrowserAction(extensionB, 0);
 344
 345   // Order is now B, A. Uninstall Extension B.
 346   UninstallExtension(idB);
 347
 348   // List contains only A now. Validate that.
 349   EXPECT_STREQ(idA.c_str(), ExtensionAt(0)->id().c_str());
 350   EXPECT_EQ(1u, model_->toolbar_items().size());
 351
 352   // Load Extension B again.
 353   ASSERT_TRUE(LoadExtension(extension_b_path));
 354   EXPECT_EQ(2u, model_->toolbar_items().size());
 355
 356   // Make sure Extension B is _not_ first (should have been forgotten at
 357   // uninstall time).
 358   EXPECT_STREQ(idA.c_str(), ExtensionAt(0)->id().c_str());
 359   EXPECT_STREQ(idB.c_str(), ExtensionAt(1)->id().c_str());
 360 }
 361
 362 IN_PROC_BROWSER_TEST_F(ExtensionToolbarModelTest, ReorderOnPrefChange) {
 363   // Load three extensions with browser action.
 364   base::FilePath extension_a_path(test_data_dir_.AppendASCII("api_test")
 365                                                 .AppendASCII("browser_action")
 366                                                 .AppendASCII("basics"));
 367   ASSERT_TRUE(LoadExtension(extension_a_path));
 368   base::FilePath extension_b_path(test_data_dir_.AppendASCII("api_test")
 369                                                 .AppendASCII("browser_action")
 370                                                 .AppendASCII("popup"));
 371   ASSERT_TRUE(LoadExtension(extension_b_path));
 372   base::FilePath extension_c_path(test_data_dir_.AppendASCII("api_test")
 373                                                 .AppendASCII("browser_action")
 374                                                 .AppendASCII("remove_popup"));
 375   ASSERT_TRUE(LoadExtension(extension_c_path));
 376   std::string id_a = ExtensionAt(0)->id();
 377   std::string id_b = ExtensionAt(1)->id();
 378   std::string id_c = ExtensionAt(2)->id();
 379
 380   // Change value of toolbar preference.
 381   ExtensionIdList new_order;
 382   new_order.push_back(id_c);
 383   new_order.push_back(id_b);
 384   ExtensionPrefs::Get(browser()->profile())->SetToolbarOrder(new_order);
 385
 386   // Verify order is changed.
 387   EXPECT_EQ(id_c, ExtensionAt(0)->id());
 388   EXPECT_EQ(id_b, ExtensionAt(1)->id());
 389   EXPECT_EQ(id_a, ExtensionAt(2)->id());
 390 }
 391
 392 IN_PROC_BROWSER_TEST_F(ExtensionToolbarModelTest, HighlightMode) {
 393   EXPECT_FALSE(model_->HighlightExtensions(ExtensionIdList()));
 394   EXPECT_EQ(0, highlight_mode_count_);
 395
 396   // Load three extensions with browser action.
 397   base::FilePath extension_a_path(test_data_dir_.AppendASCII("api_test")
 398                                                 .AppendASCII("browser_action")
 399                                                 .AppendASCII("basics"));
 400   ASSERT_TRUE(LoadExtension(extension_a_path));
 401   base::FilePath extension_b_path(test_data_dir_.AppendASCII("api_test")
 402                                                 .AppendASCII("browser_action")
 403                                                 .AppendASCII("popup"));
 404   ASSERT_TRUE(LoadExtension(extension_b_path));
 405   base::FilePath extension_c_path(test_data_dir_.AppendASCII("api_test")
 406                                                 .AppendASCII("browser_action")
 407                                                 .AppendASCII("remove_popup"));
 408   ASSERT_TRUE(LoadExtension(extension_c_path));
 409   std::string id_a = ExtensionAt(0)->id();
 410   std::string id_b = ExtensionAt(1)->id();
 411   std::string id_c = ExtensionAt(2)->id();
 412
 413   // Highlight one extension.
 414   ExtensionIdList extension_ids;
 415   extension_ids.push_back(id_b);
 416   model_->HighlightExtensions(extension_ids);
 417   EXPECT_EQ(1, highlight_mode_count_);
 418   EXPECT_TRUE(model_->is_highlighting());
 419
 420   EXPECT_EQ(1u, model_->toolbar_items().size());
 421   EXPECT_EQ(id_b, ExtensionAt(0)->id());
 422
 423   // Stop highlighting.
 424   model_->StopHighlighting();
 425   EXPECT_EQ(0, highlight_mode_count_);
 426   EXPECT_FALSE(model_->is_highlighting());
 427
 428   // Verify that the extensions are back to normal.
 429   EXPECT_EQ(3u, model_->toolbar_items().size());
 430   EXPECT_EQ(id_a, ExtensionAt(0)->id());
 431   EXPECT_EQ(id_b, ExtensionAt(1)->id());
 432   EXPECT_EQ(id_c, ExtensionAt(2)->id());
 433
 434   // Call stop highlighting a second time (shouldn't be notified).
 435   model_->StopHighlighting();
 436   EXPECT_EQ(0, highlight_mode_count_);
 437   EXPECT_FALSE(model_->is_highlighting());
 438
 439   // Highlight all extensions.
 440   extension_ids.clear();
 441   extension_ids.push_back(id_a);
 442   extension_ids.push_back(id_b);
 443   extension_ids.push_back(id_c);
 444   model_->HighlightExtensions(extension_ids);
 445   EXPECT_EQ(1, highlight_mode_count_);
 446   EXPECT_EQ(3u, model_->toolbar_items().size());
 447   EXPECT_EQ(id_a, ExtensionAt(0)->id());
 448   EXPECT_EQ(id_b, ExtensionAt(1)->id());
 449   EXPECT_EQ(id_c, ExtensionAt(2)->id());
 450
 451   // Highlight only extension b (shrink the highlight list).
 452   extension_ids.clear();
 453   extension_ids.push_back(id_b);
 454   model_->HighlightExtensions(extension_ids);
 455   EXPECT_EQ(2, highlight_mode_count_);
 456   EXPECT_EQ(1u, model_->toolbar_items().size());
 457   EXPECT_EQ(id_b, ExtensionAt(0)->id());
 458
 459   // Highlight extensions a and b (grow the highlight list).
 460   extension_ids.clear();
 461   extension_ids.push_back(id_a);
 462   extension_ids.push_back(id_b);
 463   model_->HighlightExtensions(extension_ids);
 464   EXPECT_EQ(3, highlight_mode_count_);
 465   EXPECT_EQ(2u, model_->toolbar_items().size());
 466   EXPECT_EQ(id_a, ExtensionAt(0)->id());
 467   EXPECT_EQ(id_b, ExtensionAt(1)->id());
 468
 469   // Highlight no extensions (empty the highlight list).
 470   extension_ids.clear();
 471   model_->HighlightExtensions(extension_ids);
 472   EXPECT_EQ(2, highlight_mode_count_);
 473   EXPECT_FALSE(model_->is_highlighting());
 474   EXPECT_EQ(id_a, ExtensionAt(0)->id());
 475   EXPECT_EQ(id_b, ExtensionAt(1)->id());
 476   EXPECT_EQ(id_c, ExtensionAt(2)->id());
 477 }
 478
 479 #if defined(OS_MACOSX)
 480 // Flaky on Mac bots: http://crbug.com/358752
 481 #define MAYBE_HighlightModeRemove DISABLED_HighlightModeRemove
 482 #else
 483 #define MAYBE_HighlightModeRemove HighlightModeRemove
 484 #endif
 485
 486 IN_PROC_BROWSER_TEST_F(ExtensionToolbarModelTest, MAYBE_HighlightModeRemove) {
 487   // Load three extensions with browser action.
 488   base::FilePath extension_a_path(test_data_dir_.AppendASCII("api_test")
 489                                                 .AppendASCII("browser_action")
 490                                                 .AppendASCII("basics"));
 491   ASSERT_TRUE(LoadExtension(extension_a_path));
 492   base::FilePath extension_b_path(test_data_dir_.AppendASCII("api_test")
 493                                                 .AppendASCII("browser_action")
 494                                                 .AppendASCII("popup"));
 495   ASSERT_TRUE(LoadExtension(extension_b_path));
 496   base::FilePath extension_c_path(test_data_dir_.AppendASCII("api_test")
 497                                                 .AppendASCII("browser_action")
 498                                                 .AppendASCII("remove_popup"));
 499   ASSERT_TRUE(LoadExtension(extension_c_path));
 500   std::string id_a = ExtensionAt(0)->id();
 501   std::string id_b = ExtensionAt(1)->id();
 502   std::string id_c = ExtensionAt(2)->id();
 503
 504   // Highlight two of the extensions.
 505   ExtensionIdList extension_ids;
 506   extension_ids.push_back(id_a);
 507   extension_ids.push_back(id_b);
 508   model_->HighlightExtensions(extension_ids);
 509   EXPECT_TRUE(model_->is_highlighting());
 510   EXPECT_EQ(1, highlight_mode_count_);
 511   EXPECT_EQ(2u, model_->toolbar_items().size());
 512
 513   // Disable one of them - only one should remain highlighted.
 514   DisableExtension(id_a);
 515   EXPECT_TRUE(model_->is_highlighting());
 516   EXPECT_EQ(1u, model_->toolbar_items().size());
 517   EXPECT_EQ(id_b, ExtensionAt(0)->id());
 518
 519   // Uninstall the remaining highlighted extension. This should result in
 520   // highlight mode exiting.
 521   UninstallExtension(id_b);
 522   EXPECT_FALSE(model_->is_highlighting());
 523   EXPECT_EQ(0, highlight_mode_count_);
 524   EXPECT_EQ(1u, model_->toolbar_items().size());
 525   EXPECT_EQ(id_c, ExtensionAt(0)->id());
 526
 527   // Test that removing an unhighlighted extension still works.
 528   // Reinstall extension b, and then highlight extension c.
 529   ASSERT_TRUE(LoadExtension(extension_b_path));
 530   EXPECT_EQ(id_b, ExtensionAt(1)->id());
 531   extension_ids.clear();
 532   extension_ids.push_back(id_c);
 533   model_->HighlightExtensions(extension_ids);
 534   EXPECT_EQ(1, highlight_mode_count_);
 535   EXPECT_TRUE(model_->is_highlighting());
 536   EXPECT_EQ(1u, model_->toolbar_items().size());
 537   EXPECT_EQ(id_c, ExtensionAt(0)->id());
 538
 539   // Uninstalling b should not have visible impact.
 540   UninstallExtension(id_b);
 541   EXPECT_TRUE(model_->is_highlighting());
 542   EXPECT_EQ(1, highlight_mode_count_);
 543   EXPECT_EQ(1u, model_->toolbar_items().size());
 544   EXPECT_EQ(id_c, ExtensionAt(0)->id());
 545
 546   // When we stop, only extension c should remain.
 547   model_->StopHighlighting();
 548   EXPECT_FALSE(model_->is_highlighting());
 549   EXPECT_EQ(0, highlight_mode_count_);
 550   EXPECT_EQ(1u, model_->toolbar_items().size());
 551   EXPECT_EQ(id_c, ExtensionAt(0)->id());
 552 }
 553
 554 IN_PROC_BROWSER_TEST_F(ExtensionToolbarModelTest, HighlightModeAdd) {
 555   // Load two extensions with browser action.
 556   base::FilePath extension_a_path(test_data_dir_.AppendASCII("api_test")
 557                                                 .AppendASCII("browser_action")
 558                                                 .AppendASCII("basics"));
 559   ASSERT_TRUE(LoadExtension(extension_a_path));
 560   base::FilePath extension_b_path(test_data_dir_.AppendASCII("api_test")
 561                                                 .AppendASCII("browser_action")
 562                                                 .AppendASCII("popup"));
 563   ASSERT_TRUE(LoadExtension(extension_b_path));
 564   std::string id_a = ExtensionAt(0)->id();
 565   std::string id_b = ExtensionAt(1)->id();
 566
 567   // Highlight one of the extensions.
 568   ExtensionIdList extension_ids;
 569   extension_ids.push_back(id_a);
 570   model_->HighlightExtensions(extension_ids);
 571   EXPECT_TRUE(model_->is_highlighting());
 572   EXPECT_EQ(1u, model_->toolbar_items().size());
 573   EXPECT_EQ(id_a, ExtensionAt(0)->id());
 574
 575   // Adding the new extension should have no visible effect.
 576   base::FilePath extension_c_path(test_data_dir_.AppendASCII("api_test")
 577                                                 .AppendASCII("browser_action")
 578                                                 .AppendASCII("remove_popup"));
 579   const Extension* extension_c = LoadExtension(extension_c_path);
 580   ASSERT_TRUE(extension_c);
 581   std::string id_c = extension_c->id();
 582   EXPECT_TRUE(model_->is_highlighting());
 583   EXPECT_EQ(1u, model_->toolbar_items().size());
 584   EXPECT_EQ(id_a, ExtensionAt(0)->id());
 585
 586   // When we stop highlighting, we should see the new extension show up.
 587   model_->StopHighlighting();
 588   EXPECT_FALSE(model_->is_highlighting());
 589   EXPECT_EQ(3u, model_->toolbar_items().size());
 590   EXPECT_EQ(id_a, ExtensionAt(0)->id());
 591   EXPECT_EQ(id_b, ExtensionAt(1)->id());
 592   EXPECT_EQ(id_c, ExtensionAt(2)->id());
 593 }
 594
 595 // Test is flaky (see crbug.com/379170), but currently enabled to gather traces.
 596 // If it fails, ping Finnur.
 597 IN_PROC_BROWSER_TEST_F(ExtensionToolbarModelTest, SizeAfterPrefChange) {
 598   // Load two extensions with browser action.
 599   base::FilePath extension_a_path(test_data_dir_.AppendASCII("api_test")
 600                                                 .AppendASCII("browser_action")
 601                                                 .AppendASCII("basics"));
 602   VLOG(4) << "Loading [basics]";
 603   ASSERT_TRUE(LoadExtension(extension_a_path));
 604   base::FilePath extension_b_path(test_data_dir_.AppendASCII("api_test")
 605                                                 .AppendASCII("browser_action")
 606                                                 .AppendASCII("popup"));
 607   VLOG(4) << "Loading [popup]";
 608   ASSERT_TRUE(LoadExtension(extension_b_path));
 609   std::string id_a = ExtensionAt(0)->id();
 610   std::string id_b = ExtensionAt(1)->id();
 611
 612   VLOG(4) << "GetVisibleIconCount";
 613
 614   // Should be at max size (-1).
 615   EXPECT_EQ(-1, model_->GetVisibleIconCount());
 616
 617   VLOG(4) << "OnExtensionToolbarPrefChange";
 618   model_->OnExtensionToolbarPrefChange();
 619
 620   VLOG(4) << "GetVisibleIconCount";
 621
 622   // Should still be at max size.
 623   EXPECT_EQ(-1, model_->GetVisibleIconCount());
 624 }
 625
 626 }  // namespace extensions