[Reland] [Extensions] Make extension message bubble factory platform-abstract

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 "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/dev_mode_bubble_controller.h"
@@ skipping 15 matching lines @@
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/chromeos/settings/device_settings_service.h"
+#endif
+
 namespace {
 
 const char kId1[] = "iccfkkhkfiphcjdakkmcjmkfboccmndk";
 const char kId2[] = "ajjhifimiemdpmophmkkkcijegphclbl";
 const char kId3[] = "ioibbbfddncmmabjmpokikkeiofalaek";
 
 }  // namespace
 
 namespace extensions {
 
@@ skipping 154 matching lines @@
 // what should happen when the bubble is "shown" (the bubble is actually not
 // shown, the corresponding action is taken immediately).
 class FakeExtensionMessageBubble : public ExtensionMessageBubble {
  public:
   enum ExtensionBubbleAction {
     BUBBLE_ACTION_CLICK_ACTION_BUTTON = 0,
     BUBBLE_ACTION_CLICK_DISMISS_BUTTON,
     BUBBLE_ACTION_CLICK_LINK,
   };
 
-  FakeExtensionMessageBubble() {}
+  FakeExtensionMessageBubble() : controller_(nullptr) {}
 
   void set_action_on_show(ExtensionBubbleAction action) {
     action_ = action;
   }
+  void set_controller(ExtensionMessageBubbleController* controller) {
+    controller_ = controller;
+  }
 
   void Show() override {
     if (action_ == BUBBLE_ACTION_CLICK_ACTION_BUTTON)
-      action_callback_.Run();
+      controller_->OnBubbleAction();
     else if (action_ == BUBBLE_ACTION_CLICK_DISMISS_BUTTON)
-      dismiss_callback_.Run();
+      controller_->OnBubbleDismiss();
     else if (action_ == BUBBLE_ACTION_CLICK_LINK)
-      link_callback_.Run();
-  }
-
-  void OnActionButtonClicked(const base::Closure& callback) override {
-    action_callback_ = callback;
-  }
-
-  void OnDismissButtonClicked(const base::Closure& callback) override {
-    dismiss_callback_ = callback;
-  }
-
-  void OnLinkClicked(const base::Closure& callback) override {
-    link_callback_ = callback;
+      controller_->OnLinkClicked();
   }
 
  private:
   ExtensionBubbleAction action_;
+  ExtensionMessageBubbleController* controller_;
 
-  base::Closure action_callback_;
-  base::Closure dismiss_callback_;
-  base::Closure link_callback_;
+  DISALLOW_COPY_AND_ASSIGN(FakeExtensionMessageBubble);
 };
 
 class ExtensionMessageBubbleTest : public testing::Test {
  public:
   ExtensionMessageBubbleTest() {}
 
   testing::AssertionResult LoadGenericExtension(const std::string& index,
                                                 const std::string& id,
                                                 Manifest::Location location) {
     ExtensionBuilder builder;
@@ skipping 130 matching lines @@
                                                 new base::StringValue(id));
 
     if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
       return testing::AssertionSuccess();
     return testing::AssertionFailure() << "Could not install extension: " << id;
   }
 
   void Init() {
     // The two lines of magical incantation required to get the extension
     // service to work inside a unit test and access the extension prefs.
-    thread_bundle_.reset(new content::TestBrowserThreadBundle);
     profile_.reset(new TestingProfile);
     static_cast<TestExtensionSystem*>(ExtensionSystem::Get(profile()))
         ->CreateExtensionService(base::CommandLine::ForCurrentProcess(),
                                  base::FilePath(), false);
     service_ = ExtensionSystem::Get(profile())->extension_service();
     service_->Init();
   }
 
   ~ExtensionMessageBubbleTest() override {
     // Make sure the profile is destroyed before the thread bundle.
@@ skipping 12 matching lines @@
       const std::string& data,
       const std::string& id) {
     scoped_ptr<base::DictionaryValue> parsed_manifest(
         api_test_utils::ParseDictionary(data));
     return api_test_utils::CreateExtension(location, parsed_manifest.get(), id);
   }
 
   ExtensionService* service_;
 
  private:
+  content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<base::CommandLine> command_line_;
-  scoped_ptr<content::TestBrowserThreadBundle> thread_bundle_;
   scoped_ptr<TestingProfile> profile_;
 
+#if defined OS_CHROMEOS
+  chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
+  chromeos::ScopedTestCrosSettings test_cros_settings_;
+  chromeos::ScopedTestUserManager test_user_manager_;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionMessageBubbleTest);
 };
 
-// The feature this is meant to test is only implemented on Windows.
-#if defined(OS_WIN)
-#define MAYBE_WipeoutControllerTest WipeoutControllerTest
-#else
-#define MAYBE_WipeoutControllerTest DISABLED_WipeoutControllerTest
-#endif
-
-TEST_F(ExtensionMessageBubbleTest, MAYBE_WipeoutControllerTest) {
+// The feature this is meant to test is only enacted on Windows, but it should
+// pass on all platforms.
+TEST_F(ExtensionMessageBubbleTest, WipeoutControllerTest) {
   Init();
   // 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));
 
   scoped_ptr<TestSuspiciousExtensionBubbleController> controller(
       new TestSuspiciousExtensionBubbleController(profile()));
   FakeExtensionMessageBubble bubble;
@@ skipping 16 matching lines @@
 
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId2));
   controller.reset(new TestSuspiciousExtensionBubbleController(
       profile()));
   SuspiciousExtensionBubbleController::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());
   controller->Show(&bubble);  // 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 TestSuspiciousExtensionBubbleController(
       profile()));
   SuspiciousExtensionBubbleController::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());
   controller->Show(&bubble);  // 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 implemented on Windows.
-#if defined(OS_WIN)
-#define MAYBE_DevModeControllerTest DevModeControllerTest
-#else
-#define MAYBE_DevModeControllerTest DISABLED_DevModeControllerTest
-#endif
-
-TEST_F(ExtensionMessageBubbleTest, MAYBE_DevModeControllerTest) {
+// 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));
 
   scoped_ptr<TestDevModeBubbleController> controller(
       new TestDevModeBubbleController(profile()));
 
   // 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());
   EXPECT_EQ(0U, controller->action_click_count());
 
   // Simulate showing the bubble.
   FakeExtensionMessageBubble bubble;
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_DISMISS_BUTTON);
+  bubble.set_controller(controller.get());
   controller->Show(&bubble);
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->action_click_count());
   EXPECT_EQ(1U, controller->dismiss_click_count());
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
   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 TestDevModeBubbleController(
       profile()));
   DevModeBubbleController::ClearProfileListForTesting();
   EXPECT_TRUE(controller->ShouldShow());
   dev_mode_extensions = controller->GetExtensionList();
   EXPECT_EQ(2U, dev_mode_extensions.size());
+  bubble.set_controller(controller.get());
   controller->Show(&bubble);  // 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 TestDevModeBubbleController(
       profile()));
   DevModeBubbleController::ClearProfileListForTesting();
   EXPECT_TRUE(controller->ShouldShow());
   dev_mode_extensions = controller->GetExtensionList();
   EXPECT_EQ(2U, dev_mode_extensions.size());
+  bubble.set_controller(controller.get());
   controller->Show(&bubble);  // 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);
@@ skipping 47 matching lines @@
       default:
         NOTREACHED();
         break;
     }
 
     scoped_ptr<TestSettingsApiBubbleController> controller(
         new TestSettingsApiBubbleController(
             profile(), static_cast<SettingsApiOverrideType>(i)));
 
     // The list will contain one enabled unpacked extension (ext 2).
-    EXPECT_TRUE(controller->ShouldShow(kId2));
+    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());
     EXPECT_EQ(0U, controller->action_click_count());
 
     // Simulate showing the bubble and dismissing it.
     FakeExtensionMessageBubble bubble;
     bubble.set_action_on_show(
         FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_DISMISS_BUTTON);
+    bubble.set_controller(controller.get());
     controller->Show(&bubble);
     EXPECT_EQ(0U, controller->link_click_count());
     EXPECT_EQ(0U, controller->action_click_count());
     EXPECT_EQ(1U, controller->dismiss_click_count());
     // No extension should have become disabled.
     ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
     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);
 
     // Simulate clicking the learn more link to dismiss it.
     bubble.set_action_on_show(
         FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_LINK);
     controller.reset(new TestSettingsApiBubbleController(
         profile(), static_cast<SettingsApiOverrideType>(i)));
+    bubble.set_controller(controller.get());
     controller->Show(&bubble);
     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 TestSettingsApiBubbleController(
         profile(), static_cast<SettingsApiOverrideType>(i)));
-    EXPECT_TRUE(controller->ShouldShow(kId2));
+    EXPECT_TRUE(controller->ShouldShow());
     override_extensions = controller->GetExtensionList();
     EXPECT_EQ(1U, override_extensions.size());
+    bubble.set_controller(controller.get());
     controller->Show(&bubble);  // 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);
     EXPECT_TRUE(registry->disabled_extensions().GetByID(kId2) != NULL);
     EXPECT_TRUE(registry->enabled_extensions().GetByID(kId3) != NULL);
     // No extension should have been acknowledged (it got disabled).
     EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
     EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId2));
     EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId3));
 
     // Clean up after ourselves.
     service_->UninstallExtension(kId1,
                                  extensions::UNINSTALL_REASON_FOR_TESTING,
                                  base::Bind(&base::DoNothing),
                                  NULL);
     service_->UninstallExtension(kId2,
                                  extensions::UNINSTALL_REASON_FOR_TESTING,
                                  base::Bind(&base::DoNothing),
                                  NULL);
     service_->UninstallExtension(kId3,
                                  extensions::UNINSTALL_REASON_FOR_TESTING,
                                  base::Bind(&base::DoNothing),
                                  NULL);
   }
 }
 
-// The feature this is meant to test is only implemented on Windows.
-#if defined(OS_WIN)
-#define MAYBE_NtpOverriddenControllerTest NtpOverriddenControllerTest
-#else
-#define MAYBE_NtpOverriddenControllerTest DISABLED_NtpOverriddenControllerTest
-#endif
-
-TEST_F(ExtensionMessageBubbleTest, MAYBE_NtpOverriddenControllerTest) {
+// The feature this is meant to test is only enacted on Windows, but it should
+// pass on all platforms.
+TEST_F(ExtensionMessageBubbleTest, NtpOverriddenControllerTest) {
   Init();
   // 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));
 
   scoped_ptr<TestNtpOverriddenBubbleController> controller(
       new TestNtpOverriddenBubbleController(profile()));
 
   // The list will contain one enabled unpacked extension (ext 2).
   EXPECT_TRUE(controller->ShouldShow(kId2));
   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());
   EXPECT_EQ(0U, controller->action_click_count());
 
   // Simulate showing the bubble and dismissing it.
   FakeExtensionMessageBubble bubble;
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_DISMISS_BUTTON);
   EXPECT_TRUE(controller->ShouldShow(kId2));
+  bubble.set_controller(controller.get());
   controller->Show(&bubble);
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->action_click_count());
   EXPECT_EQ(1U, controller->dismiss_click_count());
   // No extension should have become disabled.
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
   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);
 
   // Simulate clicking the learn more link to dismiss it.
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_LINK);
   controller.reset(new TestNtpOverriddenBubbleController(profile()));
   EXPECT_TRUE(controller->ShouldShow(kId2));
+  bubble.set_controller(controller.get());
   controller->Show(&bubble);
   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 TestNtpOverriddenBubbleController(profile()));
   EXPECT_TRUE(controller->ShouldShow(kId2));
   override_extensions = controller->GetExtensionList();
   EXPECT_EQ(1U, override_extensions.size());
+  bubble.set_controller(controller.get());
   controller->Show(&bubble);  // 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);
   EXPECT_TRUE(registry->disabled_extensions().GetByID(kId2) != NULL);
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId3) != NULL);
   // No extension should have been acknowledged (it got disabled).
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
@@ skipping 67 matching lines @@
   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());
 
   // Simulate showing the bubble and dismissing it.
   FakeExtensionMessageBubble bubble;
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_DISMISS_BUTTON);
+  bubble.set_controller(controller.get());
   controller->Show(&bubble);
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->action_click_count());
   EXPECT_EQ(1U, controller->dismiss_click_count());
   // No extension should have become disabled.
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
   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);
 
   // Simulate clicking the learn more link to dismiss it.
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_LINK);
   controller.reset(new TestProxyOverriddenBubbleController(profile()));
   EXPECT_TRUE(controller->ShouldShow(kId2));
+  bubble.set_controller(controller.get());
   controller->Show(&bubble);
   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 TestProxyOverriddenBubbleController(profile()));
   EXPECT_TRUE(controller->ShouldShow(kId2));
   override_extensions = controller->GetExtensionList();
   EXPECT_EQ(1U, override_extensions.size());
+  bubble.set_controller(controller.get());
   controller->Show(&bubble);  // 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);
   EXPECT_TRUE(registry->disabled_extensions().GetByID(kId2) != NULL);
   EXPECT_TRUE(registry->enabled_extensions().GetByID(kId3) != NULL);
 
   // No extension should have been acknowledged (it got disabled).
@@ skipping 10 matching lines @@
                                extensions::UNINSTALL_REASON_FOR_TESTING,
                                base::Bind(&base::DoNothing),
                                NULL);
   service_->UninstallExtension(kId3,
                                extensions::UNINSTALL_REASON_FOR_TESTING,
                                base::Bind(&base::DoNothing),
                                NULL);
 }
 
 }  // namespace extensions