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));

[Marc Treib, 2016/06/17 16:34:22]

If installed_by_custodian is false, then we should probably just clear the pref
instead of setting it to false explicitly - as it is, we'll end up storing the
pref for all users, even if they're not SUs at all. So something like:
installed_by_custodian ? new base::FundamentalValue(true) : nullptr

[mamir, 2016/06/19 11:43:09]

Done.

+  ExtensionRegistry* registry = ExtensionRegistry::Get(context);
+
+  // If the installed_by_custodian flag is reset, do nothing.

[Marc Treib, 2016/06/17 16:34:22]

Hm. Is this correct? Might we need to unload the extension?
Maybe something like "if (enabled != installed_by_custodian) Reload()" ?

[mamir, 2016/06/19 11:43:09]

The unload would happen in the callback of "MayLoad" in Supervised User service.
So adding it here would be unnecessary, or what do you think?

[Marc Treib, 2016/06/20 12:42:28]

But UserMayLoad won't get called, right?

[mamir, 2016/06/20 12:46:46]

in which case?
ahaaa, you refer to when the flag is coming from Sync for example as false?

[Marc Treib, 2016/06/20 15:01:30]

Yes. If the flag is set from "true" to "false" here, then we might need to
unload the extension. The next time UserMayLoad is called for some other reason,
that will happen. But it won't get called automatically here.

[mamir, 2016/06/20 16:08:08]

Done.

+  if (!installed_by_custodian)
+    return;
+
+  // If it is already enabled, do nothing;
+  if (registry->enabled_extensions().Contains(extension_id))
+    return;
+
+  // If the extension is not installed, it may need to be reloaded.
+  // Example is a pre-installed extension that was unloaded when a
+  // supervised user flag has been received.
+  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