Simplify managing visibility of extensions in settings.

extensions/browser/api/management/management_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 "extensions/browser/api/management/management_api.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 239 matching lines @@
   return info;
 }
 
 void AddExtensionInfo(const ExtensionSet& extensions,
                       ExtensionInfoList* extension_list,
                       content::BrowserContext* context) {
   for (ExtensionSet::const_iterator iter = extensions.begin();
        iter != extensions.end(); ++iter) {
     const Extension& extension = **iter;
 
-    if (extension.ShouldNotBeVisible())
-      continue;  // Skip built-in extensions/apps.
+    if (!extension.ShouldExposeViaManagementAPI())
+      continue;
 
     extension_list->push_back(CreateExtensionInfo(extension, context));
   }
 }
 
 }  // namespace
 
 ExtensionFunction::ResponseAction ManagementGetAllFunction::Run() {
   ExtensionInfoList extensions;
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context());
@@ skipping 137 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params.get());
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context());
   const ManagementAPIDelegate* delegate = ManagementAPI::GetFactoryInstance()
                                               ->Get(browser_context())
                                               ->GetDelegate();
 
   extension_id_ = params->id;
 
   const Extension* extension =
       registry->GetExtensionById(extension_id_, ExtensionRegistry::EVERYTHING);
-  if (!extension || extension->ShouldNotBeVisible())
+  if (!extension || !extension->ShouldExposeViaManagementAPI())
     return RespondNow(Error(keys::kNoExtensionError, extension_id_));
 
   bool enabled = params->enabled;
   const ManagementPolicy* policy =
       ExtensionSystem::Get(browser_context())->management_policy();
   if (!policy->UserMayModifySettings(extension, nullptr) ||
       (!enabled && policy->MustRemainEnabled(extension, nullptr)) ||
       (enabled && policy->MustRemainDisabled(extension, nullptr, nullptr))) {
     return RespondNow(Error(keys::kUserCantModifyError, extension_id_));
   }
@@ skipping 70 matching lines @@
     const std::string& target_extension_id,
     bool show_confirm_dialog) {
   const ManagementAPIDelegate* delegate = ManagementAPI::GetFactoryInstance()
                                               ->Get(browser_context())
                                               ->GetDelegate();
   target_extension_id_ = target_extension_id;
   const Extension* target_extension =
       extensions::ExtensionRegistry::Get(browser_context())
           ->GetExtensionById(target_extension_id_,
                              ExtensionRegistry::EVERYTHING);
-  if (!target_extension || target_extension->ShouldNotBeVisible()) {
+  if (!target_extension || !target_extension->ShouldExposeViaManagementAPI()) {
     return RespondNow(Error(keys::kNoExtensionError, target_extension_id_));
   }
 
   ManagementPolicy* policy =
       ExtensionSystem::Get(browser_context())->management_policy();
   if (!policy->UserMayModifySettings(target_extension, nullptr) ||
       policy->MustRemainInstalled(target_extension, nullptr)) {
     return RespondNow(Error(keys::kUserCantModifyError, target_extension_id_));
   }
 
@@ skipping 316 matching lines @@
     const Extension* extension,
     extensions::UninstallReason reason) {
   BroadcastEvent(extension, events::MANAGEMENT_ON_UNINSTALLED,
                  management::OnUninstalled::kEventName);
 }
 
 void ManagementEventRouter::BroadcastEvent(
     const Extension* extension,
     events::HistogramValue histogram_value,
     const char* event_name) {
-  if (extension->ShouldNotBeVisible())
-    return;  // Don't dispatch events for built-in extenions.
+  if (!extension->ShouldExposeViaManagementAPI())
+    return;
   std::unique_ptr<base::ListValue> args(new base::ListValue());
   if (event_name == management::OnUninstalled::kEventName) {
     args->AppendString(extension->id());
   } else {
     args->Append(CreateExtensionInfo(*extension, browser_context_).ToValue());
   }
 
   EventRouter::Get(browser_context_)
       ->BroadcastEvent(std::unique_ptr<Event>(
           new Event(histogram_value, event_name, std::move(args))));
@@ skipping 24 matching lines @@
 ManagementAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void ManagementAPI::OnListenerAdded(const EventListenerInfo& details) {
   management_event_router_.reset(new ManagementEventRouter(browser_context_));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions