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.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);
@@ skipping 234 matching lines @@
 
   chrome.WebRequestEvent.prototype.findListener_ = function(cb) {
     for (var i = 0; i < this.subEvents_.length; i++) {
       if (this.subEvents_[i].findListener_(cb) > -1)
         return i;
     }
 
     return -1;
   };
 
+  function CustomBindingsObject() {
+  }
+  CustomBindingsObject.prototype.setSchema = function(schema) {
+    // The functions in the schema are in list form, so we move them into a
+    // dictionary for easier access.
+    var self = this;
+    self.parameters = {};
+    schema.functions.forEach(function(f) {
+      self.parameters[f.name] = f.parameters;
+    });
+  };
+
+  function extendSchema(schema) {
+    var extendedSchema = schema.slice();
+    extendedSchema.unshift({'type': 'string'});
+    return extendedSchema;
+  }
+
+  var customBindings = {};
+
+  function setupPreferences() {
+    customBindings['Preference'] = function(prefKey, valueSchema) {
+      var getSchema = this.parameters.get;
+      var extendedGetSchema = extendSchema(getSchema);
+      this.get = function(details, callback) {
+        chromeHidden.validate([details, callback], getSchema);
+        return sendRequest('experimental.preferences.get',
+                           [prefKey, details, callback],
+                           extendedGetSchema);
+      };
+      var setSchema = this.parameters.set.slice();
+      setSchema[0].properties.value = valueSchema;
+      var extendedSetSchema = extendSchema(setSchema);
+      this.set = function(details, callback) {
+        chromeHidden.validate([details, callback], setSchema);
+        return sendRequest('experimental.preferences.set',
+                           [prefKey, details, callback],
+                           extendedSetSchema);
+      };
+    };
+    customBindings['Preference'].prototype = new CustomBindingsObject();
+  }
+
   // Page action events send (pageActionId, {tabId, tabUrl}).
   function setupPageActionEvents(extensionId) {
     var pageActions = GetCurrentPageActions(extensionId);
 
     var oldStyleEventName = "pageActions";
     // TODO(EXTENSIONS_DEPRECATED): only one page action
     for (var i = 0; i < pageActions.length; ++i) {
       // Setup events for each extension_id/page_action_id string we find.
       chrome.pageActions[pageActions[i]] = new chrome.Event(oldStyleEventName);
     }
@@ skipping 110 matching lines @@
       chrome.Event.prototype.dispatch.apply(this, [text, options, callback]);
     };
   }
 
   chromeHidden.onLoad.addListener(function (extensionId) {
     if (!extensionId) {
       return;
     }
     chrome.initExtension(extensionId, false, IsIncognitoProcess());
 
+    // Setup the Preference class so we can use it to construct Preference
+    // objects from the API definition.
+    setupPreferences();
+
     // |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 = {};
 
     // 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);
+          if (t.type == 'object' && customBindings[t.id]) {
+            customBindings[t.id].prototype.setSchema(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 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 constructor = customBindings[property["$ref"]];
+              var args = value;
+              // For an object property, |value| is an array of constructor
+              // arguments, but we want to pass the arguments directly
+              // (i.e. not as an array), so we have to fake calling |new| on the
+              // constructor.
+              value = { __proto__: constructor.prototype };
+              constructor.apply(value, args);
             } 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 247 matching lines @@
 
   if (!chrome.experimental)
     chrome.experimental = {};
 
   if (!chrome.experimental.accessibility)
     chrome.experimental.accessibility = {};
 
   if (!chrome.experimental.tts)
     chrome.experimental.tts = {};
 })();