[Extensions UI] Handle multiple warning bubbles racing to show

chrome/browser/extensions/extension_message_bubble_controller_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 305 matching lines @@
     static_cast<TestExtensionSystem*>(ExtensionSystem::Get(profile()))
         ->CreateExtensionService(base::CommandLine::ForCurrentProcess(),
                                  base::FilePath(), false);
     service_ = ExtensionSystem::Get(profile())->extension_service();
     service_->Init();
 
     extensions::ExtensionWebUIOverrideRegistrar::GetFactoryInstance()->
         SetTestingFactory(profile(), &BuildOverrideRegistrar);
     extensions::ExtensionWebUIOverrideRegistrar::GetFactoryInstance()->Get(
         profile());
+    ToolbarActionsModelFactory::GetInstance()->SetTestingFactory(
+        profile(), &BuildToolbarModel);
   }
 
   ~ExtensionMessageBubbleTest() override {}
 
   void SetUp() override {
     BrowserWithTestWindowTest::SetUp();
     command_line_.reset(new base::CommandLine(base::CommandLine::NO_PROGRAM));
     ExtensionMessageBubbleController::set_should_ignore_learn_more_for_testing(
         true);
   }
@@ skipping 23 matching lines @@
 };
 
 TEST_F(ExtensionMessageBubbleTest, BubbleReshowsOnDeactivationDismissal) {
   Init();
 
   ASSERT_TRUE(LoadExtensionOverridingNtp("1", kId1, Manifest::INTERNAL));
   ASSERT_TRUE(LoadExtensionOverridingNtp("2", kId2, Manifest::INTERNAL));
   std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
           new NtpOverriddenBubbleDelegate(browser()->profile()), browser()));
+  controller->SetIsActiveBubble();
 
   // The list will contain one enabled unpacked extension (ext 2).
   EXPECT_TRUE(controller->ShouldShow());
   std::vector<base::string16> override_extensions =
       controller->GetExtensionList();
   ASSERT_EQ(1U, override_extensions.size());
   EXPECT_EQ(base::ASCIIToUTF16("Extension 2"), override_extensions[0]);
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
   EXPECT_EQ(0U, controller->action_click_count());
@@ skipping 12 matching lines @@
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId2));
   // And since it was dismissed due to deactivation, the extension should not
   // have been acknowledged.
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId2));
 
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_DISMISS_DEACTIVATION);
   controller.reset(new TestExtensionMessageBubbleController(
       new NtpOverriddenBubbleDelegate(browser()->profile()), browser()));
+  controller->SetIsActiveBubble();
   // The bubble shouldn't show again for the same profile (we don't want to
   // be annoying).
   EXPECT_FALSE(controller->ShouldShow());
   controller->ClearProfileListForTesting();
   EXPECT_TRUE(controller->ShouldShow());
   // Explicitly click the dismiss button. The extension should be acknowledged.
   bubble.set_controller(controller.get());
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_DISMISS_BUTTON);
   bubble.Show();
@@ skipping 18 matching lines @@
   // Add three extensions, and control two of them in this test (extension 1
   // and 2).
   ASSERT_TRUE(LoadExtensionWithAction("1", kId1, Manifest::COMMAND_LINE));
   ASSERT_TRUE(LoadGenericExtension("2", kId2, Manifest::UNPACKED));
   ASSERT_TRUE(LoadGenericExtension("3", kId3, Manifest::EXTERNAL_POLICY));
 
   std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
           new SuspiciousExtensionBubbleDelegate(browser()->profile()),
           browser()));
+  controller->SetIsActiveBubble();
   FakeExtensionMessageBubble bubble;
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_DISMISS_BUTTON);
 
   // Validate that we don't have a suppress value for the extensions.
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
 
   EXPECT_FALSE(controller->ShouldShow());
   std::vector<base::string16> suspicious_extensions =
       controller->GetExtensionList();
   EXPECT_EQ(0U, suspicious_extensions.size());
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
 
   // Now disable an extension, specifying the wipeout flag.
   service_->DisableExtension(kId1, Extension::DISABLE_NOT_VERIFIED);
 
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId2));
   controller.reset(
       new TestExtensionMessageBubbleController(
           new SuspiciousExtensionBubbleDelegate(browser()->profile()),
           browser()));
+  controller->SetIsActiveBubble();
   controller->ClearProfileListForTesting();
   EXPECT_TRUE(controller->ShouldShow());
   suspicious_extensions = controller->GetExtensionList();
   ASSERT_EQ(1U, suspicious_extensions.size());
   EXPECT_TRUE(base::ASCIIToUTF16("Extension 1") == suspicious_extensions[0]);
   bubble.set_controller(controller.get());
   bubble.Show();  // Simulate showing the bubble.
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(1U, controller->dismiss_click_count());
   // Now the acknowledge flag should be set only for the first extension.
   EXPECT_TRUE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId2));
   // Clear the flag.
   controller->delegate()->SetBubbleInfoBeenAcknowledged(kId1, false);
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
 
   // Now disable the other extension and exercise the link click code path.
   service_->DisableExtension(kId2, Extension::DISABLE_NOT_VERIFIED);
 
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_LINK);
   controller.reset(
       new TestExtensionMessageBubbleController(
           new SuspiciousExtensionBubbleDelegate(browser()->profile()),
           browser()));
+  controller->SetIsActiveBubble();
   controller->ClearProfileListForTesting();
   EXPECT_TRUE(controller->ShouldShow());
   suspicious_extensions = controller->GetExtensionList();
   ASSERT_EQ(2U, suspicious_extensions.size());
   EXPECT_TRUE(base::ASCIIToUTF16("Extension 1") == suspicious_extensions[1]);
   EXPECT_TRUE(base::ASCIIToUTF16("Extension 2") == suspicious_extensions[0]);
   bubble.set_controller(controller.get());
   bubble.Show();  // Simulate showing the bubble.
   EXPECT_EQ(1U, controller->link_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
   EXPECT_TRUE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
 }
 
 // The feature this is meant to test is only enacted on Windows, but it should
 // pass on all platforms.
 TEST_F(ExtensionMessageBubbleTest, DevModeControllerTest) {
   FeatureSwitch::ScopedOverride force_dev_mode_highlighting(
       FeatureSwitch::force_dev_mode_highlighting(), true);
   Init();
   // Add three extensions, and control two of them in this test (extension 1
   // and 2). Extension 1 is a regular extension, Extension 2 is UNPACKED so it
   // counts as a DevMode extension.
   ASSERT_TRUE(LoadExtensionWithAction("1", kId1, Manifest::COMMAND_LINE));
   ASSERT_TRUE(LoadGenericExtension("2", kId2, Manifest::UNPACKED));
   ASSERT_TRUE(LoadGenericExtension("3", kId3, Manifest::EXTERNAL_POLICY));
 
   std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
           new DevModeBubbleDelegate(browser()->profile()), browser()));
+  controller->SetIsActiveBubble();
 
   // The list will contain one enabled unpacked extension.
   EXPECT_TRUE(controller->ShouldShow());
   std::vector<base::string16> dev_mode_extensions =
       controller->GetExtensionList();
   ASSERT_EQ(2U, dev_mode_extensions.size());
   EXPECT_TRUE(base::ASCIIToUTF16("Extension 2") == dev_mode_extensions[0]);
   EXPECT_TRUE(base::ASCIIToUTF16("Extension 1") == dev_mode_extensions[1]);
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
@@ skipping 12 matching lines @@
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId1) != NULL);
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId2) != NULL);
 
   // Do it again, but now press different button (Disable).
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_ACTION_BUTTON);
   controller.reset(
       new TestExtensionMessageBubbleController(
           new DevModeBubbleDelegate(browser()->profile()),
           browser()));
+  controller->SetIsActiveBubble();
   // Most bubbles would want to show again as long as the extensions weren't
   // acknowledged and the bubble wasn't dismissed due to deactivation. Since dev
   // mode extensions can't be (persistently) acknowledged, this isn't the case
   // for the dev mode bubble, and we should only show once per profile.
   EXPECT_FALSE(controller->ShouldShow());
   controller->ClearProfileListForTesting();
   EXPECT_TRUE(controller->ShouldShow());
   dev_mode_extensions = controller->GetExtensionList();
   EXPECT_EQ(2U, dev_mode_extensions.size());
   bubble.set_controller(controller.get());
   bubble.Show();  // Simulate showing the bubble.
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(1U, controller->action_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
   EXPECT_TRUE(registry->disabled_extensions().GetByID(kId1) != NULL);
   EXPECT_TRUE(registry->disabled_extensions().GetByID(kId2) != NULL);
 
   // Re-enable the extensions (disabled by the action button above).
   service_->EnableExtension(kId1);
   service_->EnableExtension(kId2);
 
   // Show the dialog a third time, but now press the learn more link.
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_LINK);
   controller.reset(
       new TestExtensionMessageBubbleController(
           new DevModeBubbleDelegate(browser()->profile()),
           browser()));
+  controller->SetIsActiveBubble();
   controller->ClearProfileListForTesting();
   EXPECT_TRUE(controller->ShouldShow());
   dev_mode_extensions = controller->GetExtensionList();
   EXPECT_EQ(2U, dev_mode_extensions.size());
   bubble.set_controller(controller.get());
   bubble.Show();  // Simulate showing the bubble.
   EXPECT_EQ(1U, controller->link_click_count());
   EXPECT_EQ(0U, controller->action_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId1) != NULL);
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId2) != NULL);
 
   // Now disable the unpacked extension.
   service_->DisableExtension(kId1, Extension::DISABLE_USER_ACTION);
   service_->DisableExtension(kId2, Extension::DISABLE_USER_ACTION);
 
   controller.reset(
       new TestExtensionMessageBubbleController(
           new DevModeBubbleDelegate(browser()->profile()),
           browser()));
+  controller->SetIsActiveBubble();
   controller->ClearProfileListForTesting();
   EXPECT_FALSE(controller->ShouldShow());
   dev_mode_extensions = controller->GetExtensionList();
   EXPECT_EQ(0U, dev_mode_extensions.size());
 }
 
 // The feature this is meant to test is only implemented on Windows and Mac.
 #if defined(OS_WIN) || defined(OS_MACOSX)
 #define MAYBE_SettingsApiControllerTest SettingsApiControllerTest
 #else
@@ skipping 39 matching lines @@
       default:
         NOTREACHED();
         break;
     }
 
     SettingsApiOverrideType type = static_cast<SettingsApiOverrideType>(i);
     std::unique_ptr<TestExtensionMessageBubbleController> controller(
         new TestExtensionMessageBubbleController(
             new SettingsApiBubbleDelegate(browser()->profile(), type),
             browser()));
+    controller->SetIsActiveBubble();
 
     // The list will contain one enabled unpacked extension (ext 2).
     EXPECT_TRUE(controller->ShouldShow());
     std::vector<base::string16> override_extensions =
         controller->GetExtensionList();
     ASSERT_EQ(1U, override_extensions.size());
     EXPECT_TRUE(base::ASCIIToUTF16("Extension 2") ==
                 override_extensions[0].c_str());
     EXPECT_EQ(0U, controller->link_click_count());
     EXPECT_EQ(0U, controller->dismiss_click_count());
@@ skipping 20 matching lines @@
     // Clean up after ourselves.
     controller->delegate()->SetBubbleInfoBeenAcknowledged(kId2, false);
 
     // Simulate clicking the learn more link to dismiss it.
     bubble.set_action_on_show(
         FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_LINK);
     controller.reset(
         new TestExtensionMessageBubbleController(
             new SettingsApiBubbleDelegate(browser()->profile(), type),
             browser()));
+    controller->SetIsActiveBubble();
     bubble.set_controller(controller.get());
     bubble.Show();
     EXPECT_EQ(1U, controller->link_click_count());
     EXPECT_EQ(0U, controller->action_click_count());
     EXPECT_EQ(0U, controller->dismiss_click_count());
     // No extension should have become disabled.
     EXPECT_TRUE(registry->enabled_extensions().GetByID(kId1) != NULL);
     EXPECT_TRUE(registry->enabled_extensions().GetByID(kId2) != NULL);
     EXPECT_TRUE(registry->enabled_extensions().GetByID(kId3) != NULL);
     // Only extension 2 should have been acknowledged.
     EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
     EXPECT_TRUE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId2));
     EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId3));
     // Clean up after ourselves.
     controller->delegate()->SetBubbleInfoBeenAcknowledged(kId2, false);
 
     // Do it again, but now opt to disable the extension.
     bubble.set_action_on_show(
         FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_ACTION_BUTTON);
     controller.reset(
         new TestExtensionMessageBubbleController(
             new SettingsApiBubbleDelegate(browser()->profile(), type),
             browser()));
+    controller->SetIsActiveBubble();
     EXPECT_TRUE(controller->ShouldShow());
     override_extensions = controller->GetExtensionList();
     EXPECT_EQ(1U, override_extensions.size());
     bubble.set_controller(controller.get());
     bubble.Show();  // Simulate showing the bubble.
     EXPECT_EQ(0U, controller->link_click_count());
     EXPECT_EQ(1U, controller->action_click_count());
     EXPECT_EQ(0U, controller->dismiss_click_count());
     // Only extension 2 should have become disabled.
     EXPECT_TRUE(registry->enabled_extensions().GetByID(kId1) != NULL);
@@ skipping 27 matching lines @@
   // Load two extensions overriding new tab page and one overriding something
   // unrelated (to check for interference). Extension 2 should still win
   // on the new tab page setting.
   ASSERT_TRUE(LoadExtensionOverridingNtp("1", kId1, Manifest::UNPACKED));
   ASSERT_TRUE(LoadExtensionOverridingNtp("2", kId2, Manifest::UNPACKED));
   ASSERT_TRUE(LoadExtensionOverridingStart("3", kId3, Manifest::UNPACKED));
 
   std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
           new NtpOverriddenBubbleDelegate(browser()->profile()), browser()));
+  controller->SetIsActiveBubble();
 
   // The list will contain one enabled unpacked extension (ext 2).
   EXPECT_TRUE(controller->ShouldShow());
   std::vector<base::string16> override_extensions =
       controller->GetExtensionList();
   ASSERT_EQ(1U, override_extensions.size());
   EXPECT_TRUE(base::ASCIIToUTF16("Extension 2") ==
               override_extensions[0].c_str());
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
@@ skipping 21 matching lines @@
   // Clean up after ourselves.
   controller->delegate()->SetBubbleInfoBeenAcknowledged(kId2, false);
 
   // Simulate clicking the learn more link to dismiss it.
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_LINK);
   controller.reset(
       new TestExtensionMessageBubbleController(
           new NtpOverriddenBubbleDelegate(browser()->profile()),
           browser()));
+  controller->SetIsActiveBubble();
   EXPECT_TRUE(controller->ShouldShow());
   bubble.set_controller(controller.get());
   bubble.Show();
   EXPECT_EQ(1U, controller->link_click_count());
   EXPECT_EQ(0U, controller->action_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
   // No extension should have become disabled.
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId1) != NULL);
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId2) != NULL);
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId3) != NULL);
   // Only extension 2 should have been acknowledged.
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
   EXPECT_TRUE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId2));
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId3));
   // Clean up after ourselves.
   controller->delegate()->SetBubbleInfoBeenAcknowledged(kId2, false);
 
   // Do it again, but now opt to disable the extension.
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_ACTION_BUTTON);
   controller.reset(
       new TestExtensionMessageBubbleController(
           new NtpOverriddenBubbleDelegate(browser()->profile()),
           browser()));
+  controller->SetIsActiveBubble();
   EXPECT_TRUE(controller->ShouldShow());
   override_extensions = controller->GetExtensionList();
   EXPECT_EQ(1U, override_extensions.size());
   bubble.set_controller(controller.get());
   bubble.Show();  // Simulate showing the bubble.
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(1U, controller->action_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
   // Only extension 2 should have become disabled.
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId1) != NULL);
@@ skipping 55 matching lines @@
   // so we artificially set the install time to simulate an old install during
   // testing.
   base::Time old_enough = base::Time::Now() - base::TimeDelta::FromDays(8);
   SetInstallTime(kId1, old_enough, prefs);
   SetInstallTime(kId2, base::Time::Now(), prefs);
   SetInstallTime(kId3, old_enough, prefs);
 
   std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
           new ProxyOverriddenBubbleDelegate(browser()->profile()), browser()));
+  controller->SetIsActiveBubble();
 
   // The second extension is too new to warn about.
   EXPECT_FALSE(controller->ShouldShow());
-  EXPECT_FALSE(controller->ShouldShow());
   // Lets make it old enough.
   SetInstallTime(kId2, old_enough, prefs);
 
   // The list will contain one enabled unpacked extension (ext 2).
   EXPECT_TRUE(controller->ShouldShow());
   EXPECT_FALSE(controller->ShouldShow());
   std::vector<base::string16> override_extensions =
       controller->GetExtensionList();
   ASSERT_EQ(1U, override_extensions.size());
   EXPECT_EQ(base::ASCIIToUTF16("Extension 2"), override_extensions[0]);
@@ skipping 22 matching lines @@
   // Clean up after ourselves.
   controller->delegate()->SetBubbleInfoBeenAcknowledged(kId2, false);
 
   // Simulate clicking the learn more link to dismiss it.
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_LINK);
   controller.reset(
       new TestExtensionMessageBubbleController(
           new ProxyOverriddenBubbleDelegate(browser()->profile()),
           browser()));
+  controller->SetIsActiveBubble();
   EXPECT_TRUE(controller->ShouldShow());
   bubble.set_controller(controller.get());
   bubble.Show();
   EXPECT_EQ(1U, controller->link_click_count());
   EXPECT_EQ(0U, controller->action_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
   // No extension should have become disabled.
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId1) != NULL);
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId2) != NULL);
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId3) != NULL);
   // Only extension 2 should have been acknowledged.
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
   EXPECT_TRUE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId2));
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId3));
   // Clean up after ourselves.
   controller->delegate()->SetBubbleInfoBeenAcknowledged(kId2, false);
 
   // Do it again, but now opt to disable the extension.
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_ACTION_BUTTON);
   controller.reset(
       new TestExtensionMessageBubbleController(
           new ProxyOverriddenBubbleDelegate(browser()->profile()),
           browser()));
+  controller->SetIsActiveBubble();
   EXPECT_TRUE(controller->ShouldShow());
   override_extensions = controller->GetExtensionList();
   EXPECT_EQ(1U, override_extensions.size());
   bubble.set_controller(controller.get());
   bubble.Show();  // Simulate showing the bubble.
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(1U, controller->action_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
   // Only extension 2 should have become disabled.
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId1) != NULL);
@@ skipping 19 matching lines @@
                                base::Bind(&base::DoNothing),
                                NULL);
 }
 
 // Tests that a bubble outliving the associated browser object doesn't crash.
 // crbug.com/604003
 TEST_F(ExtensionMessageBubbleTest, TestBubbleOutlivesBrowser) {
   FeatureSwitch::ScopedOverride force_dev_mode_highlighting(
       FeatureSwitch::force_dev_mode_highlighting(), true);
   Init();
-  ToolbarActionsModelFactory::GetInstance()->SetTestingFactory(
-      profile(), &BuildToolbarModel);
   ToolbarActionsModel* model = ToolbarActionsModel::Get(profile());
   base::RunLoop().RunUntilIdle();
 
   ASSERT_TRUE(LoadExtensionWithAction("1", kId1, Manifest::UNPACKED));
 
   std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
           new DevModeBubbleDelegate(browser()->profile()), browser()));
+  controller->SetIsActiveBubble();
   EXPECT_TRUE(controller->ShouldShow());
   EXPECT_EQ(1u, model->toolbar_items().size());
   controller->HighlightExtensionsIfNecessary();
   EXPECT_TRUE(ToolbarActionsModel::Get(profile())->is_highlighting());
   set_browser(nullptr);
   EXPECT_FALSE(ToolbarActionsModel::Get(profile())->is_highlighting());
   controller.reset();
 }
 
 }  // namespace extensions