Enable extensions error button test that was failing on stable.

chrome/browser/ui/webui/extensions/extension_settings_browsertest.cc

 // Copyright 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 "chrome/browser/ui/webui/extensions/extension_settings_browsertest.h"
 
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 16 matching lines @@
 #include "extensions/browser/api/management/management_api.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/test_extension_registry_observer.h"
 #include "extensions/common/extension_set.h"
 
 using extensions::Extension;
 using extensions::TestManagementPolicyProvider;
 
 ExtensionSettingsUIBrowserTest::ExtensionSettingsUIBrowserTest()
-    : profile_(NULL),
+    : profile_(nullptr),
       policy_provider_(TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS |
                        TestManagementPolicyProvider::MUST_REMAIN_ENABLED |
                        TestManagementPolicyProvider::MUST_REMAIN_INSTALLED) {
   CHECK(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_));
   test_data_dir_ = test_data_dir_.AppendASCII("extensions");
 }
 
 ExtensionSettingsUIBrowserTest::~ExtensionSettingsUIBrowserTest() {}
 
 Profile* ExtensionSettingsUIBrowserTest::GetProfile() {
@@ skipping 35 matching lines @@
 
 void ExtensionSettingsUIBrowserTest::AddManagedPolicyProvider() {
   auto* extension_service = extensions::ExtensionSystem::Get(GetProfile());
   extension_service->management_policy()->RegisterProvider(&policy_provider_);
 }
 
 void ExtensionSettingsUIBrowserTest::SetAutoConfirmUninstall() {
   extensions::ManagementUninstallFunctionBase::SetAutoConfirmForTest(true);
 }
 
+void ExtensionSettingsUIBrowserTest::EnableErrorConsole() {
+  error_console_override_.reset(new extensions::FeatureSwitch::ScopedOverride(
+      extensions::FeatureSwitch::error_console(), true));
+  channel_override_.reset(new extensions::ScopedCurrentChannel(
+      chrome::VersionInfo::CHANNEL_DEV));

[Dan Beam, 2015/05/07 21:47:34]

i don't like doing these things because it changes the browser's channel in the
middle of a test...

can't we just do the typical test-only hacking where we make a method virtual
and derive it for testing, e.g. 

real_thing.cc

  class RealThing {
   public:
    virtual bool CanThisDoSomething() { return false; }
  };

real_thing_test.cc

  class TestThing : public RealThing {
   public:
    bool CanThisDoSomething() override { return true; }
  };

or just make a RealThing::OverrideForTesting() (and allow only the test to
access it, preferably).

[Devlin, 2015/05/07 21:53:36]

I'm not super keen on the channels either, but I don't think we need a virtual
class here.  Instead, what about just having ErrorConsole check for if the
feature switch is deliberately disabled (i.e.,
FeatureSwitch::error_console()->GetOverrideValue() == OVERRIDE_DISABLED).

[hcarmona, 2015/05/07 22:49:53]

Updated the ErrorConsole check and removed the channel override.

+}
+
+void ExtensionSettingsUIBrowserTest::DisableErrorConsole() {
+  error_console_override_.reset(new extensions::FeatureSwitch::ScopedOverride(
+      extensions::FeatureSwitch::error_console(), false));
+  channel_override_.reset(new extensions::ScopedCurrentChannel(
+      chrome::VersionInfo::CHANNEL_STABLE));
+}
+
 class MockAutoConfirmExtensionInstallPrompt : public ExtensionInstallPrompt {
  public:
   explicit MockAutoConfirmExtensionInstallPrompt(
       content::WebContents* web_contents)
     : ExtensionInstallPrompt(web_contents) {}
 
   // Proceed without confirmation prompt.
   void ConfirmInstall(Delegate* delegate,
                       const Extension* extension,
                       const ShowDialogCallback& show_dialog_callback) override {
     delegate->InstallUIProceed();
   }
 };
 
 const Extension* ExtensionSettingsUIBrowserTest::InstallUnpackedExtension(
     const base::FilePath& path) {
   if (path.empty())
-    return NULL;
+    return nullptr;
 
   Profile* profile = GetProfile();
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   service->set_show_extensions_prompts(false);
   extensions::ExtensionRegistry* registry =
       extensions::ExtensionRegistry::Get(profile);
   extensions::TestExtensionRegistryObserver observer(registry);
   extensions::UnpackedInstaller::Create(service)->Load(path);
   base::FilePath extension_path = base::MakeAbsoluteFilePath(path);
@@ skipping 15 matching lines @@
   service->set_show_extensions_prompts(false);
   size_t num_before = registry->enabled_extensions().size();
   {
     scoped_ptr<ExtensionInstallPrompt> install_ui;
     install_ui.reset(new MockAutoConfirmExtensionInstallPrompt(
         browser()->tab_strip_model()->GetActiveWebContents()));
 
     base::FilePath crx_path = path;
     DCHECK(crx_path.Extension() == FILE_PATH_LITERAL(".crx"));
     if (crx_path.empty())
-      return NULL;
+      return nullptr;
 
     scoped_refptr<extensions::CrxInstaller> installer(
         extensions::CrxInstaller::Create(service, install_ui.Pass()));
     installer->set_expected_id(std::string());
     installer->set_is_gallery_install(false);
     installer->set_install_source(extensions::Manifest::INTERNAL);
     installer->set_install_immediately(true);
     installer->set_off_store_install_allow_reason(
         extensions::CrxInstaller::OffStoreInstallAllowedInTest);
 
@@ skipping 16 matching lines @@
          registry->enabled_extensions())
       VLOG(1) << "  " << extension->id();
 
     VLOG(1) << "Errors follow:";
     const std::vector<base::string16>* errors =
         ExtensionErrorReporter::GetInstance()->GetErrors();
     for (std::vector<base::string16>::const_iterator iter = errors->begin();
          iter != errors->end(); ++iter)
       VLOG(1) << *iter;
 
-    return NULL;
+    return nullptr;
   }
 
   if (!observer_->WaitForExtensionViewsToLoad())
-    return NULL;
+    return nullptr;
   return service->GetExtensionById(last_loaded_extension_id(), false);
 }