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 22 matching lines @@
       }
       chrome.initExtension(extensionId, false);
     });
     return;
   }
 
   if (!chrome)
     chrome = {};
 
   // 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 forEach(dict, f) {
+    for (key in dict) {
+      if (dict.hasOwnProperty(key))
+        f(key, dict[key]);
+    }
+  }
+
+  function setupPreferences() {
+    // 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 = {};
 })();