Implement chrome.systemPrivate.getIncognitoModeAvailability extension API function

chrome/browser/extensions/extension_preference_api.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.

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

Can you file one or more bugs for yourself to fix the following issues:

1. Move extension_preference_api elsewhere. See crbug.com/101244. If there's no
home outside of chrome/browser/extensions that makes sense, you can make a
subdir inside extensions.

2. Rename to content_settings_extension_api (or content_settings_api if inside
browser/extensions/).

3. Remove extension_preference_api_constants*. No longer needed. These can be in
an anonymous namespace inside the cc file.

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

I will do that, though I am pretty sad seeing that extensions are moved out of
chrome/browser/extensions. I'd have preferred if all extensions were moved to
chrome/browser/extensions/${extension_api_name} as it used to be a very handy
reference to look up how things are done in extensions-land by just peeking at
other examples. Searching for other extensions in the code base seems more
disadvantageous to me than having the extensions in said sub directories.

Anyways, thats just for the record. It's your call and I will move my
extensions.
um you mean extension_preference_extension_api? So
chrome/browser/extensions/preference/preference_extension_api.cc?

Would you prefer chrome/browser/extensions/types/types_extension_api.cc as this
is the namespace exposed to extensions? (see
http://code.google.com/chrome/extensions/trunk/types.html)

I am not sure whether "types" would make the code more discoverable. I tend to
prefer the "preference" path.
adding *_constants.* files was part of readability reviews, AFAIK. I wasn't a
big fan of that but it was considered clean style.

[Bernhard Bauer, 2011/11/29 10:00:01]

If we want to move this outside of chrome/browser/extensions,
chrome/browser/prefs might make sense?

 // 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"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_preference_api_constants.h"
 #include "chrome/browser/extensions/extension_preference_helpers.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #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"
 #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[] = {

[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,
     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.
   }
 };
 
 class IdentityPrefTransformer : public PrefTransformerInterface {
  public:
   virtual Value* ExtensionToBrowserPref(const Value* extension_pref,
                                         std::string* error,
                                         bool* bad_message) {
     return extension_pref->DeepCopy();
   }
@@ skipping 17 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);
   }
 };
 
+// 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(
     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;
 }