extensions/renderer/resources/guest_view/web_view/web_view_action_requests.js

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This module implements helper objects for the dialog, newwindow, and
   6 // permissionrequest <webview> events.
   7
   8 var MessagingNatives = requireNative('messaging_natives');
   9 var WebViewConstants = require('webViewConstants').WebViewConstants;
  10 var WebViewInternal = require('webViewInternal').WebViewInternal;
  11
  12 var PERMISSION_TYPES = ['media',
  13                         'geolocation',
  14                         'pointerLock',
  15                         'download',
  16                         'loadplugin',
  17                         'filesystem',
  18                         'fullscreen'];
  19
  20 // -----------------------------------------------------------------------------
  21 // WebViewActionRequest object.
  22
  23 // Default partial implementation of a webview action request.
  24 function WebViewActionRequest(webViewImpl, event, webViewEvent, interfaceName) {
  25   this.webViewImpl = webViewImpl;
  26   this.event = event;
  27   this.webViewEvent = webViewEvent;
  28   this.interfaceName = interfaceName;
  29   this.guestInstanceId = this.webViewImpl.guest.getId();
  30   this.requestId = event.requestId;
  31   this.actionTaken = false;
  32 }
  33
  34 // Performs the default action for the request.
  35 WebViewActionRequest.prototype.defaultAction = function() {
  36   // Do nothing if the action has already been taken or the requester is
  37   // already gone (in which case its guestInstanceId will be stale).
  38   if (this.actionTaken ||
  39       this.guestInstanceId != this.webViewImpl.guest.getId()) {
  40     return;
  41   }
  42
  43   this.actionTaken = true;
  44   WebViewInternal.setPermission(this.guestInstanceId, this.requestId,
  45                                 'default', '', function(allowed) {
  46     if (allowed) {
  47       return;
  48     }
  49     this.showWarningMessage();
  50   }.bind(this));
  51 };
  52
  53 // Called to handle the action request's event.
  54 WebViewActionRequest.prototype.handleActionRequestEvent = function() {
  55   // Construct the interface object and attach it to |webViewEvent|.
  56   var request = this.getInterfaceObject();
  57   this.webViewEvent[this.interfaceName] = request;
  58
  59   var defaultPrevented = !this.webViewImpl.dispatchEvent(this.webViewEvent);
  60   // Set |webViewEvent| to null to break the circular reference to |request| so
  61   // that the garbage collector can eventually collect it.
  62   this.webViewEvent = null;
  63   if (this.actionTaken) {
  64     return;
  65   }
  66
  67   if (defaultPrevented) {
  68     // Track the lifetime of |request| with the garbage collector.
  69     MessagingNatives.BindToGC(request, this.defaultAction.bind(this));
  70   } else {
  71     this.defaultAction();
  72   }
  73 };
  74
  75 // Displays a warning message when an action request is blocked by default.
  76 WebViewActionRequest.prototype.showWarningMessage = function() {
  77   window.console.warn(this.WARNING_MSG_REQUEST_BLOCKED);
  78 };
  79
  80 // This function ensures that each action is taken at most once.
  81 WebViewActionRequest.prototype.validateCall = function() {
  82   if (this.actionTaken) {
  83     throw new Error(this.ERROR_MSG_ACTION_ALREADY_TAKEN);
  84   }
  85   this.actionTaken = true;
  86 };
  87
  88 // The following are implemented by the specific action request.
  89
  90 // Returns the interface object for this action request.
  91 WebViewActionRequest.prototype.getInterfaceObject = undefined;
  92
  93 // Error/warning messages.
  94 WebViewActionRequest.prototype.ERROR_MSG_ACTION_ALREADY_TAKEN = undefined;
  95 WebViewActionRequest.prototype.WARNING_MSG_REQUEST_BLOCKED = undefined;
  96
  97 // -----------------------------------------------------------------------------
  98 // Dialog object.
  99
 100 // Represents a dialog box request (e.g. alert()).
 101 function Dialog(webViewImpl, event, webViewEvent) {
 102   WebViewActionRequest.call(this, webViewImpl, event, webViewEvent, 'dialog');
 103
 104   this.handleActionRequestEvent();
 105 }
 106
 107 Dialog.prototype.__proto__ = WebViewActionRequest.prototype;
 108
 109 Dialog.prototype.getInterfaceObject = function() {
 110   return {
 111     ok: function(user_input) {
 112       this.validateCall();
 113       user_input = user_input || '';
 114       WebViewInternal.setPermission(
 115           this.guestInstanceId, this.requestId, 'allow', user_input);
 116     }.bind(this),
 117     cancel: function() {
 118       this.validateCall();
 119       WebViewInternal.setPermission(
 120           this.guestInstanceId, this.requestId, 'deny');
 121     }.bind(this)
 122   };
 123 };
 124
 125 Dialog.prototype.showWarningMessage = function() {
 126   var VOWELS = ['a', 'e', 'i', 'o', 'u'];
 127   var dialogType = this.event.messageType;
 128   var article = (VOWELS.indexOf(dialogType.charAt(0)) >= 0) ? 'An' : 'A';
 129   this.WARNING_MSG_REQUEST_BLOCKED = this.WARNING_MSG_REQUEST_BLOCKED.
 130       replace('%1', article).replace('%2', dialogType);
 131   window.console.warn(this.WARNING_MSG_REQUEST_BLOCKED);
 132 };
 133
 134 Dialog.prototype.ERROR_MSG_ACTION_ALREADY_TAKEN =
 135     WebViewConstants.ERROR_MSG_DIALOG_ACTION_ALREADY_TAKEN;
 136 Dialog.prototype.WARNING_MSG_REQUEST_BLOCKED =
 137     WebViewConstants.WARNING_MSG_DIALOG_REQUEST_BLOCKED;
 138
 139 // -----------------------------------------------------------------------------
 140 // NewWindow object.
 141
 142 // Represents a new window request.
 143 function NewWindow(webViewImpl, event, webViewEvent) {
 144   WebViewActionRequest.call(this, webViewImpl, event, webViewEvent, 'window');
 145
 146   this.handleActionRequestEvent();
 147 }
 148
 149 NewWindow.prototype.__proto__ = WebViewActionRequest.prototype;
 150
 151 NewWindow.prototype.getInterfaceObject = function() {
 152   return {
 153     attach: function(webview) {
 154       this.validateCall();
 155       if (!webview || !webview.tagName || webview.tagName != 'WEBVIEW') {
 156         throw new Error(ERROR_MSG_WEBVIEW_EXPECTED);
 157       }
 158
 159       var webViewImpl = privates(webview).internal;
 160       // Update the partition.
 161       if (this.event.partition) {
 162         webViewImpl.onAttach(this.event.partition);
 163       }
 164
 165       var attached = webViewImpl.attachWindow(this.event.windowId);
 166       if (!attached) {
 167         window.console.error(ERROR_MSG_NEWWINDOW_UNABLE_TO_ATTACH);
 168       }
 169
 170       if (this.guestInstanceId != this.webViewImpl.guest.getId()) {
 171         // If the opener is already gone, then its guestInstanceId will be
 172         // stale.
 173         return;
 174       }
 175
 176       // If the object being passed into attach is not a valid <webview>
 177       // then we will fail and it will be treated as if the new window
 178       // was rejected. The permission API plumbing is used here to clean
 179       // up the state created for the new window if attaching fails.
 180       WebViewInternal.setPermission(this.guestInstanceId, this.requestId,
 181                                     attached ? 'allow' : 'deny');
 182     }.bind(this),
 183     discard: function() {
 184       this.validateCall();
 185       if (!this.guestInstanceId) {
 186         // If the opener is already gone, then we won't have its
 187         // guestInstanceId.
 188         return;
 189       }
 190       WebViewInternal.setPermission(
 191           this.guestInstanceId, this.requestId, 'deny');
 192     }.bind(this)
 193   };
 194 };
 195
 196 NewWindow.prototype.ERROR_MSG_ACTION_ALREADY_TAKEN =
 197     WebViewConstants.ERROR_MSG_NEWWINDOW_ACTION_ALREADY_TAKEN;
 198 NewWindow.prototype.WARNING_MSG_REQUEST_BLOCKED =
 199     WebViewConstants.WARNING_MSG_NEWWINDOW_REQUEST_BLOCKED;
 200
 201 // -----------------------------------------------------------------------------
 202 // PermissionRequest object.
 203
 204 // Represents a permission request (e.g. to access the filesystem).
 205 function PermissionRequest(webViewImpl, event, webViewEvent) {
 206   WebViewActionRequest.call(this, webViewImpl, event, webViewEvent, 'request');
 207
 208   if (!this.validPermissionCheck()) {
 209     return;
 210   }
 211
 212   this.handleActionRequestEvent();
 213 }
 214
 215 PermissionRequest.prototype.__proto__ = WebViewActionRequest.prototype;
 216
 217 PermissionRequest.prototype.getInterfaceObject = function() {
 218   return {
 219     allow: function() {
 220       this.validateCall();
 221       WebViewInternal.setPermission(
 222           this.guestInstanceId, this.requestId, 'allow');
 223     }.bind(this),
 224     deny: function() {
 225       this.validateCall();
 226       WebViewInternal.setPermission(
 227           this.guestInstanceId, this.requestId, 'deny');
 228     }.bind(this)
 229   };
 230 };
 231
 232 PermissionRequest.prototype.showWarningMessage = function() {
 233   window.console.warn(
 234       this.WARNING_MSG_REQUEST_BLOCKED.replace('%1', this.event.permission));
 235 };
 236
 237 // Checks that the requested permission is valid. Returns true if valid.
 238 PermissionRequest.prototype.validPermissionCheck = function() {
 239   if (PERMISSION_TYPES.indexOf(this.event.permission) < 0) {
 240     // The permission type is not allowed. Trigger the default response.
 241     this.defaultAction();
 242     return false;
 243   }
 244   return true;
 245 };
 246
 247 PermissionRequest.prototype.ERROR_MSG_ACTION_ALREADY_TAKEN =
 248     WebViewConstants.ERROR_MSG_PERMISSION_ACTION_ALREADY_TAKEN;
 249 PermissionRequest.prototype.WARNING_MSG_REQUEST_BLOCKED =
 250     WebViewConstants.WARNING_MSG_PERMISSION_REQUEST_BLOCKED;
 251
 252 // -----------------------------------------------------------------------------
 253
 254 // FullscreenPermissionRequest object.
 255
 256 // Represents a fullscreen permission request.
 257 function FullscreenPermissionRequest(webViewImpl, event, webViewEvent) {
 258   PermissionRequest.call(this, webViewImpl, event, webViewEvent);
 259 }
 260
 261 FullscreenPermissionRequest.prototype.__proto__ = PermissionRequest.prototype;
 262
 263 FullscreenPermissionRequest.prototype.getInterfaceObject = function() {
 264   return {
 265     allow: function() {
 266       this.validateCall();
 267       WebViewInternal.setPermission(
 268           this.guestInstanceId, this.requestId, 'allow');
 269       // Now make the <webview> element go fullscreen.
 270       this.webViewImpl.makeElementFullscreen();
 271     }.bind(this),
 272     deny: function() {
 273       this.validateCall();
 274       WebViewInternal.setPermission(
 275           this.guestInstanceId, this.requestId, 'deny');
 276     }.bind(this)
 277   };
 278 };
 279
 280 var WebViewActionRequests = {
 281   WebViewActionRequest: WebViewActionRequest,
 282   Dialog: Dialog,
 283   NewWindow: NewWindow,
 284   PermissionRequest: PermissionRequest,
 285   FullscreenPermissionRequest: FullscreenPermissionRequest
 286 };
 287
 288 // Exports.
 289 exports.WebViewActionRequests = WebViewActionRequests;