Implement experimental.contentSettings.misc.blockThirdPartyCookies.

chrome/renderer/resources/extension_process_bindings.js

 // Copyright (c) 2010 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.
 
 // This script contains privileged chrome extension related javascript APIs.
 // It is loaded by pages whose URL has the chrome-extension protocol.
 
 var chrome = chrome || {};
 (function() {
   native function GetExtensionAPIDefinition();
@@ skipping 21 matching lines @@
         return;
       }
       chrome.initExtension(extensionId, false);
     });
     return;
   }
 
   if (!chrome)
     chrome = {};
 
+  function forEach(dict, f) {
+    for (key in dict) {
+      if (dict.hasOwnProperty(key))
+        f(key, dict[key]);
+    }
+  }
+
   // Validate arguments.
-  chromeHidden.validationTypes = [];
+  chromeHidden.validationTypes = {};
   chromeHidden.validate = function(args, schemas) {
     if (args.length > schemas.length)
       throw new Error("Too many arguments.");
 
     for (var i = 0; i < schemas.length; i++) {
       if (i in args && args[i] !== null && args[i] !== undefined) {
         var validator = new chromeHidden.JSONSchemaValidator();
-        validator.addTypes(chromeHidden.validationTypes);
+        forEach(chromeHidden.validationTypes, function(id, type) {
+          validator.addTypes(type);
+        });
         validator.validate(args[i], schemas[i]);
         if (validator.errors.length == 0)
           continue;
 
         var message = "Invalid value for argument " + (i + 1) + ". ";
         for (var i = 0, err; err = validator.errors[i]; i++) {
           if (err.path) {
             message += "Property '" + err.path + "': ";
           }
           message += err.message;
@@ skipping 297 matching lines @@
       var callback = function(errorMessage) {
         if (errorMessage)
           chrome.experimental.tts.speakCompleted(requestId, errorMessage);
         else
           chrome.experimental.tts.speakCompleted(requestId);
       };
       chrome.Event.prototype.dispatch.apply(this, [text, options, callback]);
     };
   }
 
+  function setupPreferences() {

[Aaron Boodman, 2011/02/11 18:33:19]

You are now the second person (along with mpcomplete's webRequest API) to want
stateful objects on the client side of extension bindings.

We should come up with some generalized mechanism for implementing this; ideally
with the object's implementation in some other file than
extension_process_bindings.js.

[Aaron Boodman, 2011/02/14 02:54:02]

Did you see this comment?

+    // We declare the constructor so that a Preference shows up as such in the
+    // Javascript console, but build the Preference in a separate function so
+    // that an extension can't construct arbitrary Preference objects.
+    function Preference() {
+    };
+
+    var parameters = {};
+    chromeHidden.validationTypes['Preference'].functions.forEach(function(f) {
+      parameters[f.name] = f.parameters;
+    });
+
+    function buildPreference(prefKey, valueSchema) {
+      var pref = new Preference();
+      var getSchema = parameters.get;
+      var extendedGetSchema = getSchema.slice();
+      extendedGetSchema.unshift({'type': 'string'});
+      pref.get = function(details, callback) {
+        chromeHidden.validate([details, callback], getSchema);
+        return sendRequest('experimental.preferences.get',
+                           [prefKey, details, callback],
+                           extendedGetSchema);
+      };
+      var setSchema = parameters.set;
+      var extendedSetSchema = setSchema.slice();
+      extendedSetSchema.unshift({'type': 'string'});
+      extendedSetSchema[1].properties.value = valueSchema;
+      pref.set = function(details, callback) {
+        chromeHidden.validate([details, callback], setSchema);
+        return sendRequest('experimental.preferences.set',
+                           [prefKey, details, callback],
+                           extendedSetSchema);
+      };
+      return pref;
+    }
+
+    // TODO(bauerb): Automatically instantiate these preferences
+    // from chrome/common/extensions/api/extension_api.json.
+    chrome.experimental.contentSettings.misc.blockThirdPartyCookies =
+        buildPreference('blockThirdPartyCookies', {'type':'boolean'});
+  }
+
   chromeHidden.onLoad.addListener(function (extensionId) {
     if (!extensionId) {
       return;
     }
     chrome.initExtension(extensionId, false, IsIncognitoProcess());
 
     // |apiFunctions| is a hash of name -> object that stores the
     // name & definition of the apiFunction. Custom handling of api functions
     // is implemented by adding a "handleRequest" function to the object.
     var apiFunctions = {};
@@ skipping 10 matching lines @@
       var module = chrome;
       var namespaces = apiDef.namespace.split('.');
       for (var index = 0, name; name = namespaces[index]; index++) {
         module[name] = module[name] || {};
         module = module[name];
       }
 
       // Add types to global validationTypes
       if (apiDef.types) {
         apiDef.types.forEach(function(t) {
-          chromeHidden.validationTypes.push(t);
+          chromeHidden.validationTypes[t.id] = t;
         });
       }
 
       // Setup Functions.
       if (apiDef.functions) {
         apiDef.functions.forEach(function(functionDef) {
           // Module functions may have been defined earlier by hand. Don't
           // clobber them.
           if (module[functionDef.name])
             return;
@@ skipping 41 matching lines @@
 
           var eventName = apiDef.namespace + "." + eventDef.name;
           module[eventDef.name] = new chrome.Event(eventName,
               eventDef.parameters);
         });
       }
 
 
       // Parse any values defined for properties.
       if (apiDef.properties) {
-        for (var prop in apiDef.properties) {
-          if (!apiDef.properties.hasOwnProperty(prop))
-            continue;
-
-          var property = apiDef.properties[prop];
+        forEach(apiDef.properties, function(prop, property) {
           if (property.value) {
             var value = property.value;
             if (property.type === 'integer') {
               value = parseInt(value);
             } else if (property.type === 'boolean') {
               value = value === "true";
             } else if (property.type !== 'string') {
               throw "NOT IMPLEMENTED (extension_api.json error): Cannot " +
                   "parse values for type \"" + property.type + "\"";
             }
             module[prop] = value;
           }
-        }
+        });
       }
 
       // getTabContentses is retained for backwards compatibility
       // See http://crbug.com/21433
       chrome.extension.getTabContentses = chrome.extension.getExtensionTabs;
     });
 
     apiFunctions["tabs.connect"].handleRequest = function(tabId, connectInfo) {
       var name = "";
       if (connectInfo) {
@@ skipping 302 matching lines @@
     if (chrome.test) {
       chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
     }
 
     setupPageActionEvents(extensionId);
     setupToolstripEvents(GetRenderViewId());
     setupPopupEvents(GetRenderViewId());
     setupHiddenContextMenuEvent(extensionId);
     setupOmniboxEvents();
     setupTtsEvents();
+    setupPreferences();
   });
 
   if (!chrome.experimental)
     chrome.experimental = {};
 
   if (!chrome.experimental.accessibility)
     chrome.experimental.accessibility = {};
 
   if (!chrome.experimental.tts)
     chrome.experimental.tts = {};
 })();