Enable incognito_session_only 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"
@@ skipping 22 matching lines @@
 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 kIncognitoSessionOnly[] = "incognito_session_only";
 const char kValue[] = "value";
 
 const char kOnPrefChangeFormat[] =
     "preferences.%s.onChange";
 
 const char kIncognitoErrorMessage[] =
     "You do not have permission to access incognito preferences.";
 
+const char kIncognitoSessionOnlyErrorMessage[] =
+    "You cannot set a preference with scope 'incognito_session_only' when no "
+    "incognito window is open.";
+
 const char kPermissionErrorMessage[] =
     "You do not have permission to access the preference '%s'. "
     "Be sure to declare in your manifest what permissions you need.";
 
 PrefMappingEntry kPrefMapping[] = {
   { "blockThirdPartyCookies",
     prefs::kBlockThirdPartyCookies,
     Extension::kContentSettingsPermission
   },
   { "enableReferrers",
@@ skipping 50 matching lines @@
     return kControllableByThisExtension;
 
   return kControlledByOtherExtensions;
 }
 
 bool StringToScope(const std::string& s, extension_prefs_scope::Scope* scope) {
   if (s == kRegular)
     *scope = extension_prefs_scope::kRegular;
   else if (s == kIncognitoPersistent)
     *scope = extension_prefs_scope::kIncognitoPersistent;
+  else if (s == kIncognitoSessionOnly)
+    *scope = extension_prefs_scope::kIncognitoSessionOnly;
   else
     return false;
   return true;
 }
 
 class PrefMapping {
  public:
   static PrefMapping* GetInstance() {
     return Singleton<PrefMapping>::get();
   }
@@ skipping 229 matching lines @@
   Value* value = NULL;
   EXTENSION_FUNCTION_VALIDATE(details->Get(kValue, &value));
 
   std::string scope_str = kRegular;
   if (details->HasKey(kScope))
     EXTENSION_FUNCTION_VALIDATE(details->GetString(kScope, &scope_str));
 
   extension_prefs_scope::Scope scope;
   EXTENSION_FUNCTION_VALIDATE(StringToScope(scope_str, &scope));
 
-  // TODO(battre): add kIncognitoSessionOnly
-  bool incognito = (scope == extension_prefs_scope::kIncognitoPersistent);
+  bool incognito = (scope == extension_prefs_scope::kIncognitoPersistent ||
+                    scope == extension_prefs_scope::kIncognitoSessionOnly);
   if (incognito) {
     // Regular profiles can't access incognito unless include_incognito is true.
     if (!profile()->IsOffTheRecord() && !include_incognito()) {
       error_ = kIncognitoErrorMessage;
       return false;
     }
   } else {
     // Incognito profiles can't access regular mode ever, they only exist in
     // split mode.
     if (profile()->IsOffTheRecord()) {
       error_ = "Can't modify regular settings from an incognito context.";
       return false;
     }
   }
 
+  if (scope == extension_prefs_scope::kIncognitoSessionOnly &&
+      !profile_->HasOffTheRecordProfile()) {
+    error_ = kIncognitoSessionOnlyErrorMessage;
+    return false;
+  }
+
   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();
@@ skipping 27 matching lines @@
   DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &details));
 
   std::string scope_str = kRegular;
   if (details->HasKey(kScope))
     EXTENSION_FUNCTION_VALIDATE(details->GetString(kScope, &scope_str));
 
   extension_prefs_scope::Scope scope;
   EXTENSION_FUNCTION_VALIDATE(StringToScope(scope_str, &scope));
 
-  // TODO(battre): add kIncognitoSessionOnly
-  bool incognito = (scope == extension_prefs_scope::kIncognitoPersistent);
+  bool incognito = (scope == extension_prefs_scope::kIncognitoPersistent ||
+                    scope == extension_prefs_scope::kIncognitoSessionOnly);
   if (incognito) {
     // We don't check incognito permissions here, as an extension should be
     // always allowed to clear its own settings.
   } else {
     // Incognito profiles can't access regular mode ever, they only exist in
     // split mode.
     if (profile()->IsOffTheRecord()) {
       error_ = "Can't modify regular settings from an incognito context.";
       return false;
     }
   }
 
   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, scope);
   return true;
 }