Add an extension override bubble and warning box for proxy extensions.

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"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_message_bubble.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/ntp_overridden_bubble_controller.h"
+#include "chrome/browser/extensions/proxy_overridden_bubble_controller.h"
 #include "chrome/browser/extensions/settings_api_bubble_controller.h"
 #include "chrome/browser/extensions/suspicious_extension_bubble_controller.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/common/chrome_version_info.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "extensions/browser/extension_pref_value_map.h"
+#include "extensions/browser/extension_pref_value_map_factory.h"
 #include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/feature_switch.h"
+#include "extensions/common/value_builder.h"
 
 namespace {
 
 const char kId1[] = "iccfkkhkfiphcjdakkmcjmkfboccmndk";
 const char kId2[] = "ajjhifimiemdpmophmkkkcijegphclbl";
 const char kId3[] = "ioibbbfddncmmabjmpokikkeiofalaek";
 
 }  // namespace
 
 namespace extensions {
@@ skipping 119 matching lines @@
     ++dismiss_button_callback_count_;
     NtpOverriddenBubbleController::OnBubbleDismiss();
   }
 
   virtual void OnLinkClicked() OVERRIDE {
     ++link_click_callback_count_;
     NtpOverriddenBubbleController::OnLinkClicked();
   }
 };
 
+// A test class for the ProxyOverriddenBubbleController.
+class TestProxyOverriddenBubbleController
+    : public ProxyOverriddenBubbleController,
+      public TestDelegate {
+ public:
+  explicit TestProxyOverriddenBubbleController(Profile* profile)
+      : ProxyOverriddenBubbleController(profile) {
+  }
+
+  virtual void OnBubbleAction() OVERRIDE {
+    ++action_button_callback_count_;
+    ProxyOverriddenBubbleController::OnBubbleAction();
+  }
+
+  virtual void OnBubbleDismiss() OVERRIDE {
+    ++dismiss_button_callback_count_;
+    ProxyOverriddenBubbleController::OnBubbleDismiss();
+  }
+
+  virtual void OnLinkClicked() OVERRIDE {
+    ++link_click_callback_count_;
+    ProxyOverriddenBubbleController::OnLinkClicked();
+  }
+};
+
 // A fake bubble used for testing the controller. Takes an action that specifies
 // 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,
   };
@@ skipping 30 matching lines @@
 
   base::Closure action_callback_;
   base::Closure dismiss_callback_;
   base::Closure link_callback_;
 };
 
 class ExtensionMessageBubbleTest : public testing::Test {
  public:
   ExtensionMessageBubbleTest() {}
 
-  void LoadGenericExtension(const std::string& index,
-                            const std::string& id,
-                            Manifest::Location location) {
-    extensions::ExtensionBuilder builder;
-    builder.SetManifest(extensions::DictionaryBuilder()
+  testing::AssertionResult LoadGenericExtension(const std::string& index,
+                                                const std::string& id,
+                                                Manifest::Location location) {
+    ExtensionBuilder builder;
+    builder.SetManifest(DictionaryBuilder()
                             .Set("name", std::string("Extension " + index))
                             .Set("version", "1.0")
                             .Set("manifest_version", 2));
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
+
+    if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
+      return testing::AssertionSuccess();
+    return testing::AssertionFailure() << "Could not install extension: " << id;
   }
 
-  void LoadExtensionWithAction(const std::string& index,
-                               const std::string& id,
-                               Manifest::Location location) {
-    extensions::ExtensionBuilder builder;
-    builder.SetManifest(extensions::DictionaryBuilder()
+  testing::AssertionResult LoadExtensionWithAction(
+      const std::string& index,
+      const std::string& id,
+      Manifest::Location location) {
+    ExtensionBuilder builder;
+    builder.SetManifest(DictionaryBuilder()
                             .Set("name", std::string("Extension " + index))
                             .Set("version", "1.0")
                             .Set("manifest_version", 2)
                             .Set("browser_action",
-                                 extensions::DictionaryBuilder().Set(
+                                 DictionaryBuilder().Set(
                                      "default_title", "Default title")));
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
+
+    if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
+      return testing::AssertionSuccess();
+    return testing::AssertionFailure() << "Could not install extension: " << id;
   }
 
-  void LoadExtensionOverridingHome(const std::string& index,
-                                   const std::string& id,
-                                   Manifest::Location location) {
-    extensions::ExtensionBuilder builder;
-    builder.SetManifest(extensions::DictionaryBuilder()
+  testing::AssertionResult LoadExtensionOverridingHome(
+      const std::string& index,
+      const std::string& id,
+      Manifest::Location location) {
+    ExtensionBuilder builder;
+    builder.SetManifest(DictionaryBuilder()
                             .Set("name", std::string("Extension " + index))
                             .Set("version", "1.0")
                             .Set("manifest_version", 2)
                             .Set("chrome_settings_overrides",
-                                 extensions::DictionaryBuilder().Set(
+                                 DictionaryBuilder().Set(
                                      "homepage", "http://www.google.com")));
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
+
+    if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
+      return testing::AssertionSuccess();
+    return testing::AssertionFailure() << "Could not install extension: " << id;
   }
 
-  void LoadExtensionOverridingStart(const std::string& index,
-                                    const std::string& id,
-                                    Manifest::Location location) {
-    extensions::ExtensionBuilder builder;
-    builder.SetManifest(extensions::DictionaryBuilder()
+  testing::AssertionResult LoadExtensionOverridingStart(
+      const std::string& index,
+      const std::string& id,
+      Manifest::Location location) {
+    ExtensionBuilder builder;
+    builder.SetManifest(DictionaryBuilder()
                             .Set("name", std::string("Extension " + index))
                             .Set("version", "1.0")
                             .Set("manifest_version", 2)
                             .Set("chrome_settings_overrides",
-                                 extensions::DictionaryBuilder().Set(
+                                 DictionaryBuilder().Set(
                                      "startup_pages",
-                                     extensions::ListBuilder().Append(
+                                     ListBuilder().Append(
                                          "http://www.google.com"))));
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
+
+    if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
+      return testing::AssertionSuccess();
+    return testing::AssertionFailure() << "Could not install extension: " << id;
   }
 
-  void LoadExtensionOverridingNtp(const std::string& index,
-                                  const std::string& id,
-                                  Manifest::Location location) {
-    extensions::ExtensionBuilder builder;
-    builder.SetManifest(extensions::DictionaryBuilder()
+  testing::AssertionResult LoadExtensionOverridingNtp(
+      const std::string& index,
+      const std::string& id,
+      Manifest::Location location) {
+    ExtensionBuilder builder;
+    builder.SetManifest(DictionaryBuilder()
                             .Set("name", std::string("Extension " + index))
                             .Set("version", "1.0")
                             .Set("manifest_version", 2)
                             .Set("chrome_url_overrides",
-                                 extensions::DictionaryBuilder().Set(
+                                 DictionaryBuilder().Set(
                                      "newtab", "Default.html")));
 
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
+
+    if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
+      return testing::AssertionSuccess();
+    return testing::AssertionFailure() << "Could not install extension: " << id;
+  }
+
+  testing::AssertionResult LoadExtensionOverridingProxy(
+      const std::string& index,
+      const std::string& id,
+      Manifest::Location location) {
+    ExtensionBuilder builder;
+    builder.SetManifest(DictionaryBuilder()
+                            .Set("name", std::string("Extension " + index))
+                            .Set("version", "1.0")
+                            .Set("manifest_version", 2)
+                            .Set("permissions",
+                                 ListBuilder().Append("proxy")));
+
+    builder.SetLocation(location);
+    builder.SetID(id);
+    service_->AddExtension(builder.Build().get());
+
+    // The proxy check relies on ExtensionPrefValueMap being up to date as to
+    // specifying which extension is controlling the proxy, but unfortunately
+    // that Map is not updated automatically for unit tests, so we simulate the
+    // update here to avoid test failures.
+    ExtensionPrefValueMap* extension_prefs_value_map =
+        ExtensionPrefValueMapFactory::GetForBrowserContext(profile());
+    extension_prefs_value_map->RegisterExtension(
+        id, base::Time::Now(), true, false);

[Devlin, 2014/06/05 19:42:54]

nit: please document anonymous bools.

+    extension_prefs_value_map->SetExtensionPref(
+        id,
+        prefs::kProxy,
+        kExtensionPrefsScopeRegular,
+                base::Value::CreateStringValue(id));

[Devlin, 2014/06/05 19:42:55]

nit: indentation mishap.

+
+    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(
             CommandLine::ForCurrentProcess(),
@@ skipping 41 matching lines @@
 #if defined(OS_WIN)
 #define MAYBE_WipeoutControllerTest WipeoutControllerTest
 #else
 #define MAYBE_WipeoutControllerTest DISABLED_WipeoutControllerTest
 #endif
 
 TEST_F(ExtensionMessageBubbleTest, MAYBE_WipeoutControllerTest) {
   Init();
   // Add three extensions, and control two of them in this test (extension 1
   // and 2).
-  LoadExtensionWithAction("1", kId1, Manifest::COMMAND_LINE);
-  LoadGenericExtension("2", kId2, Manifest::UNPACKED);
-  LoadGenericExtension("3", kId3, Manifest::EXTERNAL_POLICY);
+  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;
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_DISMISS_BUTTON);
 
   // Validate that we don't have a suppress value for the extensions.
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
   EXPECT_FALSE(prefs->HasWipeoutBeenAcknowledged(kId1));
@@ skipping 54 matching lines @@
 #define MAYBE_DevModeControllerTest DISABLED_DevModeControllerTest
 #endif
 
 TEST_F(ExtensionMessageBubbleTest, MAYBE_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.
-  LoadExtensionWithAction("1", kId1, Manifest::COMMAND_LINE);
-  LoadGenericExtension("2", kId2, Manifest::UNPACKED);
-  LoadGenericExtension("3", kId3, Manifest::EXTERNAL_POLICY);
+  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);
   controller->Show(&bubble);
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->action_click_count());
   EXPECT_EQ(1U, controller->dismiss_click_count());
-  EXPECT_TRUE(service_->GetExtensionById(kId1, false) != NULL);
-  EXPECT_TRUE(service_->GetExtensionById(kId2, false) != NULL);
+  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());
   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(service_->GetExtensionById(kId1, false) == NULL);
-  EXPECT_TRUE(service_->GetExtensionById(kId2, false) == NULL);
+  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());
   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(service_->GetExtensionById(kId1, false) != NULL);
-  EXPECT_TRUE(service_->GetExtensionById(kId2, false) != NULL);
+  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 TestDevModeBubbleController(
       profile()));
   DevModeBubbleController::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.
 #if defined(OS_WIN)
 #define MAYBE_SettingsApiControllerTest SettingsApiControllerTest
 #else
 #define MAYBE_SettingsApiControllerTest DISABLED_SettingsApiControllerTest
 #endif
 
 TEST_F(ExtensionMessageBubbleTest, MAYBE_SettingsApiControllerTest) {
   Init();
-  extensions::ExtensionPrefs* prefs =
-      extensions::ExtensionPrefs::Get(profile());
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
   for (int i = 0; i < 3; ++i) {
     switch (static_cast<SettingsApiOverrideType>(i)) {
       case BUBBLE_TYPE_HOME_PAGE:
         // Load two extensions overriding home page and one overriding something
         // unrelated (to check for interference). Extension 2 should still win
         // on the home page setting.
-        LoadExtensionOverridingHome("1", kId1, Manifest::UNPACKED);
-        LoadExtensionOverridingHome("2", kId2, Manifest::UNPACKED);
-        LoadExtensionOverridingStart("3", kId3, Manifest::UNPACKED);
+        ASSERT_TRUE(LoadExtensionOverridingHome("1", kId1, Manifest::UNPACKED));
+        ASSERT_TRUE(LoadExtensionOverridingHome("2", kId2, Manifest::UNPACKED));
+        ASSERT_TRUE(
+            LoadExtensionOverridingStart("3", kId3, Manifest::UNPACKED));
         break;
       case BUBBLE_TYPE_SEARCH_ENGINE:
         // We deliberately skip testing the search engine since it relies on
         // TemplateURLServiceFactory that isn't available while unit testing.
         // This test is only simulating the bubble interaction with the user and
         // that is more or less the same for the search engine as it is for the
         // others.
         continue;
       case BUBBLE_TYPE_STARTUP_PAGES:
         // Load two extensions overriding start page and one overriding
         // something unrelated (to check for interference). Extension 2 should
         // still win on the startup page setting.
-        LoadExtensionOverridingStart("1", kId1, Manifest::UNPACKED);
-        LoadExtensionOverridingStart("2", kId2, Manifest::UNPACKED);
-        LoadExtensionOverridingHome("3", kId3, Manifest::UNPACKED);
+        ASSERT_TRUE(
+            LoadExtensionOverridingStart("1", kId1, Manifest::UNPACKED));
+        ASSERT_TRUE(
+            LoadExtensionOverridingStart("2", kId2, Manifest::UNPACKED));
+        ASSERT_TRUE(LoadExtensionOverridingHome("3", kId3, Manifest::UNPACKED));
         break;
       default:
         NOTREACHED();
         break;
     }
 
     scoped_ptr<TestSettingsApiBubbleController> controller(
         new TestSettingsApiBubbleController(
             profile(), static_cast<SettingsApiOverrideType>(i)));
 
@@ skipping 10 matching lines @@
 
     // Simulate showing the bubble and dismissing it.
     FakeExtensionMessageBubble bubble;
     bubble.set_action_on_show(
         FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_DISMISS_BUTTON);
     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.
-    EXPECT_TRUE(service_->GetExtensionById(kId1, false) != NULL);
-    EXPECT_TRUE(service_->GetExtensionById(kId2, false) != NULL);
-    EXPECT_TRUE(service_->GetExtensionById(kId3, false) != NULL);
+    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(prefs->HasSettingsApiBubbleBeenAcknowledged(kId1));
     EXPECT_TRUE(prefs->HasSettingsApiBubbleBeenAcknowledged(kId2));
     EXPECT_FALSE(prefs->HasSettingsApiBubbleBeenAcknowledged(kId3));
     // Clean up after ourselves.
     prefs->SetSettingsApiBubbleBeenAcknowledged(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)));
     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(service_->GetExtensionById(kId1, false) != NULL);
-    EXPECT_TRUE(service_->GetExtensionById(kId2, false) != NULL);
-    EXPECT_TRUE(service_->GetExtensionById(kId3, false) != NULL);
+    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(prefs->HasSettingsApiBubbleBeenAcknowledged(kId1));
     EXPECT_TRUE(prefs->HasSettingsApiBubbleBeenAcknowledged(kId2));
     EXPECT_FALSE(prefs->HasSettingsApiBubbleBeenAcknowledged(kId3));
     // Clean up after ourselves.
     prefs->SetSettingsApiBubbleBeenAcknowledged(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));
     override_extensions = controller->GetExtensionList();
     EXPECT_EQ(1U, override_extensions.size());
     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(service_->GetExtensionById(kId1, false) != NULL);
-    EXPECT_TRUE(service_->GetExtensionById(kId2, false) == NULL);
-    EXPECT_TRUE(service_->GetExtensionById(kId3, false) != NULL);
+    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(prefs->HasSettingsApiBubbleBeenAcknowledged(kId1));
     EXPECT_FALSE(prefs->HasSettingsApiBubbleBeenAcknowledged(kId2));
     EXPECT_FALSE(prefs->HasSettingsApiBubbleBeenAcknowledged(kId3));
 
     // Clean up after ourselves.
     service_->UninstallExtension(kId1, false, NULL);
     service_->UninstallExtension(kId2, false, NULL);
     service_->UninstallExtension(kId3, false, 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) {
   Init();
-  extensions::ExtensionPrefs* prefs =
-      extensions::ExtensionPrefs::Get(profile());
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
   // 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.
-  LoadExtensionOverridingNtp("1", kId1, Manifest::UNPACKED);
-  LoadExtensionOverridingNtp("2", kId2, Manifest::UNPACKED);
-  LoadExtensionOverridingStart("3", kId3, Manifest::UNPACKED);
+  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));
   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.
-  EXPECT_TRUE(service_->GetExtensionById(kId1, false) != NULL);
-  EXPECT_TRUE(service_->GetExtensionById(kId2, false) != NULL);
-  EXPECT_TRUE(service_->GetExtensionById(kId3, false) != NULL);
+  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(prefs->HasNtpOverriddenBubbleBeenAcknowledged(kId1));
   EXPECT_TRUE(prefs->HasNtpOverriddenBubbleBeenAcknowledged(kId2));
   EXPECT_FALSE(prefs->HasNtpOverriddenBubbleBeenAcknowledged(kId3));
   // Clean up after ourselves.
   prefs->SetNtpOverriddenBubbleBeenAcknowledged(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));
   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(service_->GetExtensionById(kId1, false) != NULL);
-  EXPECT_TRUE(service_->GetExtensionById(kId2, false) != NULL);
-  EXPECT_TRUE(service_->GetExtensionById(kId3, false) != NULL);
+  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(prefs->HasNtpOverriddenBubbleBeenAcknowledged(kId1));
   EXPECT_TRUE(prefs->HasNtpOverriddenBubbleBeenAcknowledged(kId2));
   EXPECT_FALSE(prefs->HasNtpOverriddenBubbleBeenAcknowledged(kId3));
   // Clean up after ourselves.
   prefs->SetNtpOverriddenBubbleBeenAcknowledged(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());
   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(service_->GetExtensionById(kId1, false) != NULL);
-  EXPECT_TRUE(service_->GetExtensionById(kId2, false) == NULL);
-  EXPECT_TRUE(service_->GetExtensionById(kId3, false) != NULL);
+  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(prefs->HasNtpOverriddenBubbleBeenAcknowledged(kId1));
   EXPECT_FALSE(prefs->HasNtpOverriddenBubbleBeenAcknowledged(kId2));
   EXPECT_FALSE(prefs->HasNtpOverriddenBubbleBeenAcknowledged(kId3));
 
   // Clean up after ourselves.
   service_->UninstallExtension(kId1, false, NULL);
   service_->UninstallExtension(kId2, false, NULL);
   service_->UninstallExtension(kId3, false, NULL);
 }
 
+void SetInstallTime(const std::string& extension_id,
+                    const base::Time& time,
+                    ExtensionPrefs* prefs) {
+  std::string time_str = base::Int64ToString(time.ToInternalValue());
+  prefs->UpdateExtensionPref(extension_id,
+                             "install_time",
+                             new base::StringValue(time_str));
+}
+
+// The feature this is meant to test is only implemented on Windows.
+#if defined(OS_WIN)
+#define MAYBE_ProxyOverriddenControllerTest ProxyOverriddenControllerTest
+#else
+#define MAYBE_ProxyOverriddenControllerTest DISABLED_ProxyOverriddenControllerTest
+#endif
+
+TEST_F(ExtensionMessageBubbleTest, MAYBE_ProxyOverriddenControllerTest) {
+  Init();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
+  // Load two extensions overriding proxy and one overriding something
+  // unrelated (to check for interference). Extension 2 should still win
+  // on the proxy setting.
+  ASSERT_TRUE(LoadExtensionOverridingProxy("1", kId1, Manifest::UNPACKED));
+  ASSERT_TRUE(LoadExtensionOverridingProxy("2", kId2, Manifest::UNPACKED));
+  ASSERT_TRUE(LoadExtensionOverridingStart("3", kId3, Manifest::UNPACKED));
+
+  // The bubble will not show if the extension was installed in the last 7 days
+  // 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);
+
+  scoped_ptr<TestProxyOverriddenBubbleController> controller(
+      new TestProxyOverriddenBubbleController(profile()));
+
+  // The second extension is too new to warn about.
+  EXPECT_FALSE(controller->ShouldShow(kId1));
+  EXPECT_FALSE(controller->ShouldShow(kId2));
+  // Lets make it old enough.
+  SetInstallTime(kId2, old_enough, prefs);
+
+  // The list will contain one enabled unpacked extension (ext 2).
+  EXPECT_TRUE(controller->ShouldShow(kId2));
+  EXPECT_FALSE(controller->ShouldShow(kId3));
+  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());
+
+  // Simulate showing the bubble and dismissing it.
+  FakeExtensionMessageBubble bubble;
+  bubble.set_action_on_show(
+      FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_DISMISS_BUTTON);
+  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(prefs->HasProxyOverriddenBubbleBeenAcknowledged(kId1));
+  EXPECT_TRUE(prefs->HasProxyOverriddenBubbleBeenAcknowledged(kId2));
+  EXPECT_FALSE(prefs->HasProxyOverriddenBubbleBeenAcknowledged(kId3));
+  // Clean up after ourselves.
+  prefs->SetProxyOverriddenBubbleBeenAcknowledged(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));
+  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(prefs->HasProxyOverriddenBubbleBeenAcknowledged(kId1));
+  EXPECT_TRUE(prefs->HasProxyOverriddenBubbleBeenAcknowledged(kId2));
+  EXPECT_FALSE(prefs->HasProxyOverriddenBubbleBeenAcknowledged(kId3));
+  // Clean up after ourselves.
+  prefs->SetProxyOverriddenBubbleBeenAcknowledged(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());
+  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(prefs->HasProxyOverriddenBubbleBeenAcknowledged(kId1));
+  EXPECT_FALSE(prefs->HasProxyOverriddenBubbleBeenAcknowledged(kId2));
+  EXPECT_FALSE(prefs->HasProxyOverriddenBubbleBeenAcknowledged(kId3));
+
+  // Clean up after ourselves.
+  service_->UninstallExtension(kId1, false, NULL);
+  service_->UninstallExtension(kId2, false, NULL);
+  service_->UninstallExtension(kId3, false, NULL);
+}
+
 }  // namespace extensions