[Extensions] Move remaining notifications out of ExtensionSettingsHandler

chrome/browser/extensions/api/developer_private/developer_private_api.cc

 // Copyright (c) 2012 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/api/developer_private/developer_private_api.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 137 matching lines @@
       break;
     }
   }
 
   UMA_HISTOGRAM_BOOLEAN("ExtensionSettings.ShouldDoVerificationCheck",
                         should_do_verification_check);
   if (should_do_verification_check)
     InstallVerifier::Get(context)->VerifyAllExtensions();
 }
 
+scoped_ptr<developer::ProfileInfo> CreateProfileInfo(Profile* profile) {
+  scoped_ptr<developer::ProfileInfo> info(new developer::ProfileInfo());
+  info->is_supervised = profile->IsSupervised();
+  PrefService* prefs = profile->GetPrefs();
+  info->is_incognito_available =
+      IncognitoModePrefs::GetAvailability(prefs) !=
+          IncognitoModePrefs::DISABLED;
+  info->in_developer_mode =
+      !info->is_supervised &&

[not at google - send to devlin, 2015/05/19 20:35:04]

I wonder why supervised users are called out here. Marc, why can't they use
developer mode?

[Devlin, 2015/05/19 22:01:08]

(Since this isn't a behavior change, I'll commit now, but still good to hear
what Marc says.)

[Marc Treib, 2015/05/20 08:07:27]

This is from before my time, so I might be missing things here :)

Supervised users aren't allowed to install extensions, and developer mode would
allow them to sideload extensions. In fact, until quite recently, they couldn't
use extensions at all, so I guess there was just no point to developer mode. We
might want to revisit this decision now...

[not at google - send to devlin, 2015/05/20 21:32:32]

Yeah seems like a perfectly reasonable thing for supervised users to do... write
extensions :-)

+      prefs->GetBoolean(prefs::kExtensionsUIDeveloperMode);
+  info->app_info_dialog_enabled = CanShowAppInfoDialog();
+  info->can_load_unpacked =
+      !ExtensionManagementFactory::GetForBrowserContext(profile)
+          ->BlacklistedByDefault();
+  return info.Pass();
+}
+
 }  // namespace
 
 namespace ChoosePath = api::developer_private::ChoosePath;
 namespace GetItemsInfo = api::developer_private::GetItemsInfo;
 namespace PackDirectory = api::developer_private::PackDirectory;
 namespace Reload = api::developer_private::Reload;
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<DeveloperPrivateAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 13 matching lines @@
     : profile_(Profile::FromBrowserContext(context)) {
   RegisterNotifications();
 }
 
 DeveloperPrivateEventRouter::DeveloperPrivateEventRouter(Profile* profile)
     : extension_registry_observer_(this),
       error_console_observer_(this),
       process_manager_observer_(this),
       app_window_registry_observer_(this),
       extension_action_api_observer_(this),
+      warning_service_observer_(this),
+      extension_prefs_observer_(this),
+      extension_management_observer_(this),
       profile_(profile),
       event_router_(EventRouter::Get(profile_)),
       weak_factory_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
   error_console_observer_.Add(ErrorConsole::Get(profile));
   process_manager_observer_.Add(ProcessManager::Get(profile));
   app_window_registry_observer_.Add(AppWindowRegistry::Get(profile));
   extension_action_api_observer_.Add(ExtensionActionAPI::Get(profile));
+  warning_service_observer_.Add(WarningService::Get(profile));
+  extension_prefs_observer_.Add(ExtensionPrefs::Get(profile));
+  extension_management_observer_.Add(
+      ExtensionManagementFactory::GetForBrowserContext(profile));
 }
 
 DeveloperPrivateEventRouter::~DeveloperPrivateEventRouter() {
 }
 
 void DeveloperPrivateEventRouter::AddExtensionId(
     const std::string& extension_id) {
   extension_ids_.insert(extension_id);
 }
 
@@ skipping 75 matching lines @@
   BroadcastItemStateChanged(developer::EVENT_TYPE_VIEW_UNREGISTERED,
                             window->extension_id());
 }
 
 void DeveloperPrivateEventRouter::OnExtensionActionVisibilityChanged(
     const std::string& extension_id,
     bool is_now_visible) {
   BroadcastItemStateChanged(developer::EVENT_TYPE_PREFS_CHANGED, extension_id);
 }
 
+void DeveloperPrivateEventRouter::OnExtensionDisableReasonsChanged(
+    const std::string& extension_id, int disable_reasons) {
+  BroadcastItemStateChanged(developer::EVENT_TYPE_PREFS_CHANGED, extension_id);
+}
+
+void DeveloperPrivateEventRouter::OnExtensionManagementSettingsChanged() {
+  scoped_ptr<base::DictionaryValue> dict =
+      CreateProfileInfo(profile_)->ToValue();
+  scoped_ptr<base::ListValue> args(new base::ListValue());
+  args->Append(dict.release());

[not at google - send to devlin, 2015/05/19 20:35:04]

I'd prefer inlining |dict| as just CreateProfileInfo(profile_)->ToValue(), not
because I'm pedantic, but because after this line |dict| is null and if anybody
tries to use it then bad things will happen. Inlining is both cleaner and avoid
this problem.

[Devlin, 2015/05/19 22:01:07]

I'm not sure I buy your safety argument, but I like inlining things anyway, so
done. ;)

+  scoped_ptr<Event> event(new Event(
+      developer::OnProfileStateChanged::kEventName, args.Pass()));
+  event_router_->BroadcastEvent(event.Pass());
+}
+
+void DeveloperPrivateEventRouter::ExtensionWarningsChanged(
+    const std::set<std::string>& affected_extensions) {
+  for (const std::string& id : affected_extensions)
+    BroadcastItemStateChanged(developer::EVENT_TYPE_WARNINGS_CHANGED, id);

[not at google - send to devlin, 2015/05/19 20:35:04]

These event broadcasts in loops make me sad. We should be coalescing them. Oh
well.

[Devlin, 2015/05/19 22:01:07]

We should be, but that's a much larger change.  And, more importantly, the
chance of warnings being added for multiple extensions is pretty low.  Lower yet
for it to happen when the user just so happens to have chrome://extensions open.
 So we need to do it, because of The Law of a Billion Users, but don't agonize.
:)

+}
+
 void DeveloperPrivateEventRouter::BroadcastItemStateChanged(
     developer::EventType event_type,
     const std::string& extension_id) {
   scoped_ptr<ExtensionInfoGenerator> info_generator(
       new ExtensionInfoGenerator(profile_));
   ExtensionInfoGenerator* info_generator_weak = info_generator.get();
   info_generator_weak->CreateExtensionInfo(
       extension_id,
       base::Bind(&DeveloperPrivateEventRouter::BroadcastItemStateChangedHelper,
                  weak_factory_.GetWeakPtr(),
@@ skipping 188 matching lines @@
 
   Respond(ArgumentList(developer::GetItemsInfo::Results::Create(item_list)));
 }
 
 DeveloperPrivateGetProfileConfigurationFunction::
 ~DeveloperPrivateGetProfileConfigurationFunction() {
 }
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateGetProfileConfigurationFunction::Run() {
-  developer::ProfileInfo info;
-  info.is_supervised = GetProfile()->IsSupervised();
-  info.is_incognito_available =
-      IncognitoModePrefs::GetAvailability(GetProfile()->GetPrefs()) !=
-          IncognitoModePrefs::DISABLED;
-  info.in_developer_mode =
-      !info.is_supervised &&
-      GetProfile()->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode);
-  info.app_info_dialog_enabled = CanShowAppInfoDialog();
-  info.can_load_unpacked =
-      !ExtensionManagementFactory::GetForBrowserContext(browser_context())
-          ->BlacklistedByDefault();
+  scoped_ptr<developer::ProfileInfo> info = CreateProfileInfo(GetProfile());
 
   // If this is called from the chrome://extensions page, we use this as a
   // heuristic that it's a good time to verify installs. We do this on startup,
   // but there's a chance that it failed erroneously, so it's good to double-
   // check.
   if (source_context_type() == Feature::WEBUI_CONTEXT)
     PerformVerificationCheck(browser_context());
 
-  return RespondNow(OneArgument(info.ToValue()));
+  return RespondNow(OneArgument(info->ToValue()));
 }
 
 DeveloperPrivateUpdateProfileConfigurationFunction::
 ~DeveloperPrivateUpdateProfileConfigurationFunction() {
 }
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateUpdateProfileConfigurationFunction::Run() {
   scoped_ptr<developer::UpdateProfileConfiguration::Params> params(
       developer::UpdateProfileConfiguration::Params::Create(*args_));
@@ skipping 810 matching lines @@
   // We explicitly show manifest.json in order to work around an issue in OSX
   // where opening the directory doesn't focus the Finder.
   platform_util::ShowItemInFolder(GetProfile(),
                                   extension->path().Append(kManifestFilename));
   return RespondNow(NoArguments());
 }
 
 }  // namespace api
 
 }  // namespace extensions