<webview>: Refactor Permission API to chrome

chrome/renderer/resources/extensions/web_view.js

 // Copyright (c) 2012 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.
 
 // Shim that simulates a <webview> tag via Mutation Observers.
 //
 // The actual tag is implemented via the browser plugin. The internals of this
 // are hidden via Shadow DOM.
 
 var addTagWatcher = require('tagWatcher').addTagWatcher;
@@ skipping 29 matching lines @@
   },
   'exit': {
      evt: createEvent('webview.onExit'),
      fields: ['processId', 'reason']
   },
   'loadabort': {
     evt: createEvent('webview.onLoadAbort'),
     fields: ['url', 'isTopLevel', 'reason']
   },
   'loadcommit': {
-    customHandler: function(webview, event) {
+    customHandler: function(webview, event, webviewEvent) {
       webview.currentEntryIndex_ = event.currentEntryIndex;
       webview.entryCount_ = event.entryCount;
       webview.processId_ = event.processId;
       if (event.isTopLevel) {
         webview.browserPluginNode_.setAttribute('src', event.url);
       }
+      webview.webviewNode_.dispatchEvent(webviewEvent);
     },
     evt: createEvent('webview.onLoadCommit'),
     fields: ['url', 'isTopLevel']
   },
   'loadredirect': {
     evt: createEvent('webview.onLoadRedirect'),
     fields: ['isTopLevel', 'oldUrl', 'newUrl']
   },
   'loadstart': {
     evt: createEvent('webview.onLoadStart'),
     fields: ['url', 'isTopLevel']
   },
   'loadstop': {
     evt: createEvent('webview.onLoadStop'),
     fields: []
   },
+  'newwindow': {
+    cancelable: true,
+    customHandler: function(webview, event, webviewEvent) {
+      webview.setupExtNewWindowEvent_(event, webviewEvent);
+    },
+    evt: createEvent('webview.onNewWindow'),
+    fields: [
+      'initialHeight',
+      'initialWidth',
+      'targetUrl',
+      'windowOpenDisposition',
+      'name'
+    ]
+  },
+  'permissionrequest': {
+    cancelable: true,
+    customHandler: function(webview, event, webviewEvent) {
+      webview.setupExtPermissionEvent_(event, webviewEvent);
+    },
+    evt: createEvent('webview.onPermissionRequest'),
+    fields: [
+      'lastUnlockedBySelf',
+      'permission',
+      'requestMethod',
+      'url',
+      'userGesture'
+    ]
+  },
   'responsive': {
     evt: createEvent('webview.onResponsive'),
     fields: ['processId']
   },
   'unresponsive': {
     evt: createEvent('webview.onUnresponsive'),
     fields: ['processId']
   }
 };
 
@@ skipping 253 matching lines @@
     var newValue = this.browserPluginNode_.getAttribute(mutation.attributeName);
     if (newValue != oldValue) {
       this.webviewNode_.setAttribute(mutation.attributeName, newValue);
     }
   }
 };
 
 /**
  * @private
  */
+WebView.prototype.getWebviewExtEvents_ = function() {
+  var experimentalExtEvents = this.maybeGetWebviewExperimentalExtEvents_();
+  for (var eventName in experimentalExtEvents) {
+    WEB_VIEW_EXT_EVENTS[eventName] = experimentalExtEvents[eventName];
+  }
+  return WEB_VIEW_EXT_EVENTS;
+};
+
+/**
+ * @private
+ */
 WebView.prototype.setupWebviewNodeEvents_ = function() {
   var self = this;
   this.viewInstanceId_ = ++webViewInstanceIdCounter;
   var onInstanceIdAllocated = function(e) {
     var detail = e.detail ? JSON.parse(e.detail) : {};
     self.instanceId_ = detail.windowId;
     var params = {
       'api': 'webview',
       'instanceId': self.viewInstanceId_
     };
     self.browserPluginNode_['-internal-attach'](params);
 
-    for (var eventName in WEB_VIEW_EXT_EVENTS) {
-      self.setupExtEvent_(eventName, WEB_VIEW_EXT_EVENTS[eventName]);
+    var extEvents = self.getWebviewExtEvents_();
+    for (var eventName in extEvents) {
+      self.setupExtEvent_(eventName, extEvents[eventName]);
     }
   };
   this.browserPluginNode_.addEventListener('-internal-instanceid-allocated',
                                            onInstanceIdAllocated);
 
   for (var eventName in WEB_VIEW_EVENTS) {
     this.setupEvent_(eventName, WEB_VIEW_EVENTS[eventName]);
   }
-  this.setupNewWindowEvent_();
-  this.setupPermissionEvent_();
 };
 
 /**
  * @private
  */
 WebView.prototype.setupExtEvent_ = function(eventName, eventInfo) {
   var self = this;
   var webviewNode = this.webviewNode_;
   eventInfo.evt.addListener(function(event) {
-    var webviewEvent = new Event(eventName, {bubbles: true});
+    var details = {bubbles:true};
+    if (eventInfo.cancelable)
+      details.cancelable = true;
+    var webviewEvent = new Event(eventName, details);
     $Array.forEach(eventInfo.fields, function(field) {
-      webviewEvent[field] = event[field];
+      if (event[field] !== undefined) {
+        webviewEvent[field] = event[field];
+      }
     });
     if (eventInfo.customHandler) {
-      eventInfo.customHandler(self, event);
+      eventInfo.customHandler(self, event, webviewEvent);
+      return;
     }
     webviewNode.dispatchEvent(webviewEvent);
   }, {instanceId: self.instanceId_});
 };
 
 /**
  * @private
  */
 WebView.prototype.setupEvent_ = function(eventName, attribs) {
   var webviewNode = this.webviewNode_;
   var internalname = '-internal-' + eventName;
   this.browserPluginNode_.addEventListener(internalname, function(e) {
     var evt = new Event(eventName, { bubbles: true });
     var detail = e.detail ? JSON.parse(e.detail) : {};
     $Array.forEach(attribs, function(attribName) {
       evt[attribName] = detail[attribName];
     });
     webviewNode.dispatchEvent(evt);
   });
 };
 
 /**
  * @private
  */
-WebView.prototype.setupNewWindowEvent_ = function() {
+WebView.prototype.setupExtNewWindowEvent_ = function(event, webviewEvent) {
   var ERROR_MSG_NEWWINDOW_ACTION_ALREADY_TAKEN = '<webview>: ' +
       'An action has already been taken for this "newwindow" event.';
 
   var ERROR_MSG_NEWWINDOW_UNABLE_TO_ATTACH = '<webview>: ' +
       'Unable to attach the new window to the provided webview.';
 
   var ERROR_MSG_WEBVIEW_EXPECTED = '<webview> element expected.';
 
   var showWarningMessage = function() {
     var WARNING_MSG_NEWWINDOW_BLOCKED = '<webview>: A new window was blocked.';
     console.warn(WARNING_MSG_NEWWINDOW_BLOCKED);
   };
 
-  var NEW_WINDOW_EVENT_ATTRIBUTES = [
-    'initialHeight',
-    'initialWidth',
-    'targetUrl',
-    'windowOpenDisposition',
-    'name'
-  ];
+  var self = this;
+  var browserPluginNode = this.browserPluginNode_;
+  var webviewNode = this.webviewNode_;
 
-  var self = this;
-  var node = this.webviewNode_;
-  var browserPluginNode = this.browserPluginNode_;
+  var requestId = event.requestId;
+  var actionTaken = false;
 
   var onTrackedObjectGone = function(requestId, e) {
     var detail = e.detail ? JSON.parse(e.detail) : {};
     if (detail.id != requestId) {
       return;
     }
-    // If the request was pending then show a warning indiciating that a dialog
-    // was blocked.
-    if (browserPluginNode['-internal-setPermission'](requestId, false, '')) {
-      showWarningMessage();
-    }
-  };
 
-  browserPluginNode.addEventListener('-internal-newwindow', function(e) {
-    var evt = new Event('newwindow', { bubbles: true, cancelable: true });
-    var detail = e.detail ? JSON.parse(e.detail) : {};
-
-    $Array.forEach(NEW_WINDOW_EVENT_ATTRIBUTES, function(attribName) {
-      evt[attribName] = detail[attribName];
-    });
-    var requestId = detail.requestId;
-    var actionTaken = false;
-
-    var validateCall = function () {
-      if (actionTaken) {
-        throw new Error(ERROR_MSG_NEWWINDOW_ACTION_ALREADY_TAKEN);
-      }
-      actionTaken = true;
-    };
-
-    var window = {
-      attach: function(webview) {
-        validateCall();
-        if (!webview)
-          throw new Error(ERROR_MSG_WEBVIEW_EXPECTED);
-        // Attach happens asynchronously to give the tagWatcher an opportunity
-        // to pick up the new webview before attach operates on it, if it hasn't
-        // been attached to the DOM already.
-        // Note: Any subsequent errors cannot be exceptions because they happen
-        // asynchronously.
-        setTimeout(function() {
-          var attached =
-              browserPluginNode['-internal-attachWindowTo'](webview,
-                                                            detail.windowId);
-          if (!attached) {
-            console.error(ERROR_MSG_NEWWINDOW_UNABLE_TO_ATTACH);
-          }
-          // If the object being passed into attach is not a valid <webview>
-          // then we will fail and it will be treated as if the new window
-          // was rejected. The permission API plumbing is used here to clean
-          // up the state created for the new window if attaching fails.
-          browserPluginNode['-internal-setPermission'](requestId, attached, '');
-        }, 0);
-      },
-      discard: function() {
-        validateCall();
-        browserPluginNode['-internal-setPermission'](requestId, false, '');
-      }
-    };
-    evt.window = window;
-
-    var defaultPrevented = !node.dispatchEvent(evt);
+    // Avoid showing a warning message if the decision has already been made.
     if (actionTaken) {
       return;
     }
 
-    if (defaultPrevented) {
-      // Make browser plugin track lifetime of |window|.
-      var onTrackedObjectGoneWithRequestId =
-          $Function.bind(onTrackedObjectGone, self, requestId);
-      browserPluginNode.addEventListener('-internal-trackedobjectgone',
-          onTrackedObjectGoneWithRequestId);
-      browserPluginNode['-internal-trackObjectLifetime'](window, requestId);
-    } else {
-      actionTaken = true;
-      // The default action is to discard the window.
-      browserPluginNode['-internal-setPermission'](requestId, false, '');
-      showWarningMessage();
+    chrome.webview.setPermission(self.instanceId_, requestId, false, '');
+    showWarningMessage();
+  };
+
+
+  var validateCall = function () {
+    if (actionTaken) {
+      throw new Error(ERROR_MSG_NEWWINDOW_ACTION_ALREADY_TAKEN);
     }
+    actionTaken = true;
+  };
 
-  });
+  var window = {
+    attach: function(webview) {
+      validateCall();
+      if (!webview)
+        throw new Error(ERROR_MSG_WEBVIEW_EXPECTED);
+      // Attach happens asynchronously to give the tagWatcher an opportunity
+      // to pick up the new webview before attach operates on it, if it hasn't
+      // been attached to the DOM already.
+      // Note: Any subsequent errors cannot be exceptions because they happen
+      // asynchronously.
+      setTimeout(function() {
+        var attached =
+            browserPluginNode['-internal-attachWindowTo'](webview,
+                                                          event.windowId);
+        if (!attached) {
+          console.error(ERROR_MSG_NEWWINDOW_UNABLE_TO_ATTACH);
+        }
+        // If the object being passed into attach is not a valid <webview>
+        // then we will fail and it will be treated as if the new window
+        // was rejected. The permission API plumbing is used here to clean
+        // up the state created for the new window if attaching fails.
+        chrome.webview.setPermission(self.instanceId_, requestId, attached, '');
+      }, 0);
+    },
+    discard: function() {
+      validateCall();
+      chrome.webview.setPermission(self.instanceId_, requestId, false, '');
+    }
+  };
+  webviewEvent.window = window;
+
+  var defaultPrevented = !webviewNode.dispatchEvent(webviewEvent);
+  if (actionTaken) {
+    return;
+  }
+
+  if (defaultPrevented) {
+    // Make browser plugin track lifetime of |window|.
+    var onTrackedObjectGoneWithRequestId =
+        $Function.bind(onTrackedObjectGone, self, requestId);
+    browserPluginNode.addEventListener('-internal-trackedobjectgone',
+        onTrackedObjectGoneWithRequestId);
+    browserPluginNode['-internal-trackObjectLifetime'](window, requestId);
+  } else {
+    actionTaken = true;
+    // The default action is to discard the window.
+    chrome.webview.setPermission(self.instanceId_, requestId, false, '');
+    showWarningMessage();
+  }
 };
 
 /**
  * @private
  */
 WebView.prototype.setupExecuteCodeAPI_ = function() {
   var ERROR_MSG_CANNOT_INJECT_SCRIPT = '<webview>: ' +
       'Script cannot be injected into content until the page has loaded.';
 
   var self = this;
@@ skipping 11 matching lines @@
   }
   this.webviewNode_['insertCSS'] = function(var_args) {
     validateCall();
     var args = $Array.concat([self.browserPluginNode_.getGuestInstanceId()],
                              $Array.slice(arguments));
     $Function.apply(chrome.webview.insertCSS, null, args);
   }
 };
 
 /**
- * @param {!Object} detail The event details, originated from <object>.
  * @private
  */
-WebView.prototype.setupPermissionEvent_ = function() {
+WebView.prototype.getPermissionTypes_ = function() {
+  return ['media', 'geolocation', 'pointerLock', 'download'];
+};
+
+WebView.prototype.setupExtPermissionEvent_ = function(event, webviewEvent) {
   var ERROR_MSG_PERMISSION_ALREADY_DECIDED = '<webview>: ' +
       'Permission has already been decided for this "permissionrequest" event.';
 
   var showWarningMessage = function(permission) {
     var WARNING_MSG_PERMISSION_DENIED = '<webview>: ' +
         'The permission request for "%1" has been denied.';
     console.warn(WARNING_MSG_PERMISSION_DENIED.replace('%1', permission));
   };
 
-  var PERMISSION_TYPES = ['media', 'geolocation', 'pointerLock', 'download'];
-
-  var EXPOSED_PERMISSION_EVENT_ATTRIBS = [
-      'lastUnlockedBySelf',
-      'permission',
-      'requestMethod',
-      'url',
-      'userGesture'
-  ];
+  var PERMISSION_TYPES = this.getPermissionTypes_();
 
   var self = this;
-  var node = this.webviewNode_;
   var browserPluginNode = this.browserPluginNode_;
-  var internalevent = '-internal-permissionrequest';
+  var webviewNode = this.webviewNode_;
+
+  var requestId = event.requestId;
+  var decisionMade = false;
 
   var onTrackedObjectGone = function(requestId, permission, e) {
     var detail = e.detail ? JSON.parse(e.detail) : {};
-    if (detail.id != requestId)
-      return;
-    // If the request was pending then show a warning indiciating that the
-    // permission was denied.
-    if (browserPluginNode['-internal-setPermission'](requestId, false, '')) {
-      showWarningMessage(permission);
-    }
-  };
-
-  browserPluginNode.addEventListener(internalevent, function(e) {
-    var evt = new Event('permissionrequest', {bubbles: true, cancelable: true});
-    var detail = e.detail ? JSON.parse(e.detail) : {};
-    $Array.forEach(EXPOSED_PERMISSION_EVENT_ATTRIBS, function(attribName) {
-      if (detail[attribName] !== undefined)
-        evt[attribName] = detail[attribName];
-    });
-    var requestId = detail.requestId;
-
-    if (detail.requestId == undefined ||
-        PERMISSION_TYPES.indexOf(detail.permission) < 0) {
+    if (detail.id != requestId) {
       return;
     }
 
-    // TODO(lazyboy): Also fill in evt.details (see webview specs).
-    // http://crbug.com/141197.
-    var decisionMade = false;
-
-    var validateCall = function() {
-      if (decisionMade) {
-        throw new Error(ERROR_MSG_PERMISSION_ALREADY_DECIDED);
-      }
-      decisionMade = true;
-    };
-
-    // Construct the event.request object.
-    var request = {
-      allow: function() {
-        validateCall();
-        browserPluginNode['-internal-setPermission'](requestId, true, '');
-      },
-      deny: function() {
-        validateCall();
-        browserPluginNode['-internal-setPermission'](requestId, false, '');
-      }
-    };
-    evt.request = request;
-
-    var defaultPrevented = !node.dispatchEvent(evt);
+    // Avoid showing a warning message if the decision has already been made.
     if (decisionMade) {
       return;
     }
 
-    if (defaultPrevented) {
-      // Make browser plugin track lifetime of |request|.
-      var onTrackedObjectGoneWithRequestId =
-          $Function.bind(
-              onTrackedObjectGone, self, requestId, detail.permission);
-      browserPluginNode.addEventListener('-internal-trackedobjectgone',
-          onTrackedObjectGoneWithRequestId);
-      browserPluginNode['-internal-trackObjectLifetime'](request, requestId);
-    } else {
-      decisionMade = true;
-      browserPluginNode['-internal-setPermission'](requestId, false, '');
-      showWarningMessage(detail.permission);
+    chrome.webview.setPermission(self.instanceId_, requestId, false, '');
+    showWarningMessage(permission);
+  };
+
+  var validateCall = function() {
+    if (decisionMade) {
+      throw new Error(ERROR_MSG_PERMISSION_ALREADY_DECIDED);
     }
-  });
+    decisionMade = true;
+  };
+
+  // Construct the event.request object.
+  var request = {
+    allow: function() {
+      validateCall();
+      chrome.webview.setPermission(self.instanceId_, requestId, true, '');
+    },
+    deny: function() {
+      validateCall();
+      chrome.webview.setPermission(self.instanceId_, requestId, false, '');
+    }
+  };
+  webviewEvent.request = request;
+
+  var defaultPrevented = !webviewNode.dispatchEvent(webviewEvent);
+  if (decisionMade) {
+    return;
+  }
+
+  if (defaultPrevented) {
+    // Make browser plugin track lifetime of |request|.
+    var onTrackedObjectGoneWithRequestId =
+        $Function.bind(
+            onTrackedObjectGone, self, requestId, event.permission);
+    browserPluginNode.addEventListener('-internal-trackedobjectgone',
+        onTrackedObjectGoneWithRequestId);
+    browserPluginNode['-internal-trackObjectLifetime'](request, requestId);
+  } else {
+    decisionMade = true;
+    chrome.webview.setPermission(self.instanceId_, requestId, false, '');
+    showWarningMessage(event.permission);
+  }
 };
 
 /**
  * Implemented when the experimental API is available.
  * @private
  */
 WebView.prototype.maybeSetupExperimentalAPI_ = function() {};
 
+/**
+ * Implemented when the experimental API is available.
+ * @private
+ */
+WebView.prototype.maybeSetupExtDialogEvent_ = function() {};
+
+/**
+ * Implemented when the experimental API is available.
+ * @private
+ */
+WebView.prototype.maybeGetWebviewExperimentalExtEvents_ = function() {};
+
 exports.WebView = WebView;
+exports.CreateEvent = createEvent;