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 20 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 348 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]);
     };
   }
 
+  var customInitializers = {};
+
+  function setupPreferences() {
+    var parameters = {};
+    chromeHidden.validationTypes['Preference'].functions.forEach(function(f) {
+      parameters[f.name] = f.parameters;
+    });
+
+    customInitializers['Preference'] = function(prefKey, valueSchema) {
+      var getSchema = parameters.get;
+      var extendedGetSchema = getSchema.slice();

[Aaron Boodman, 2011/02/23 01:17:26]

Can you find a way to generalize this such that everyone who uses this pattern,
doesn't have to repeat these two lines?

[Bernhard Bauer, 2011/02/23 17:33:27]

Done. I pulled out a function |extendSchema|.

+      extendedGetSchema.unshift({'type': 'string'});
+      this.get = function(details, callback) {
+        chromeHidden.validate([details, callback], getSchema);
+        return sendRequest('experimental.preferences.get',
+                           [prefKey, details, callback],
+                           extendedGetSchema);
+      };
+      var setSchema = parameters.set.slice();
+      setSchema[0].properties.value = valueSchema;
+      var extendedSetSchema = setSchema.slice();
+      extendedSetSchema.unshift({'type': 'string'});
+      this.set = function(details, callback) {
+        chromeHidden.validate([details, callback], setSchema);
+        return sendRequest('experimental.preferences.set',
+                           [prefKey, details, callback],
+                           extendedSetSchema);
+      };
+    };
+  }
+
   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 = {};
 
+    var customObjects = {};
+
     // Read api definitions and setup api functions in the chrome namespace.
     // TODO(rafaelw): Consider defining a json schema for an api definition
     //   and validating either here, in a unit_test or both.
     // TODO(rafaelw): Handle synchronous functions.
     // TOOD(rafaelw): Consider providing some convenient override points
     //   for api functions that wish to insert themselves into the call.
     var apiDefinitions = chromeHidden.JSON.parse(GetExtensionAPIDefinition());
 
     apiDefinitions.forEach(function(apiDef) {
       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;
+          if (t.type == 'object' && t.customBindings) {

[Aaron Boodman, 2011/02/23 01:17:26]

The customBindings flag seems unnecessary since you can just look in the lookup
of customBindings.

[Bernhard Bauer, 2011/02/23 17:33:27]

Done.

+            function CustomBindingsObject(args) {

[Aaron Boodman, 2011/02/23 01:17:26]

This object doesn't seem to do a lot right now. I realize it was partially based
on my ideas, but without the lazy-loading of the implementation, I don't see the
value.

How about just making there be a lookup of customBindings, eg:

var customBindings = {};

People can come along and register themselves as the implementation for a
certain type:

customBindings['Preference'] = function(schema) {
  this.schema_ = schema;
};

customBindings['Preference'].prototype.get = function() {
  chromeHidden.validate(arguments, this.schema.functions.get);
  sendRequest(...);
};

Then in the property parsing code, you create one of these directly.

[Bernhard Bauer, 2011/02/23 17:33:27]

Done. I'm still using CustomBindingsObject as a base class that mangles the
method schemas into a dictionary. If you prefer, I could do that when parsing
the types below and directly set the schemas on the customBindings entry.

+              this.initArgs = args;
+            }
+            customObjects[t.id] = CustomBindingsObject;
+
+            t.functions.forEach(function(f) {
+              CustomBindingsObject.prototype[f.name] = function() {
+                customInitializers[t.customBindings].apply(this, this.initArgs);
+                delete this.initArgs;
+                this[f.name].apply(this, arguments);
+              };
+            });
+          }
         });
       }
 
       // 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 47 matching lines @@
           } else {
             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["$ref"]) {
+              var proto = customObjects[property["$ref"]];

[Aaron Boodman, 2011/02/23 01:17:26]

naming nit: I think this should really be 'ctor' or 'constructor' if that isn't
a reserved javascript word.

[Bernhard Bauer, 2011/02/23 17:33:27]

Done. I think constructor only has a special meaning as a property name.

+              value = new proto(value);
             } 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 236 matching lines @@
 
     if (chrome.test) {
       chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
     }
 
     setupPageActionEvents(extensionId);
     setupToolstripEvents(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 = {};
 })();