Extension API: Rename contentSettings.misc to .global and rename preferences under it.

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 40 matching lines @@
 
 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",
+  { "thirdPartyCookiesAllowed",
     prefs::kBlockThirdPartyCookies,
     Extension::kContentSettingsPermission
   },
-  { "enableReferrers",
+  { "referrersEnabled",
     prefs::kEnableReferrers,
     Extension::kContentSettingsPermission
   },
-  { "enableHyperlinkAuditing",
+  { "hyperlinkAuditingEnabled",
     prefs::kEnableHyperlinkAuditing,
     Extension::kContentSettingsPermission
   },
   { "proxy",
     prefs::kProxy,
     Extension::kProxyPermission
   },
 };
 
 class IdentityPrefTransformer : public PrefTransformerInterface {
  public:
-  IdentityPrefTransformer() { }
-  virtual ~IdentityPrefTransformer() { }
-
   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();
   }
 };
 
+class InvertBooleanTransformer : public PrefTransformerInterface {
+ public:
+  virtual Value* ExtensionToBrowserPref(const Value* extension_pref,
+                                        std::string* error,
+                                        bool* bad_message) {
+    return InvertBooleanValue(extension_pref);
+  }
+
+  virtual Value* BrowserToExtensionPref(const Value* browser_pref) {
+    return InvertBooleanValue(browser_pref);
+  }
+
+ private:
+  static Value* InvertBooleanValue(const Value* value) {

[jochen (gone - plz use gerrit), 2011/06/01 08:46:43]

why static and private member? either should be enough

[Bernhard Bauer, 2011/06/01 16:48:48]

Why not? :-) It's static because it doesn't use object state, and private
because it's only called from within the class.

+    bool bool_value = false;
+    bool result = value->GetAsBoolean(&bool_value);
+    DCHECK(result);
+    return Value::CreateBooleanValue(!bool_value);
+  }
+};
+
 // 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 =
@@ skipping 78 matching lines @@
                          kPrefMapping[i].permission);
       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());
   }
 
   ~PrefMapping() {
     STLDeleteContainerPairSecondPointers(transformers_.begin(),
                                          transformers_.end());
   }
 
   void RegisterPrefTransformer(const std::string& browser_pref,
                                PrefTransformerInterface* transformer) {
     DCHECK_EQ(0u, transformers_.count(browser_pref)) <<
@@ skipping 270 matching lines @@
       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;
 }