[Reland][Extensions] Enable sideloading prompt on mac on canary

chrome/browser/extensions/external_install_manager.cc

 // Copyright 2014 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/extensions/external_install_manager.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/external_install_error.h"
 #include "chrome/browser/profiles/profile.h"
+#include "components/version_info/version_info.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/feature_switch.h"
+#include "extensions/common/features/feature_channel.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_url_handlers.h"
 
 namespace extensions {
 
 namespace {
 
 // Histogram values for logging events related to externally installed
 // extensions.
 enum ExternalExtensionEvent {
@@ skipping 46 matching lines @@
   for (const auto& extension :
        ExtensionRegistry::Get(browser_context)->disabled_extensions()) {
     if (IsUnacknowledgedExternalExtension(*extension))
       unacknowledged_ids_.insert(extension->id());
   }
 }
 
 ExternalInstallManager::~ExternalInstallManager() {
 }
 
+
+bool ExternalInstallManager::IsPromptingEnabled() {
+  // Enable this feature on canary on mac.
+#if defined(OS_MACOSX) && defined(GOOGLE_CHROME_BUILD)
+  return GetCurrentChannel() <= version_info::Channel::CANARY;
+#else
+  return FeatureSwitch::prompt_for_external_extensions()->IsEnabled();
+#endif
+}
+
 void ExternalInstallManager::AddExternalInstallError(const Extension* extension,
                                                      bool is_new_profile) {
   // Error already exists or has been previously shown.
   if (base::ContainsKey(errors_, extension->id()) ||
       shown_ids_.count(extension->id()) > 0)
     return;
 
   ExternalInstallError::AlertType alert_type =
       (ManifestURL::UpdatesFromGallery(extension) && !is_new_profile)
           ? ExternalInstallError::BUBBLE_ALERT
@@ skipping 12 matching lines @@
     if (iter->second.get() == currently_visible_install_alert_)
       currently_visible_install_alert_ = nullptr;
     errors_.erase(iter);
     unacknowledged_ids_.erase(extension_id);
     UpdateExternalExtensionAlert();
   }
 }
 
 void ExternalInstallManager::UpdateExternalExtensionAlert() {
   // If the feature is not enabled do nothing.
-  if (!FeatureSwitch::prompt_for_external_extensions()->IsEnabled())
+  if (!IsPromptingEnabled())
     return;
 
   // Look for any extensions that were disabled because of being unacknowledged
   // external extensions.
   const ExtensionSet& disabled_extensions =
       ExtensionRegistry::Get(browser_context_)->disabled_extensions();
   for (const auto& id : unacknowledged_ids_) {
     if (base::ContainsKey(errors_, id) || shown_ids_.count(id) > 0)
       continue;
 
@@ skipping 82 matching lines @@
 void ExternalInstallManager::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     extensions::UninstallReason reason) {
   if (unacknowledged_ids_.erase(extension->id()))
     LogExternalExtensionEvent(extension, EXTERNAL_EXTENSION_UNINSTALLED);
 }
 
 bool ExternalInstallManager::IsUnacknowledgedExternalExtension(
     const Extension& extension) const {
-  if (!FeatureSwitch::prompt_for_external_extensions()->IsEnabled())
+  if (!IsPromptingEnabled())
     return false;
 
   int disable_reasons = extension_prefs_->GetDisableReasons(extension.id());
   bool is_from_sideload_wipeout =
       (disable_reasons & Extension::DISABLE_SIDELOAD_WIPEOUT) != 0;
   // We don't consider extensions that weren't disabled for being external so
   // that we grandfather in extensions. External extensions are only disabled on
   // install with the "prompt for external extensions" feature enabled.
   bool is_disabled_external =
       (disable_reasons & Extension::DISABLE_EXTERNAL_EXTENSION) != 0;
@@ skipping 11 matching lines @@
   // It's a shame we have to use the notification system (instead of the
   // registry observer) for this, but the ExtensionUnloaded notification is
   // not sent out if the extension is disabled (which it is here).
   const std::string& extension_id =
       content::Details<const Extension>(details).ptr()->id();
   if (base::ContainsKey(errors_, extension_id))
     RemoveExternalInstallError(extension_id);
 }
 
 }  // namespace extensions