chrome/browser/ui/toolbar/browser_actions_bar_browsertest.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 "chrome/browser/ui/toolbar/browser_actions_bar_browsertest.h"
   6
   7 #include "base/run_loop.h"
   8 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
   9 #include "chrome/browser/extensions/browser_action_test_util.h"
  10 #include "chrome/browser/extensions/extension_action.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_browsertest.h"
  14 #include "chrome/browser/extensions/extension_service.h"
  15 #include "chrome/browser/extensions/extension_toolbar_model.h"
  16 #include "chrome/browser/sessions/session_tab_helper.h"
  17 #include "chrome/browser/ui/extensions/extension_action_view_controller.h"
  18 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  19 #include "chrome/browser/ui/toolbar/toolbar_action_view_controller.h"
  20 #include "chrome/browser/ui/toolbar/toolbar_actions_bar.h"
  21 #include "components/crx_file/id_util.h"
  22 #include "content/public/browser/notification_service.h"
  23 #include "content/public/test/test_utils.h"
  24 #include "extensions/browser/extension_prefs.h"
  25 #include "extensions/browser/extension_registry.h"
  26 #include "extensions/browser/notification_types.h"
  27 #include "extensions/common/extension.h"
  28 #include "extensions/common/extension_builder.h"
  29 #include "extensions/common/value_builder.h"
  30 #include "extensions/test/extension_test_message_listener.h"
  31
  32 namespace {
  33
  34 scoped_refptr<const extensions::Extension> CreateExtension(
  35     const std::string& name,
  36     bool has_browser_action) {
  37   extensions::DictionaryBuilder manifest;
  38   manifest.Set("name", name).
  39            Set("description", "an extension").
  40            Set("manifest_version", 2).
  41            Set("version", "1.0");
  42   if (has_browser_action)
  43     manifest.Set("browser_action", extensions::DictionaryBuilder().Pass());
  44   return extensions::ExtensionBuilder().
  45       SetManifest(manifest.Pass()).
  46       SetID(crx_file::id_util::GenerateId(name)).
  47       Build();
  48 }
  49
  50 }  // namespace
  51
  52 // BrowserActionsBarBrowserTest:
  53
  54 BrowserActionsBarBrowserTest::BrowserActionsBarBrowserTest()
  55     : toolbar_model_(nullptr) {
  56 }
  57
  58 BrowserActionsBarBrowserTest::~BrowserActionsBarBrowserTest() {
  59 }
  60
  61 void BrowserActionsBarBrowserTest::SetUpCommandLine(
  62     base::CommandLine* command_line) {
  63   ToolbarActionsBar::disable_animations_for_testing_ = true;
  64   ExtensionBrowserTest::SetUpCommandLine(command_line);
  65 }
  66
  67 void BrowserActionsBarBrowserTest::SetUpOnMainThread() {
  68   ExtensionBrowserTest::SetUpOnMainThread();
  69   browser_actions_bar_.reset(new BrowserActionTestUtil(browser()));
  70   toolbar_model_ = extensions::ExtensionToolbarModel::Get(profile());
  71 }
  72
  73 void BrowserActionsBarBrowserTest::TearDownOnMainThread() {
  74   ToolbarActionsBar::disable_animations_for_testing_ = false;
  75   ExtensionBrowserTest::TearDownOnMainThread();
  76 }
  77
  78 void BrowserActionsBarBrowserTest::LoadExtensions() {
  79   // Create three extensions with browser actions.
  80   extension_a_ = CreateExtension("alpha", true);
  81   extension_b_ = CreateExtension("beta", true);
  82   extension_c_ = CreateExtension("gamma", true);
  83
  84   const extensions::Extension* extensions[] =
  85       { extension_a(), extension_b(), extension_c() };
  86   extensions::ExtensionRegistry* registry =
  87       extensions::ExtensionRegistry::Get(profile());
  88   // Add each, and verify that it is both correctly added to the extension
  89   // registry and to the browser actions container.
  90   for (size_t i = 0; i < arraysize(extensions); ++i) {
  91     extension_service()->AddExtension(extensions[i]);
  92     EXPECT_TRUE(registry->enabled_extensions().GetByID(extensions[i]->id())) <<
  93         extensions[i]->name();
  94     EXPECT_EQ(static_cast<int>(i + 1),
  95               browser_actions_bar_->NumberOfBrowserActions());
  96     EXPECT_TRUE(browser_actions_bar_->HasIcon(i));
  97     EXPECT_EQ(static_cast<int>(i + 1),
  98               browser_actions_bar()->VisibleBrowserActions());
  99   }
 100 }
 101
 102 // BrowserActionsBarRedesignBrowserTest:
 103
 104 BrowserActionsBarRedesignBrowserTest::BrowserActionsBarRedesignBrowserTest() {
 105 }
 106
 107 BrowserActionsBarRedesignBrowserTest::~BrowserActionsBarRedesignBrowserTest() {
 108 }
 109
 110 void BrowserActionsBarRedesignBrowserTest::SetUpCommandLine(
 111     base::CommandLine* command_line) {
 112   BrowserActionsBarBrowserTest::SetUpCommandLine(command_line);
 113   enable_redesign_.reset(new extensions::FeatureSwitch::ScopedOverride(
 114       extensions::FeatureSwitch::extension_action_redesign(),
 115       true));
 116 }
 117
 118 // Test the basic functionality.
 119 IN_PROC_BROWSER_TEST_F(BrowserActionsBarBrowserTest, Basic) {
 120   // Load an extension with no browser action.
 121   extension_service()->AddExtension(CreateExtension("alpha", false).get());
 122   // This extension should not be in the model (has no browser action).
 123   EXPECT_EQ(0, browser_actions_bar()->NumberOfBrowserActions());
 124
 125   // Load an extension with a browser action.
 126   extension_service()->AddExtension(CreateExtension("beta", true).get());
 127   EXPECT_EQ(1, browser_actions_bar()->NumberOfBrowserActions());
 128   EXPECT_TRUE(browser_actions_bar()->HasIcon(0));
 129
 130   // Unload the extension.
 131   std::string id = browser_actions_bar()->GetExtensionId(0);
 132   UnloadExtension(id);
 133   EXPECT_EQ(0, browser_actions_bar()->NumberOfBrowserActions());
 134 }
 135
 136 // Test moving various browser actions. This is not to check the logic of the
 137 // move (that's in the toolbar model tests), but just to check our ui.
 138 IN_PROC_BROWSER_TEST_F(BrowserActionsBarBrowserTest, MoveBrowserActions) {
 139   LoadExtensions();
 140
 141   EXPECT_EQ(3, browser_actions_bar()->VisibleBrowserActions());
 142   EXPECT_EQ(3, browser_actions_bar()->NumberOfBrowserActions());
 143
 144   // Order is now A B C.
 145   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(0));
 146   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(1));
 147   EXPECT_EQ(extension_c()->id(), browser_actions_bar()->GetExtensionId(2));
 148
 149   // Move C to first position. Order is C A B.
 150   toolbar_model()->MoveExtensionIcon(extension_c()->id(), 0);
 151   EXPECT_EQ(extension_c()->id(), browser_actions_bar()->GetExtensionId(0));
 152   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(1));
 153   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(2));
 154
 155   // Move B to third position. Order is still C A B.
 156   toolbar_model()->MoveExtensionIcon(extension_b()->id(), 2);
 157   EXPECT_EQ(extension_c()->id(), browser_actions_bar()->GetExtensionId(0));
 158   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(1));
 159   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(2));
 160
 161   // Move B to middle position. Order is C B A.
 162   toolbar_model()->MoveExtensionIcon(extension_b()->id(), 1);
 163   EXPECT_EQ(extension_c()->id(), browser_actions_bar()->GetExtensionId(0));
 164   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(1));
 165   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(2));
 166 }
 167
 168 // Test that explicitly hiding an extension action results in it disappearing
 169 // from the browser actions bar.
 170 IN_PROC_BROWSER_TEST_F(BrowserActionsBarBrowserTest, ForceHide) {
 171   LoadExtensions();
 172
 173   EXPECT_EQ(3, browser_actions_bar()->VisibleBrowserActions());
 174   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(0));
 175   // Force hide one of the extensions' browser action.
 176   extensions::ExtensionActionAPI::Get(browser()->profile())->
 177       SetBrowserActionVisibility(extension_a()->id(), false);
 178   // The browser action for Extension A should be removed.
 179   EXPECT_EQ(2, browser_actions_bar()->VisibleBrowserActions());
 180   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(0));
 181 }
 182
 183 IN_PROC_BROWSER_TEST_F(BrowserActionsBarBrowserTest, Visibility) {
 184   LoadExtensions();
 185
 186   // Change container to show only one action, rest in overflow: A, [B, C].
 187   toolbar_model()->SetVisibleIconCount(1);
 188   EXPECT_EQ(1, browser_actions_bar()->VisibleBrowserActions());
 189
 190   // Disable extension A (should disappear). State becomes: B [C].
 191   DisableExtension(extension_a()->id());
 192   EXPECT_EQ(2, browser_actions_bar()->NumberOfBrowserActions());
 193   EXPECT_EQ(1, browser_actions_bar()->VisibleBrowserActions());
 194   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(0));
 195
 196   // Enable A again. A should get its spot in the same location and the bar
 197   // should not grow (chevron is showing). For details: http://crbug.com/35349.
 198   // State becomes: A, [B, C].
 199   EnableExtension(extension_a()->id());
 200   EXPECT_EQ(3, browser_actions_bar()->NumberOfBrowserActions());
 201   EXPECT_EQ(1, browser_actions_bar()->VisibleBrowserActions());
 202   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(0));
 203
 204   // Disable C (in overflow). State becomes: A, [B].
 205   DisableExtension(extension_c()->id());
 206   EXPECT_EQ(2, browser_actions_bar()->NumberOfBrowserActions());
 207   EXPECT_EQ(1, browser_actions_bar()->VisibleBrowserActions());
 208   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(0));
 209
 210   // Enable C again. State becomes: A, [B, C].
 211   EnableExtension(extension_c()->id());
 212   EXPECT_EQ(3, browser_actions_bar()->NumberOfBrowserActions());
 213   EXPECT_EQ(1, browser_actions_bar()->VisibleBrowserActions());
 214   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(0));
 215
 216   // Now we have 3 extensions. Make sure they are all visible. State: A, B, C.
 217   toolbar_model()->SetVisibleIconCount(3);
 218   EXPECT_EQ(3, browser_actions_bar()->VisibleBrowserActions());
 219
 220   // Disable extension A (should disappear). State becomes: B, C.
 221   DisableExtension(extension_a()->id());
 222   EXPECT_EQ(2, browser_actions_bar()->NumberOfBrowserActions());
 223   EXPECT_EQ(2, browser_actions_bar()->VisibleBrowserActions());
 224   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(0));
 225
 226   // Disable extension B (should disappear). State becomes: C.
 227   DisableExtension(extension_b()->id());
 228   EXPECT_EQ(1, browser_actions_bar()->NumberOfBrowserActions());
 229   EXPECT_EQ(1, browser_actions_bar()->VisibleBrowserActions());
 230   EXPECT_EQ(extension_c()->id(), browser_actions_bar()->GetExtensionId(0));
 231
 232   // Enable B. State becomes: B, C.
 233   EnableExtension(extension_b()->id());
 234   EXPECT_EQ(2, browser_actions_bar()->NumberOfBrowserActions());
 235   EXPECT_EQ(2, browser_actions_bar()->VisibleBrowserActions());
 236   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(0));
 237
 238   // Enable A. State becomes: A, B, C.
 239   EnableExtension(extension_a()->id());
 240   EXPECT_EQ(3, browser_actions_bar()->NumberOfBrowserActions());
 241   EXPECT_EQ(3, browser_actions_bar()->VisibleBrowserActions());
 242   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(0));
 243
 244   // Shrink the browser actions bar to zero visible icons.
 245   // No icons should be visible, but we *should* show the chevron and have a
 246   // non-empty size.
 247   toolbar_model()->SetVisibleIconCount(0);
 248   EXPECT_EQ(0, browser_actions_bar()->VisibleBrowserActions());
 249   EXPECT_TRUE(browser_actions_bar()->IsChevronShowing());
 250
 251   // Reset visibility count to 2. State should be A, B, [C], and the chevron
 252   // should be visible.
 253   toolbar_model()->SetVisibleIconCount(2);
 254   EXPECT_EQ(2, browser_actions_bar()->VisibleBrowserActions());
 255   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(0));
 256   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(1));
 257   EXPECT_TRUE(browser_actions_bar()->IsChevronShowing());
 258
 259   // Disable C (the overflowed extension). State should now be A, B, and the
 260   // chevron should be hidden.
 261   DisableExtension(extension_c()->id());
 262   EXPECT_EQ(2, browser_actions_bar()->VisibleBrowserActions());
 263   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(0));
 264   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(1));
 265   EXPECT_FALSE(browser_actions_bar()->IsChevronShowing());
 266
 267   // Re-enable C. We should still only have 2 visible icons, and the chevron
 268   // should be visible.
 269   EnableExtension(extension_c()->id());
 270   EXPECT_EQ(2, browser_actions_bar()->VisibleBrowserActions());
 271   EXPECT_EQ(extension_a()->id(), browser_actions_bar()->GetExtensionId(0));
 272   EXPECT_EQ(extension_b()->id(), browser_actions_bar()->GetExtensionId(1));
 273   EXPECT_TRUE(browser_actions_bar()->IsChevronShowing());
 274 }
 275
 276 // Test that, with the toolbar action redesign, actions that want to run have
 277 // the proper appearance.
 278 IN_PROC_BROWSER_TEST_F(BrowserActionsBarRedesignBrowserTest,
 279                        TestUiForActionsWantToRun) {
 280   LoadExtensions();
 281   EXPECT_EQ(3, browser_actions_bar()->VisibleBrowserActions());
 282
 283   // Load an extension with a page action.
 284   scoped_refptr<const extensions::Extension> page_action_extension =
 285       extensions::extension_action_test_util::CreateActionExtension(
 286           "page action", extensions::extension_action_test_util::PAGE_ACTION);
 287   extension_service()->AddExtension(page_action_extension.get());
 288
 289   // Verify that the extension was added at the last index.
 290   EXPECT_EQ(4, browser_actions_bar()->VisibleBrowserActions());
 291   EXPECT_EQ(page_action_extension->id(),
 292             browser_actions_bar()->GetExtensionId(3));
 293   EXPECT_FALSE(browser_actions_bar()->ActionButtonWantsToRun(3));
 294
 295   // Make the extension want to run on the current page.
 296   ExtensionAction* action = extensions::ExtensionActionManager::Get(profile())->
 297       GetExtensionAction(*page_action_extension);
 298   ASSERT_TRUE(action);
 299   content::WebContents* web_contents =
 300       browser()->tab_strip_model()->GetActiveWebContents();
 301   int tab_id = SessionTabHelper::IdForTab(web_contents);
 302   action->SetIsVisible(tab_id, true);
 303   extensions::ExtensionActionAPI* extension_action_api =
 304       extensions::ExtensionActionAPI::Get(profile());
 305   extension_action_api->NotifyChange(action, web_contents, profile());
 306   // Verify that the extension's button has the proper UI.
 307   EXPECT_TRUE(browser_actions_bar()->ActionButtonWantsToRun(3));
 308
 309   // Make the extension not want to run, and check that the special UI goes
 310   // away.
 311   action->SetIsVisible(tab_id, false);
 312   extension_action_api->NotifyChange(action, web_contents, profile());
 313   EXPECT_FALSE(browser_actions_bar()->ActionButtonWantsToRun(3));
 314
 315   // Reduce the visible icon count so that the extension is hidden.
 316   toolbar_model()->SetVisibleIconCount(3);
 317   EXPECT_FALSE(browser_actions_bar()->OverflowedActionButtonWantsToRun());
 318
 319   // Make the extension want to run, and verify that the overflow button (the
 320   // wrench) has the correct UI. Then, make the extension not want to run and
 321   // verify it goes away.
 322   action->SetIsVisible(tab_id, true);
 323   extension_action_api->NotifyChange(action, web_contents, profile());
 324   EXPECT_TRUE(browser_actions_bar()->OverflowedActionButtonWantsToRun());
 325   action->SetIsVisible(tab_id, false);
 326   extension_action_api->NotifyChange(action, web_contents, profile());
 327   EXPECT_FALSE(browser_actions_bar()->OverflowedActionButtonWantsToRun());
 328
 329   // Make the extension want to run again, and then move it out of the overflow
 330   // menu. This should stop the wrench menu from having the special UI.
 331   action->SetIsVisible(tab_id, true);
 332   extension_action_api->NotifyChange(action, web_contents, profile());
 333   EXPECT_TRUE(browser_actions_bar()->OverflowedActionButtonWantsToRun());
 334   toolbar_model()->SetVisibleIconCount(4);
 335   EXPECT_FALSE(browser_actions_bar()->OverflowedActionButtonWantsToRun());
 336 }
 337
 338 IN_PROC_BROWSER_TEST_F(BrowserActionsBarBrowserTest,
 339                        BrowserActionPopupTest) {
 340   // Load up two extensions that have browser action popups.
 341   base::FilePath data_dir =
 342       test_data_dir_.AppendASCII("api_test").AppendASCII("browser_action");
 343   const extensions::Extension* first_extension =
 344       LoadExtension(data_dir.AppendASCII("open_popup"));
 345   ASSERT_TRUE(first_extension);
 346   const extensions::Extension* second_extension =
 347       LoadExtension(data_dir.AppendASCII("remove_popup"));
 348   ASSERT_TRUE(second_extension);
 349
 350   // Verify state: two actions, in the order of [first, second].
 351   EXPECT_EQ(2, browser_actions_bar()->VisibleBrowserActions());
 352   EXPECT_EQ(first_extension->id(), browser_actions_bar()->GetExtensionId(0));
 353   EXPECT_EQ(second_extension->id(), browser_actions_bar()->GetExtensionId(1));
 354
 355   // Do a little piping to get at the underlying ExtensionActionViewControllers.
 356   ToolbarActionsBar* toolbar_actions_bar =
 357       browser_actions_bar()->GetToolbarActionsBar();
 358   const std::vector<ToolbarActionViewController*>& toolbar_actions =
 359       toolbar_actions_bar->GetActions();
 360   ASSERT_EQ(2u, toolbar_actions.size());
 361   EXPECT_EQ(first_extension->id(), toolbar_actions[0]->GetId());
 362   EXPECT_EQ(second_extension->id(), toolbar_actions[1]->GetId());
 363   ExtensionActionViewController* first_controller =
 364       static_cast<ExtensionActionViewController*>(toolbar_actions[0]);
 365   ExtensionActionViewController* second_controller =
 366       static_cast<ExtensionActionViewController*>(toolbar_actions[1]);
 367
 368   // Neither should yet be showing a popup.
 369   EXPECT_FALSE(browser_actions_bar()->HasPopup());
 370   EXPECT_FALSE(first_controller->is_showing_popup());
 371   EXPECT_FALSE(second_controller->is_showing_popup());
 372
 373   // Click on the first extension's browser action. This should open a popup.
 374   browser_actions_bar()->Press(0);
 375   EXPECT_TRUE(browser_actions_bar()->HasPopup());
 376   EXPECT_TRUE(first_controller->is_showing_popup());
 377   EXPECT_FALSE(second_controller->is_showing_popup());
 378
 379   {
 380     content::WindowedNotificationObserver observer(
 381         extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
 382         content::NotificationService::AllSources());
 383     // Clicking on the second extension's browser action should open the
 384     // second's popup. Since we only allow one extension popup at a time, this
 385     // should also close the first popup.
 386     browser_actions_bar()->Press(1);
 387     // Closing an extension popup isn't always synchronous; wait for a
 388     // notification.
 389     observer.Wait();
 390     EXPECT_TRUE(browser_actions_bar()->HasPopup());
 391     EXPECT_FALSE(first_controller->is_showing_popup());
 392     EXPECT_TRUE(second_controller->is_showing_popup());
 393   }
 394
 395   {
 396     // Clicking on the second extension's browser action a second time should
 397     // result in closing the popup.
 398     content::WindowedNotificationObserver observer(
 399         extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
 400         content::NotificationService::AllSources());
 401     browser_actions_bar()->Press(1);
 402     observer.Wait();
 403     EXPECT_FALSE(browser_actions_bar()->HasPopup());
 404     EXPECT_FALSE(first_controller->is_showing_popup());
 405     EXPECT_FALSE(second_controller->is_showing_popup());
 406   }
 407 }
 408
 409 IN_PROC_BROWSER_TEST_F(BrowserActionsBarRedesignBrowserTest,
 410                        OverflowedBrowserActionPopupTest) {
 411   scoped_ptr<BrowserActionTestUtil> overflow_bar =
 412       browser_actions_bar()->CreateOverflowBar();
 413
 414   // Load up two extensions that have browser action popups.
 415   base::FilePath data_dir =
 416       test_data_dir_.AppendASCII("api_test").AppendASCII("browser_action");
 417   const extensions::Extension* first_extension =
 418       LoadExtension(data_dir.AppendASCII("open_popup"));
 419   ASSERT_TRUE(first_extension);
 420   const extensions::Extension* second_extension =
 421       LoadExtension(data_dir.AppendASCII("remove_popup"));
 422   ASSERT_TRUE(second_extension);
 423
 424   // Verify state: two actions, in the order of [first, second].
 425   EXPECT_EQ(2, browser_actions_bar()->VisibleBrowserActions());
 426   EXPECT_EQ(first_extension->id(), browser_actions_bar()->GetExtensionId(0));
 427   EXPECT_EQ(second_extension->id(), browser_actions_bar()->GetExtensionId(1));
 428
 429   // Do a little piping to get at the underlying ExtensionActionViewControllers.
 430   ToolbarActionsBar* main_tab = browser_actions_bar()->GetToolbarActionsBar();
 431   std::vector<ToolbarActionViewController*> toolbar_actions =
 432       main_tab->GetActions();
 433   ASSERT_EQ(2u, toolbar_actions.size());
 434   EXPECT_EQ(first_extension->id(), toolbar_actions[0]->GetId());
 435   EXPECT_EQ(second_extension->id(), toolbar_actions[1]->GetId());
 436   ExtensionActionViewController* first_controller_main =
 437       static_cast<ExtensionActionViewController*>(toolbar_actions[0]);
 438   ExtensionActionViewController* second_controller_main =
 439       static_cast<ExtensionActionViewController*>(toolbar_actions[1]);
 440
 441   ToolbarActionsBar* overflow_tab = overflow_bar->GetToolbarActionsBar();
 442   toolbar_actions = overflow_tab->GetActions();
 443   ExtensionActionViewController* second_controller_overflow =
 444       static_cast<ExtensionActionViewController*>(toolbar_actions[1]);
 445
 446   toolbar_model()->SetVisibleIconCount(0);
 447
 448   EXPECT_EQ(0, browser_actions_bar()->VisibleBrowserActions());
 449   EXPECT_EQ(2, overflow_bar->VisibleBrowserActions());
 450
 451   // Neither should yet be showing a popup.
 452   EXPECT_FALSE(browser_actions_bar()->HasPopup());
 453   EXPECT_FALSE(second_controller_main->is_showing_popup());
 454   EXPECT_FALSE(second_controller_overflow->is_showing_popup());
 455
 456   // Click on the first extension's browser action. This should open a popup.
 457   overflow_bar->Press(1);
 458   base::RunLoop().RunUntilIdle();
 459   EXPECT_TRUE(browser_actions_bar()->HasPopup());
 460   EXPECT_FALSE(overflow_bar->HasPopup());
 461   EXPECT_TRUE(second_controller_main->is_showing_popup());
 462   EXPECT_FALSE(second_controller_overflow->is_showing_popup());
 463
 464   EXPECT_EQ(1, browser_actions_bar()->VisibleBrowserActions());
 465   EXPECT_EQ(1u, main_tab->GetIconCount());
 466   EXPECT_EQ(second_controller_main->GetId(),
 467             browser_actions_bar()->GetExtensionId(0));
 468   EXPECT_EQ(2, overflow_bar->VisibleBrowserActions());
 469   EXPECT_EQ(2u, overflow_tab->GetIconCount());
 470   EXPECT_EQ(first_controller_main->GetId(),
 471             overflow_bar->GetExtensionId(0));
 472
 473   {
 474     content::WindowedNotificationObserver observer(
 475         extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
 476         content::NotificationService::AllSources());
 477     second_controller_main->HidePopup();
 478     observer.Wait();
 479   }
 480
 481   EXPECT_FALSE(browser_actions_bar()->HasPopup());
 482   EXPECT_FALSE(overflow_bar->HasPopup());
 483   EXPECT_FALSE(second_controller_main->is_showing_popup());
 484   EXPECT_FALSE(second_controller_overflow->is_showing_popup());
 485   EXPECT_EQ(0, browser_actions_bar()->VisibleBrowserActions());
 486   EXPECT_EQ(2, overflow_bar->VisibleBrowserActions());
 487   base::RunLoop().RunUntilIdle();
 488   EXPECT_EQ(first_controller_main->GetId(),
 489             browser_actions_bar()->GetExtensionId(0));
 490   EXPECT_EQ(second_controller_main->GetId(),
 491             browser_actions_bar()->GetExtensionId(1));
 492 }
 493
 494 // Test that page action popups work with the toolbar redesign.
 495 IN_PROC_BROWSER_TEST_F(BrowserActionsBarRedesignBrowserTest,
 496                        PageActionPopupsTest) {
 497   ExtensionTestMessageListener listener("ready", false);
 498   const extensions::Extension* page_action_extension =
 499       LoadExtension(test_data_dir_.AppendASCII("trigger_actions").
 500                         AppendASCII("page_action_popup"));
 501   ASSERT_TRUE(page_action_extension);
 502   listener.WaitUntilSatisfied();
 503   EXPECT_EQ(1, browser_actions_bar()->VisibleBrowserActions());
 504   EXPECT_EQ(page_action_extension->id(),
 505             browser_actions_bar()->GetExtensionId(0));
 506   browser_actions_bar()->Press(0);
 507   base::RunLoop().RunUntilIdle();
 508   EXPECT_TRUE(browser_actions_bar()->HasPopup());
 509   // Cleanup the popup (to avoid having windows open at tear down).
 510   browser_actions_bar()->HidePopup();
 511   content::RunAllBlockingPoolTasksUntilIdle();
 512   EXPECT_FALSE(browser_actions_bar()->HasPopup());
 513 }