Remove all the ephemeral apps code.

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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 228 matching lines @@
         NOTREACHED();
     }
 
     info->available_launch_types.reset(new std::vector<management::LaunchType>(
         GetAvailableLaunchTypes(extension, delegate)));
   }
 
   return info.Pass();
 }
 
-bool ShouldNotBeVisible(const Extension* extension,
-                        content::BrowserContext* context) {
-  return (extension->ShouldNotBeVisible() ||
-          ExtensionPrefs::Get(context)->IsEphemeralApp(extension->id()));
-}
-
 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->get();
 
-    if (ShouldNotBeVisible(&extension, context))
+    if (extension.ShouldNotBeVisible())
       continue;  // Skip built-in extensions/apps.
 
     extension_list->push_back(make_linked_ptr<management::ExtensionInfo>(
         CreateExtensionInfo(extension, context).release()));
   }
 }
 
 }  // namespace
 
 bool ManagementGetAllFunction::RunSync() {
@@ skipping 154 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 || ShouldNotBeVisible(extension, browser_context()))
+  if (!extension || extension->ShouldNotBeVisible())
     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 68 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 ||
-      ShouldNotBeVisible(target_extension, browser_context())) {
+  if (!target_extension || target_extension->ShouldNotBeVisible()) {
     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 322 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 (ShouldNotBeVisible(extension, browser_context_))
+  if (extension->ShouldNotBeVisible())
     return;  // Don't dispatch events for built-in extenions.
   scoped_ptr<base::ListValue> args(new base::ListValue());
   if (event_name == management::OnUninstalled::kEventName) {
     args->Append(new base::StringValue(extension->id()));
   } else {
     scoped_ptr<management::ExtensionInfo> info =
         CreateExtensionInfo(*extension, browser_context_);
     args->Append(info->ToValue().release());
   }
 
@@ skipping 27 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