Support PNG and quality control in chrome.tabs.captureVisibleTab().

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 333 matching lines @@
       // 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;
 
           var apiFunction = {};
           apiFunction.definition = functionDef;
-          apiFunction.name = apiDef.namespace + "." + functionDef.name;;
+          apiFunction.name = apiDef.namespace + "." + functionDef.name;
           apiFunctions[apiFunction.name] = apiFunction;
 
           module[functionDef.name] = bind(apiFunction, function() {
-            chromeHidden.validate(arguments, this.definition.parameters);
+            var args = arguments;
+            if (this.updateArguments) {
+              // Functions whose signature has changed can define an
+              // |updateArguments| function to transform old argument lists
+              // into the new form, preserving compatibility.
+              // TODO(skerner): Once optional args can be omitted (crbug/29215),
+              // this mechanism will become unnecessary.  Consider removing it
+              // when crbug/29215 is fixed.
+              args = this.updateArguments.apply(this, args);
+            }
+            chromeHidden.validate(args, this.definition.parameters);
 
             var retval;
             if (this.handleRequest) {
-              retval = this.handleRequest.apply(this, arguments);
+              retval = this.handleRequest.apply(this, args);
             } else {
-              retval = sendRequest(this.name, arguments,
+              retval = sendRequest(this.name, args,
                                    this.definition.parameters,
                                    this.customCallback);
             }
 
             // Validate return value if defined - only in debug.
             if (chromeHidden.validateCallbacks &&
                 chromeHidden.validate &&
                 this.definition.returns) {
               chromeHidden.validate([retval], [this.definition.returns]);
             }
@@ skipping 23 matching lines @@
     });
 
     apiFunctions["tabs.connect"].handleRequest = function(tabId, connectInfo) {
       var name = "";
       if (connectInfo) {
         name = connectInfo.name || name;
       }
       var portId = OpenChannelToTab(
           tabId, chromeHidden.extensionId, name);
       return chromeHidden.Port.createPort(portId, name);
-    }
+    };
 
     apiFunctions["tabs.sendRequest"].handleRequest =
         function(tabId, request, responseCallback) {
       var port = chrome.tabs.connect(tabId,
                                      {name: chromeHidden.kRequestChannel});
       port.postMessage(request);
       port.onMessage.addListener(function(response) {
         if (responseCallback)
           responseCallback(response);
         port.disconnect();
       });
-    }
+    };
 
     apiFunctions["extension.getViews"].handleRequest = function(properties) {
       var windowId = -1;
       var type = "ALL";
       if (typeof(properties) != "undefined") {
         if (typeof(properties.type) != "undefined") {
           type = properties.type;
         }
         if (typeof(properties.windowId) != "undefined") {
           windowId = properties.windowId;
         }
       }
       return GetExtensionViews(windowId, type) || null;
-    }
+    };
 
     apiFunctions["extension.getBackgroundPage"].handleRequest = function() {
       return GetExtensionViews(-1, "BACKGROUND")[0] || null;
-    }
+    };
 
     apiFunctions["extension.getToolstrips"].handleRequest =
         function(windowId) {
       if (typeof(windowId) == "undefined")
         windowId = -1;
       return GetExtensionViews(windowId, "TOOLSTRIP");
-    }
+    };
 
     apiFunctions["extension.getExtensionTabs"].handleRequest =
         function(windowId) {
       if (typeof(windowId) == "undefined")
         windowId = -1;
       return GetExtensionViews(windowId, "TAB");
-    }
+    };
 
     apiFunctions["devtools.getTabEvents"].handleRequest = function(tabId) {
       var tabIdProxy = {};
       var functions = ["onPageEvent", "onTabClose"];
       functions.forEach(function(name) {
         // Event disambiguation is handled by name munging.  See
         // chrome/browser/extensions/extension_devtools_events.h for the C++
         // equivalent of this logic.
         tabIdProxy[name] = new chrome.Event("devtools." + tabId + "." + name);
       });
       return tabIdProxy;
-    }
+    };
 
     apiFunctions["experimental.popup.show"].handleRequest =
         function(url, showDetails, callback) {
       // Second argument is a transform from HTMLElement to Rect.
       var internalSchema = [
         this.definition.parameters[0],
         {
           type: "object",
           name: "showDetails",
           properties: {
@@ skipping 21 matching lines @@
       ];
       return sendRequest(this.name,
                          [url,
                           {
                             domAnchor: getAbsoluteRect(showDetails.relativeTo),
                             giveFocus: showDetails.giveFocus,
                             borderStyle: showDetails.borderStyle
                           },
                           callback],
                          internalSchema);
-    }
+    };
 
     apiFunctions["experimental.extension.getPopupView"].handleRequest =
         function() {
       return GetPopupView();
-    }
+    };
 
     apiFunctions["experimental.popup.getParentWindow"].handleRequest =
         function() {
       return GetPopupParentWindow();
-    }
+    };
 
     var canvas;
     function setIconCommon(details, name, parameters, actionType) {
       var EXTENSION_ACTION_ICON_SIZE = 19;
 
       if ("iconIndex" in details) {
         sendRequest(name, [details], parameters);
       } else if ("imageData" in details) {
         // Verify that this at least looks like an ImageData element.
         // Unfortunately, we cannot use instanceof because the ImageData
@@ skipping 67 matching lines @@
       }
     };
 
     apiFunctions["experimental.contextMenu.remove"].customCallback =
         function(name, request, response) {
       // Remove any onclick handler we had registered for this menu item.
       if (request.args.length > 0) {
         var menuItemId = request.args[0];
         delete chromeHidden.contextMenuHandlers[menuItemId];
       }
-    }
+    };
+
+    apiFunctions["tabs.captureVisibleTab"].updateArguments = function() {
+      // Old signature:
+      //    captureVisibleTab(int windowId, function callback);
+      // New signature:
+      //    captureVisibleTab(int windowId, object details, function callback);
+      //
+      // TODO(skerner): The next step to omitting optional arguments is the
+      // replacement of this code with code that matches arguments by type.
+      // Once this is working for captureVisibleTab() it can be enabled for
+      // the rest of the API. See crbug/29215 .
+      if (arguments.length == 2 && typeof(arguments[1]) == "function") {
+        // If the old signature is used, add a null details object.
+        newArgs = [arguments[0], null, arguments[1]];
+      } else {
+        newArgs = arguments;
+      }
+      return newArgs;
+    };
 
     if (chrome.test) {
       chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
     }
 
     setupBrowserActionEvent(extensionId);
     setupPageActionEvents(extensionId);
     setupToolstripEvents(GetRenderViewId());
     setupPopupEvents(GetRenderViewId());
     setupHiddenContextMenuEvent(extensionId);
   });
 
   if (!chrome.experimental)
     chrome.experimental = {};
 
   if (!chrome.experimental.accessibility)
     chrome.experimental.accessibility = {};
 })();