Replace the WAS_INSTALLED_BY_CUSTODIAN creation flag with a pref

chrome/browser/extensions/extension_util.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/extensions/extension_util.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/values.h"
@@ skipping 36 matching lines @@
 
 // The entry into the ExtensionPrefs for allowing an extension to script on
 // all urls without explicit permission.
 const char kExtensionAllowedOnAllUrlsPrefName[] =
     "extension_can_script_all_urls";
 
 // The entry into the prefs for when a user has explicitly set the "extension
 // allowed on all urls" pref.
 const char kHasSetScriptOnAllUrlsPrefName[] = "has_set_script_all_urls";
 
+// The entry into the prefs used to flag an extension as installed by custodian.
+// It is relevant only for supervised users
+const char kWasInstalledByCustodianPrefName[] = "was_installed_by_custodian";
+
 // Returns true if |extension| should always be enabled in incognito mode.
 bool IsWhitelistedForIncognito(const Extension* extension) {
   const Feature* feature = FeatureProvider::GetBehaviorFeature(
       BehaviorFeature::kWhitelistedForIncognito);
   return feature && feature->IsAvailableToExtension(extension).is_available();
 }
 
 // Returns |extension_id|. See note below.
 std::string ReloadExtensionIfEnabled(const std::string& extension_id,
                                      content::BrowserContext* context) {
@@ skipping 146 matching lines @@
   // Reload to update browser state. Only bother if the value changed and the
   // extension is actually enabled, since there is no UI otherwise.
   if (allow == AllowFileAccess(extension_id, context))
     return;
 
   ExtensionPrefs::Get(context)->SetAllowFileAccess(extension_id, allow);
 
   ReloadExtensionIfEnabled(extension_id, context);
 }
 
+void SetWasInstalledByCustodian(const std::string& extension_id,
+                                content::BrowserContext* context,
+                                bool installed_by_custodian) {
+  ExtensionPrefs::Get(context)->UpdateExtensionPref(
+      extension_id, kWasInstalledByCustodianPrefName,
+      new base::FundamentalValue(installed_by_custodian));
+  ExtensionRegistry* registry = ExtensionRegistry::Get(context);
+
+  // If it is already enabled, nothing to be done.

[Marc Treib, 2016/06/16 12:35:39]

This is assuming that |installed_by_custodian| is true, yes? If it can never be
set to false, then remove the parameter.

[mamir, 2016/06/17 08:33:18]

Yes.
It can never be set to false, but I left the parameter for consistency with
other methods.
I removed it.

+  if (registry->enabled_extensions().Contains(extension_id))
+    return;
+
+  // If the extension is not installed, it may need to be reloaded.

[Marc Treib, 2016/06/16 12:35:39]

Why?
Is there any situation where registry->GetInstalledExtension would return null,
but reloading will do anything?

[mamir, 2016/06/17 08:33:18]

Pre-installed extensions that get unloaded after Chrome knows it's a supervised
user.

[Marc Treib, 2016/06/17 08:56:54]

And in that case, GetInstalledExtension won't return it at all? Okay, maybe
mention that in the comment?
(I think GetInstalledExtension is really misnamed, making this super confusing
to read...)

[mamir, 2016/06/17 16:12:54]

Done.

+  const Extension* extension = registry->GetInstalledExtension(extension_id);
+  if (!extension) {
+    ExtensionService* service =
+        ExtensionSystem::Get(context)->extension_service();
+    service->ReloadExtension(extension_id);
+  }
+}
+
+bool WasInstalledByCustodian(const std::string& extension_id,
+                             content::BrowserContext* context) {
+  bool installed_by_custodian = false;
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(context);
+  prefs->ReadPrefAsBoolean(extension_id, kWasInstalledByCustodianPrefName,
+                           &installed_by_custodian);
+  return installed_by_custodian;
+}
+
 bool AllowedScriptingOnAllUrls(const std::string& extension_id,
                                content::BrowserContext* context) {
   bool allowed = false;
   ExtensionPrefs* prefs = ExtensionPrefs::Get(context);
   if (!prefs->ReadPrefAsBoolean(extension_id,
                                 kExtensionAllowedOnAllUrlsPrefName,
                                 &allowed)) {
     // If there is no value present, we make one, defaulting it to the value of
     // the 'scripts require action' flag. If the flag is on, then the extension
     // does not have permission to script on all urls by default.
@@ skipping 138 matching lines @@
 
 bool CanHostedAppsOpenInWindows() {
 #if defined(OS_MACOSX)
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableHostedAppsInWindows);
 #else
   return true;
 #endif
 }
 
-bool IsExtensionSupervised(const Extension* extension, const Profile* profile) {
-  return extension->was_installed_by_custodian() && profile->IsSupervised();
+bool IsExtensionSupervised(const Extension* extension, Profile* profile) {
+  return WasInstalledByCustodian(extension->id(), profile) &&
+         profile->IsSupervised();
 }
 
 bool NeedCustodianApprovalForPermissionIncrease(const Profile* profile) {
   if (!profile->IsSupervised())
     return false;
   // Query the trial group name first, to make sure it's properly initialized.
   base::FieldTrialList::FindFullName(
       kSupervisedUserExtensionPermissionIncreaseFieldTrialName);
   std::string value = variations::GetVariationParamValue(
       kSupervisedUserExtensionPermissionIncreaseFieldTrialName,
       profile->IsChild() ? "child_account" : "legacy_supervised_user");
   return value == "true";
 }
 
 }  // namespace util
 }  // namespace extensions