Implement chrome.systemPrivate.getIncognitoModeAvailability extension API function

chrome/browser/extensions/extension_preference_api.cc

 // Copyright (c) 2011 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_preference_api.h"
 
 #include <map>
 
 #include "base/json/json_writer.h"
 #include "base/memory/singleton.h"
@@ skipping 11 matching lines @@
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_permission_set.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 
 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;
 };
 
 const char kNotControllable[] = "not_controllable";
 const char kControlledByOtherExtensions[] = "controlled_by_other_extensions";
 const char kControllableByThisExtension[] = "controllable_by_this_extension";
 const char kControlledByThisExtension[] = "controlled_by_this_extension";
 
 const char kIncognitoSpecific[] = "incognitoSpecific";
 const char kLevelOfControl[] = "levelOfControl";
 const char kValue[] = "value";
 
 const char kOnPrefChangeFormat[] = "types.ChromeSetting.%s.onChange";
 
+const char* kReadOnlyPrefs[] = {
+    prefs::kIncognitoModeAvailability
+};
+
 PrefMappingEntry kPrefMapping[] = {
   { "alternateErrorPagesEnabled",
     prefs::kAlternateErrorPagesEnabled,
     ExtensionAPIPermission::kExperimental
   },
   { "autofillEnabled",
     prefs::kAutofillEnabled,
     ExtensionAPIPermission::kExperimental
   },
   { "hyperlinkAuditingEnabled",
@@ skipping 29 matching lines @@
     prefs::kSafeBrowsingEnabled,
     ExtensionAPIPermission::kExperimental
   },
   { "thirdPartyCookiesAllowed",
     prefs::kBlockThirdPartyCookies,
     ExtensionAPIPermission::kExperimental
   },
   { "translationServiceEnabled",
     prefs::kEnableTranslate,
     ExtensionAPIPermission::kExperimental
+  },
+  { "incognitoModeAvailability",
+    prefs::kIncognitoModeAvailability,
+    ExtensionAPIPermission::kInvalid  // kInvalid = none required.
   }
 };
 
+// Maps prefs::kIncognitoModeAvailability values (0 = enabled, ...)
+// to strings exposed to extensions.
+const char* kIncognitoModeAvailabilityStrings[] = {
+  "enabled",
+  "disabled",
+  "forced"
+};
+
 class IdentityPrefTransformer : public PrefTransformerInterface {
  public:
   virtual Value* ExtensionToBrowserPref(const Value* extension_pref,
                                         std::string* error,
                                         bool* bad_message) {
     return extension_pref->DeepCopy();
   }
 
   virtual Value* BrowserToExtensionPref(const Value* browser_pref) {
     return browser_pref->DeepCopy();
@@ skipping 14 matching lines @@
 
  private:
   static Value* InvertBooleanValue(const Value* value) {
     bool bool_value = false;
     bool result = value->GetAsBoolean(&bool_value);
     DCHECK(result);
     return Value::CreateBooleanValue(!bool_value);
   }
 };
 
+class IncognitoModeAvailabilityTransformer : public PrefTransformerInterface {
+ public:
+  virtual Value* ExtensionToBrowserPref(const Value* extension_pref,
+                                        std::string* error,
+                                        bool* bad_message) {
+    // We do not allow extensions to modify the IncognitoModeAvailability
+    // preference. Therefore, this function is never called.
+    NOTREACHED();
+    return NULL;
+  }
+
+  virtual Value* BrowserToExtensionPref(const Value* browser_pref) {
+    int browser_pref_value;
+    if (!browser_pref->GetAsInteger(&browser_pref_value) ||
+        browser_pref_value < 0 ||
+        browser_pref_value >=
+            static_cast<int>(arraysize(kIncognitoModeAvailabilityStrings))) {
+      return NULL;
+    }
+    return Value::CreateStringValue(
+        kIncognitoModeAvailabilityStrings[browser_pref_value]);
+  }
+};
+
+// 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) {

[Bernhard Bauer, 2011/11/23 15:53:57]

Nit: Indent only two spaces.

[battre, 2011/11/23 15:56:05]

Done.

+      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(
     Profile* profile,
     const std::string& extension_id,
     const std::string& browser_pref,
     bool incognito) {
   PrefService* prefs = incognito ? profile->GetOffTheRecordPrefs()
                                  : profile->GetPrefs();
   const PrefService::Preference* pref =
       prefs->FindPreference(browser_pref.c_str());
   CHECK(pref);
   ExtensionPrefs* ep = profile->GetExtensionService()->extension_prefs();
 
+  if (IsReadOnlyPreference(browser_pref))
+    return kNotControllable;
+
   if (!pref->IsExtensionModifiable())
     return kNotControllable;
 
   if (ep->DoesExtensionControlPref(extension_id, browser_pref, incognito))
     return kControlledByThisExtension;
 
   if (ep->CanExtensionControlPref(extension_id, browser_pref, incognito))
     return kControllableByThisExtension;
 
   return kControlledByOtherExtensions;
@@ skipping 51 matching lines @@
       std::string event_name =
           base::StringPrintf(kOnPrefChangeFormat,
                              kPrefMapping[i].extension_pref);
       event_mapping_[kPrefMapping[i].browser_pref] =
           std::make_pair(event_name, kPrefMapping[i].permission);
     }
     DCHECK_EQ(arraysize(kPrefMapping), mapping_.size());
     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() {
     STLDeleteContainerPairSecondPointers(transformers_.begin(),
                                          transformers_.end());
   }
 
   void RegisterPrefTransformer(const std::string& browser_pref,
                                PrefTransformerInterface* transformer) {
     DCHECK_EQ(0u, transformers_.count(browser_pref)) <<
@@ skipping 78 matching lines @@
 
   ExtensionEventRouter* router = profile_->GetExtensionEventRouter();
   if (!router || !router->HasEventListener(event_name))
     return;
   const ExtensionList* extensions = extension_service->extensions();
   for (ExtensionList::const_iterator it = extensions->begin();
        it != extensions->end(); ++it) {
     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);
       dict->SetString(kLevelOfControl, level_of_control);
 
       std::string json_args;
       base::JSONWriter::Write(&args, false, &json_args);
 
       DispatchEvent(extension_id, event_name, json_args);
     }
@@ skipping 28 matching lines @@
     return false;
   }
 
   PrefService* prefs = incognito ? profile_->GetOffTheRecordPrefs()
                                  : profile_->GetPrefs();
   std::string browser_pref;
   ExtensionAPIPermission::ID permission = ExtensionAPIPermission::kInvalid;
   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;
   }
 
   const PrefService::Preference* pref =
       prefs->FindPreference(browser_pref.c_str());
   CHECK(pref);
   std::string level_of_control =
       GetLevelOfControl(profile_, extension_id(), browser_pref, incognito);
@@ skipping 53 matching lines @@
       !profile_->HasOffTheRecordProfile()) {
     error_ = keys::kIncognitoSessionOnlyErrorMessage;
     return false;
   }
 
   std::string browser_pref;
   ExtensionAPIPermission::ID permission = ExtensionAPIPermission::kInvalid;
   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());
   CHECK(pref);
   EXTENSION_FUNCTION_VALIDATE(value->GetType() == pref->GetType());
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   std::string error;
   bool bad_message = false;
   Value* browserPrefValue =
@@ skipping 39 matching lines @@
       error_ = "Can't modify regular settings from an incognito context.";
       return false;
     }
   }
 
   std::string browser_pref;
   ExtensionAPIPermission::ID permission = ExtensionAPIPermission::kInvalid;
   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;
 }