Support persistent incognito preferences

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"
 #include "base/stl_util-inl.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.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/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "content/common/notification_type.h"
 #include "content/common/notification_service.h"
 
 namespace {
 
 struct PrefMappingEntry {
   const char* extension_pref;
   const char* browser_pref;
   const char* permission;
 };
 
 const char kNotControllable[] = "NotControllable";
 const char kControlledByOtherExtensions[] = "ControlledByOtherExtensions";
 const char kControllableByThisExtension[] = "ControllableByThisExtension";
 const char kControlledByThisExtension[] = "ControlledByThisExtension";
 
 const char kIncognito[] = "incognito";
 const char kIncognitoSpecific[] = "incognitoSpecific";
+const char kScope[] = "scope";
 const char kLevelOfControl[] = "levelOfControl";
+const char kRegular[] = "regular";
+const char kIncognitoPersistent[] = "incognito_persistent";
 const char kValue[] = "value";
 
 const char kOnPrefChangeFormat[] =
     "preferences.%s.onChange";
 
 const char kIncognitoErrorMessage[] =
     "You do not have permission to access incognito preferences.";
 
 const char kPermissionErrorMessage[] =
     "You do not have permission to access the preference '%s'. "
@@ skipping 53 matching lines @@
 
   if (ep->DoesExtensionControlPref(extension_id, browser_pref, incognito))
     return kControlledByThisExtension;
 
   if (ep->CanExtensionControlPref(extension_id, browser_pref, incognito))
     return kControllableByThisExtension;
 
   return kControlledByOtherExtensions;
 }
 
+extension_prefs_scope::Scope StringToScope(const std::string& s) {
+  if (s == kRegular) {
+    return extension_prefs_scope::kRegular;
+  } else if (s == kIncognitoPersistent) {
+    return extension_prefs_scope::kIncognitoPersistent;
+  } else {
+    // The extension API checks that no invalid string can be passed.
+    NOTREACHED();

[Bernhard Bauer, 2011/05/25 00:43:00]

In that case you should fail validation (EXTENSION_FUNCTION_VALIDATE style)
instead of DCHECKing.

[battre, 2011/05/25 11:31:45]

The EXTENSION_FUNCTION_VALIDATE style validation has taken place already. The
Extension API guarantees that only valid strings arrive here. If anything else
arrives, this is a bug and should DCHECK.

[Bernhard Bauer, 2011/05/25 17:48:35]

As in, the Javascript API? That can be circumvented though (in which case we
should kill the renderer). I don't think this case is any different from the
other EXTENSION_FUNCTION_VALIDATE below, which also check stuff which has been
checked renderer-side by the JSON validator.

[Matt Perry, 2011/05/25 18:40:42]

Agreed. EXTENSION_FUNCTION_VALIDATE exists because a renderer could be
compromised and send bad messages to the browser. You've only validated that
it's a string. You should also validate the enum value.

[battre, 2011/05/25 19:47:44]

Done.

+    return extension_prefs_scope::kRegular;
+  }
+}
+
 class PrefMapping {
  public:
   static PrefMapping* GetInstance() {
     return Singleton<PrefMapping>::get();
   }
 
   bool FindBrowserPrefForExtensionPref(const std::string& extension_pref,
                                        std::string* browser_pref,
                                        std::string* permission) {
     std::map<std::string, std::pair<std::string, std::string> >::iterator it =
@@ skipping 217 matching lines @@
 
 bool SetPreferenceFunction::RunImpl() {
   std::string pref_key;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &pref_key));
   DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &details));
 
   Value* value = NULL;
   EXTENSION_FUNCTION_VALIDATE(details->Get(kValue, &value));
 
-  bool incognito = false;
+  std::string scope = kRegular;
+  if (details->HasKey(kScope))
+    EXTENSION_FUNCTION_VALIDATE(details->GetString(kScope, &scope));
 
-  // TODO(battre): enable incognito preferences again.
-  // if (details->HasKey(kIncognito))
-  //   EXTENSION_FUNCTION_VALIDATE(details->GetBoolean(kIncognito, &incognito));
-
+  // TODO(battre): add kIncognitoSessionOnly
+  bool incognito = (scope == kIncognitoPersistent);
   if (incognito && !include_incognito()) {
     error_ = kIncognitoErrorMessage;
     return false;
   }
 
   std::string browser_pref;
   std::string permission;
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
           pref_key, &browser_pref, &permission));
@@ skipping 12 matching lines @@
   bool bad_message = false;
   Value* browserPrefValue =
       transformer->ExtensionToBrowserPref(value, &error, &bad_message);
   if (!browserPrefValue) {
     error_ = error;
     bad_message_ = bad_message;
     return false;
   }
   prefs->SetExtensionControlledPref(extension_id(),
                                     browser_pref,
-                                    incognito,
+                                    StringToScope(scope),
                                     browserPrefValue);
   return true;
 }
 
 ClearPreferenceFunction::~ClearPreferenceFunction() { }
 
 bool ClearPreferenceFunction::RunImpl() {
   std::string pref_key;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &pref_key));
   DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &details));
 
-  bool incognito = false;
-
-  // TODO(battre): enable incognito preferences again.
-  // if (details->HasKey(kIncognito))
-  //   EXTENSION_FUNCTION_VALIDATE(details->GetBoolean(kIncognito, &incognito));
+  std::string scope = kRegular;
+  if (details->HasKey(kScope))
+    EXTENSION_FUNCTION_VALIDATE(details->GetString(kScope, &scope));
 
   // We don't check incognito permissions here, as an extension should be always
   // allowed to clear its own settings.
 
   std::string browser_pref;
   std::string permission;
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
           pref_key, &browser_pref, &permission));
   if (!GetExtension()->HasApiPermission(permission)) {
     error_ = base::StringPrintf(kPermissionErrorMessage, pref_key.c_str());
     return false;
   }
   ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
-  prefs->RemoveExtensionControlledPref(extension_id(), browser_pref, incognito);
+  prefs->RemoveExtensionControlledPref(extension_id(), browser_pref,
+                                       StringToScope(scope));
   return true;
 }