Implement chrome.systemPrivate.getIncognitoModeAvailability extension API function

chrome/browser/extensions/extension_preference_api.cc

Index: chrome/browser/extensions/extension_preference_api.cc
diff --git a/chrome/browser/extensions/extension_preference_api.cc b/chrome/browser/extensions/extension_preference_api.cc
index 871d99bcac5fca3cc678cfa9226c7510fe0f745a..4e79b29748fd9326453c80bee2ba49713e32e5cd 100644
--- a/chrome/browser/extensions/extension_preference_api.cc
+++ b/chrome/browser/extensions/extension_preference_api.cc
@@ -18,6 +18,7 @@
 #include "chrome/browser/extensions/extension_prefs_scope.h"
 #include "chrome/browser/extensions/extension_proxy_api.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_system_api.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_error_utils.h"
@@ -29,8 +30,15 @@
 namespace {
 
 struct PrefMappingEntry {
+  // Name of the preference referenced by extension_api.json.
   const char* extension_pref;
+
+  // Name of the preference in the PrefStores.
   const char* browser_pref;
+
+  // Permission required to access this preference.
+  // Use ExtensionAPIPermission::kInvalid for |permission| to express that no
+  // permission is necessary.
   ExtensionAPIPermission::ID permission;
 };
 
@@ -45,6 +53,10 @@ const char kValue[] = "value";
 
 const char kOnPrefChangeFormat[] = "types.ChromeSetting.%s.onChange";
 
+const char* kReadOnlyPrefs[] = {

[Aaron Boodman, 2011/11/28 19:32:44]

Does it really make sense to overload the content settings API to serve this
different purpose?

It seems likely to cause coupling problems. And when it comes down to it the
implementation of isIncognitoAvailable() is like one line. It seems harder to
share it than it's worth.

[battre, 2011/11/28 20:23:16]

We lose two things:
- subscription to changes (they can be triggered by policy changes)
- possibility to allow setting preference values in the future.

If this was a public API I'd probably stick to the current implementation. As it
is private and we can change all callers later in case we decide that we want to
allow extensions to either subscribe to or set the preference.

+    prefs::kIncognitoModeAvailability
+};
+
 PrefMappingEntry kPrefMapping[] = {
   { "alternateErrorPagesEnabled",
     prefs::kAlternateErrorPagesEnabled,
@@ -94,6 +106,10 @@ PrefMappingEntry kPrefMapping[] = {
   { "translationServiceEnabled",
     prefs::kEnableTranslate,
     ExtensionAPIPermission::kExperimental
+  },
+  { "incognitoModeAvailability",
+    prefs::kIncognitoModeAvailability,
+    ExtensionAPIPermission::kInvalid  // kInvalid = none required.
   }
 };
 
@@ -131,6 +147,23 @@ class InvertBooleanTransformer : public PrefTransformerInterface {
   }
 };
 
+// Checks whether an extension has a specific permission but considers
+// ExtensionAPIPermission::kInvalid a wildcard that is possessed by every
+// extension.
+bool HasAPIPermission(const Extension* extension,
+                      ExtensionAPIPermission::ID permission) {
+  return permission == ExtensionAPIPermission::kInvalid ||
+         extension->HasAPIPermission(permission);
+}
+
+bool IsReadOnlyPreference(const std::string& browser_pref) {
+  for (size_t i = 0; i < arraysize(kReadOnlyPrefs); ++i) {
+    if (kReadOnlyPrefs[i] == browser_pref)
+      return true;
+  }
+  return false;
+}
+
 // Returns a string constant (defined in the API) indicating the level of
 // control this extension has over the specified preference.
 const char* GetLevelOfControl(
@@ -145,6 +178,9 @@ const char* GetLevelOfControl(
   CHECK(pref);
   ExtensionPrefs* ep = profile->GetExtensionService()->extension_prefs();
 
+  if (IsReadOnlyPreference(browser_pref))
+    return kNotControllable;
+
   if (!pref->IsExtensionModifiable())
     return kNotControllable;
 
@@ -216,7 +252,9 @@ class PrefMapping {
     DCHECK_EQ(arraysize(kPrefMapping), event_mapping_.size());
     RegisterPrefTransformer(prefs::kProxy, new ProxyPrefTransformer());
     RegisterPrefTransformer(prefs::kBlockThirdPartyCookies,
-                            new InvertBooleanTransformer());
+        new InvertBooleanTransformer());
+    RegisterPrefTransformer(prefs::kIncognitoModeAvailability,
+        new IncognitoModeAvailabilityTransformer());
   }
 
   ~PrefMapping() {
@@ -315,7 +353,7 @@ void ExtensionPreferenceEventRouter::OnPrefChanged(
     std::string extension_id = (*it)->id();
     // TODO(bauerb): Only iterate over registered event listeners.
     if (router->ExtensionHasEventListener(extension_id, event_name) &&
-        (*it)->HasAPIPermission(permission) &&
+        HasAPIPermission(it->get(), permission) &&
         (!incognito || extension_service->CanCrossIncognito(*it))) {
       std::string level_of_control =
           GetLevelOfControl(profile_, extension_id, browser_pref, incognito);
@@ -364,7 +402,7 @@ bool GetPreferenceFunction::RunImpl() {
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
           pref_key, &browser_pref, &permission));
-  if (!GetExtension()->HasAPIPermission(permission)) {
+  if (!HasAPIPermission(GetExtension(), permission)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kPermissionErrorMessage, pref_key);
     return false;
@@ -438,11 +476,18 @@ bool SetPreferenceFunction::RunImpl() {
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
           pref_key, &browser_pref, &permission));
-  if (!GetExtension()->HasAPIPermission(permission)) {
+  if (!HasAPIPermission(GetExtension(), permission)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kPermissionErrorMessage, pref_key);
     return false;
   }
+
+  if (IsReadOnlyPreference(browser_pref)) {
+    error_ = ExtensionErrorUtils::FormatErrorMessage(
+        keys::kCannotModifyReadOnlyMessage, pref_key);
+    return false;
+  }
+
   ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
   const PrefService::Preference* pref =
       prefs->pref_service()->FindPreference(browser_pref.c_str());
@@ -502,11 +547,18 @@ bool ClearPreferenceFunction::RunImpl() {
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
           pref_key, &browser_pref, &permission));
-  if (!GetExtension()->HasAPIPermission(permission)) {
+  if (!HasAPIPermission(GetExtension(), permission)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kPermissionErrorMessage, pref_key);
     return false;
   }
+
+  if (IsReadOnlyPreference(browser_pref)) {
+    error_ = ExtensionErrorUtils::FormatErrorMessage(
+        keys::kCannotModifyReadOnlyMessage, pref_key);
+    return false;
+  }
+
   ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
   prefs->RemoveExtensionControlledPref(extension_id(), browser_pref, scope);
   return true;