Webview attributes overhaul.

extensions/renderer/resources/guest_view/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.
 
 // This module implements WebView (<webview>) as a custom element that wraps a
 // BrowserPlugin object element. The object element is hidden within
 // the shadow DOM of the WebView element.
 
 var DocumentNatives = requireNative('document_natives');
 var GuestViewInternal =
     require('binding').Binding.create('guestViewInternal').generate();
 var guestViewInternalNatives = requireNative('guest_view_internal');
 var IdGenerator = requireNative('id_generator');
 var WebViewConstants = require('webViewConstants').WebViewConstants;
 var WebViewEvents = require('webViewEvents').WebViewEvents;
 var WebViewInternal = require('webViewInternal').WebViewInternal;
 
+// Attributes.
+var BROWSER_PLUGIN_ATTRIBUTE_INTERNALINSTANCEID = 'internalinstanceid'

[Fady Samuel, 2014/10/22 21:48:26]

Move to WebViewConstants?

[paulmeyer, 2014/10/23 21:39:56]

Done.

 var AUTO_SIZE_ATTRIBUTES = [
   WebViewConstants.ATTRIBUTE_AUTOSIZE,
   WebViewConstants.ATTRIBUTE_MAXHEIGHT,
   WebViewConstants.ATTRIBUTE_MAXWIDTH,
   WebViewConstants.ATTRIBUTE_MINHEIGHT,
   WebViewConstants.ATTRIBUTE_MINWIDTH
 ];
 
-// Represents the state of the storage partition.
-function Partition() {
-  this.validPartitionId = true;
-  this.persistStorage = false;
-  this.storagePartitionId = '';
-}
-
-Partition.prototype.toAttribute = function() {
-  if (!this.validPartitionId) {
-    return '';
-  }
-  return (this.persistStorage ? 'persist:' : '') + this.storagePartitionId;
-};
-
-Partition.prototype.fromAttribute = function(value, hasNavigated) {
-  var result = {};
-  if (hasNavigated) {
-    result.error = WebViewConstants.ERROR_MSG_ALREADY_NAVIGATED;
-    return result;
-  }
-  if (!value) {
-    value = '';
-  }
-
-  var LEN = 'persist:'.length;
-  if (value.substr(0, LEN) == 'persist:') {
-    value = value.substr(LEN);
-    if (!value) {
-      this.validPartitionId = false;
-      result.error = WebViewConstants.ERROR_MSG_INVALID_PARTITION_ATTRIBUTE;
-      return result;
-    }
-    this.persistStorage = true;
-  } else {
-    this.persistStorage = false;
-  }
-
-  this.storagePartitionId = value;
-  return result;
-};
-
 // Represents the internal state of the WebView node.
 function WebView(webviewNode) {
   privates(webviewNode).internal = this;
   this.webviewNode = webviewNode;
   this.attached = false;
   this.pendingGuestCreation = false;
   this.elementAttached = false;
 
   this.beforeFirstNavigation = true;
   this.contentWindow = null;
   this.validPartitionId = true;
   // Used to save some state upon deferred attachment.
   // If <object> bindings is not available, we defer attachment.
   // This state contains whether or not the attachment request was for
   // newwindow.
   this.deferredAttachState = null;
 
   // on* Event handlers.
   this.on = {};
 
   this.browserPluginNode = this.createBrowserPluginNode();
   var shadowRoot = this.webviewNode.createShadowRoot();
-  this.partition = new Partition();
-
+  this.setupWebViewAttributes();
   this.setupWebViewSrcAttributeMutationObserver();
   this.setupFocusPropagation();
   this.setupWebviewNodeProperties();
 
   this.viewInstanceId = IdGenerator.GetNextId();
 
   new WebViewEvents(this, this.viewInstanceId);
 
   shadowRoot.appendChild(this.browserPluginNode);
 }
@@ skipping 16 matching lines @@
   // already picked up a partition ID. Thus, we need to reset the initialization
   // state. However, it may be the case that beforeFirstNavigation is false BUT
   // guestInstanceId has yet to be initialized. This means that we have not
   // heard back from createGuest yet. We will not reset the flag in this case so
   // that we don't end up allocating a second guest.
   if (this.guestInstanceId) {
     GuestViewInternal.destroyGuest(this.guestInstanceId);
     this.guestInstanceId = undefined;
     this.beforeFirstNavigation = true;
     this.validPartitionId = true;
-    this.partition.validPartitionId = true;
+    this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].validPartitionId =
+        true;
     this.contentWindow = null;
   }
   this.internalInstanceId = 0;
 };
 
 // Sets the <webview>.request property.
 WebView.prototype.setRequestPropertyOnWebViewNode = function(request) {
   Object.defineProperty(
       this.webviewNode,
       'request',
@@ skipping 24 matching lines @@
 
 // Validation helper function for executeScript() and insertCSS().
 WebView.prototype.validateExecuteCodeCall  = function() {
   if (!this.guestInstanceId) {
     throw new Error(WebViewConstants.ERROR_MSG_CANNOT_INJECT_SCRIPT);
   }
 };
 
 WebView.prototype.setupAutoSizeProperties = function() {
   $Array.forEach(AUTO_SIZE_ATTRIBUTES, function(attributeName) {
-    this[attributeName] = this.webviewNode.getAttribute(attributeName);
+    this.attributes[attributeName].setValue(
+        this.webviewNode.getAttribute(attributeName));
     Object.defineProperty(this.webviewNode, attributeName, {
       get: function() {
-        return this[attributeName];
+        return this.attributes[attributeName];
       }.bind(this),
       set: function(value) {
         this.webviewNode.setAttribute(attributeName, value);
       }.bind(this),
       enumerable: true
     });
   }.bind(this), this);
 };
 
 WebView.prototype.setupWebviewNodeProperties = function() {
@@ skipping 19 matching lines @@
       if (this.contentWindow) {
         return this.contentWindow;
       }
       window.console.error(
           WebViewConstants.ERROR_MSG_CONTENTWINDOW_NOT_AVAILABLE);
     }.bind(this),
     // No setter.
     enumerable: true
   });
 
-  Object.defineProperty(this.webviewNode, 'name', {
+  Object.defineProperty(this.webviewNode, WebViewConstants.ATTRIBUTE_NAME, {
     get: function() {
-      return this.name;
+      return this.attributes[WebViewConstants.ATTRIBUTE_NAME].getValue();
     }.bind(this),
     set: function(value) {
-      this.webviewNode.setAttribute('name', value);
+      this.webviewNode.setAttribute(WebViewConstants.ATTRIBUTE_NAME, value);
     }.bind(this),
     enumerable: true
   });
 
-  Object.defineProperty(this.webviewNode, 'partition', {
+  Object.defineProperty(this.webviewNode,
+                        WebViewConstants.ATTRIBUTE_PARTITION, {
     get: function() {
-      return this.partition.toAttribute();
+      return this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].getValue();
     }.bind(this),
     set: function(value) {
-      var result = this.partition.fromAttribute(value, this.hasNavigated());
+      var result = this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].
+          setValue(value);
       if (result.error) {
         throw result.error;
       }
-      this.webviewNode.setAttribute('partition', value);
+      this.webviewNode.setAttribute(WebViewConstants.ATTRIBUTE_PARTITION,
+                                    value);
     }.bind(this),
     enumerable: true
   });
 
-  this.src = this.webviewNode.getAttribute('src');
-  Object.defineProperty(this.webviewNode, 'src', {
+  this.attributes[WebViewConstants.ATTRIBUTE_SRC].setValue(
+      this.webviewNode.getAttribute(WebViewConstants.ATTRIBUTE_SRC));
+  Object.defineProperty(this.webviewNode, WebViewConstants.ATTRIBUTE_SRC, {
     get: function() {
-      return this.src;
+      return this.attributes[WebViewConstants.ATTRIBUTE_SRC].getValue();
     }.bind(this),
     set: function(value) {
-      this.webviewNode.setAttribute('src', value);
+      this.webviewNode.setAttribute(WebViewConstants.ATTRIBUTE_SRC, value);
     }.bind(this),
-    // No setter.
     enumerable: true
   });
 };
 
 // The purpose of this mutation observer is to catch assignment to the src
 // attribute without any changes to its value. This is useful in the case
 // where the webview guest has crashed and navigating to the same address
 // spawns off a new process.
 WebView.prototype.setupWebViewSrcAttributeMutationObserver =
     function() {
   this.srcAndPartitionObserver = new MutationObserver(function(mutations) {
     $Array.forEach(mutations, function(mutation) {
       var oldValue = mutation.oldValue;
       var newValue = this.webviewNode.getAttribute(mutation.attributeName);
       if (oldValue != newValue) {
         return;
       }
       this.handleWebviewAttributeMutation(
           mutation.attributeName, oldValue, newValue);
     }.bind(this));
   }.bind(this));
   var params = {
     attributes: true,
     attributeOldValue: true,
-    attributeFilter: ['src', 'partition']
+    attributeFilter: [WebViewConstants.ATTRIBUTE_SRC,
+                      WebViewConstants.ATTRIBUTE_PARTITION]
   };
   this.srcAndPartitionObserver.observe(this.webviewNode, params);
 };
 
 // This observer monitors mutations to attributes of the <webview> and
 // updates the BrowserPlugin properties accordingly. In turn, updating
 // a BrowserPlugin property will update the corresponding BrowserPlugin
 // attribute, if necessary. See BrowserPlugin::UpdateDOMAttribute for more
 // details.
 WebView.prototype.handleWebviewAttributeMutation =
       function(name, oldValue, newValue) {
   if (AUTO_SIZE_ATTRIBUTES.indexOf(name) > -1) {
-    this[name] = newValue;
+    this.attributes[name] = newValue;
     if (!this.guestInstanceId) {
       return;
     }
     // Convert autosize attribute to boolean.
+    // TODO(paulmeyer) is this right?

[Fady Samuel, 2014/10/22 21:48:26]

Yes, we're not looking specifically for any value of autosize. Just that
autosize exists.

[paulmeyer, 2014/10/23 21:39:56]

Acknowledged.

     var autosize = this.webviewNode.hasAttribute(
         WebViewConstants.ATTRIBUTE_AUTOSIZE);
     GuestViewInternal.setAutoSize(this.guestInstanceId, {
       'enableAutoSize': autosize,
       'min': {
-        'width': parseInt(this.minwidth || 0),
-        'height': parseInt(this.minheight || 0)
+        'width': parseInt(this.
+            attributes[WebViewConstants.ATTRIBUTE_MINWIDTH].getValue() || 0),
+        'height': parseInt(this.
+            attributes[WebViewConstants.ATTRIBUTE_MINHEIGHT].getValue() || 0)
       },
       'max': {
-        'width': parseInt(this.maxwidth || 0),
-        'height': parseInt(this.maxheight || 0)
+        'width': parseInt(this.
+            attributes[WebViewConstants.ATTRIBUTE_MAXWIDTH].getValue() || 0),
+        'height': parseInt(this.
+            attributes[WebViewConstants.ATTRIBUTE_MAXHEIGHT].getValue() || 0)
       }
     });
     return;
   } else if (name == WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY) {
     // We treat null attribute (attribute removed) and the empty string as
     // one case.
     oldValue = oldValue || '';
     newValue = newValue || '';
 
     if (oldValue === newValue) {
       return;
     }
     this.allowtransparency = newValue != '';
 
     if (!this.guestInstanceId) {
       return;
     }
 
     WebViewInternal.setAllowTransparency(this.guestInstanceId,
                                          this.allowtransparency);
     return;
-  } else if (name == 'name') {
+  } else if (name == WebViewConstants.ATTRIBUTE_NAME) {
     // We treat null attribute (attribute removed) and the empty string as
     // one case.
     oldValue = oldValue || '';
     newValue = newValue || '';
 
     if (oldValue === newValue) {
       return;
     }
-    this.name = newValue;
+    this.attributes[WebViewConstants.ATTRIBUTE_NAME].setValue(newValue);
     if (!this.guestInstanceId) {
       return;
     }
     WebViewInternal.setName(this.guestInstanceId, newValue);
     return;
-  } else if (name == 'src') {
+  } else if (name == WebViewConstants.ATTRIBUTE_SRC) {
     // We treat null attribute (attribute removed) and the empty string as
     // one case.
     oldValue = oldValue || '';
     newValue = newValue || '';
     // Once we have navigated, we don't allow clearing the src attribute.
     // Once <webview> enters a navigated state, it cannot be return back to a
     // placeholder state.
     if (newValue == '' && oldValue != '') {
       // src attribute changes normally initiate a navigation. We suppress
       // the next src attribute handler call to avoid reloading the page
       // on every guest-initiated navigation.
       this.ignoreNextSrcAttributeChange = true;
-      this.webviewNode.setAttribute('src', oldValue);
+      this.webviewNode.setAttribute(WebViewConstants.ATTRIBUTE_SRC, oldValue);
       return;
     }
-    this.src = newValue;
+    this.attributes[WebViewConstants.ATTRIBUTE_SRC].setValue(newValue);
     if (this.ignoreNextSrcAttributeChange) {
       // Don't allow the src mutation observer to see this change.
       this.srcAndPartitionObserver.takeRecords();
       this.ignoreNextSrcAttributeChange = false;
       return;
     }
     var result = {};
     this.parseSrcAttribute(result);
 
     if (result.error) {
       throw result.error;
     }
-  } else if (name == 'partition') {
+  } else if (name == WebViewConstants.ATTRIBUTE_PARTITION) {
     // Note that throwing error here won't synchronously propagate.
-    this.partition.fromAttribute(newValue, this.hasNavigated());
+    this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].setValue(newValue);
   }
 };
 
 WebView.prototype.handleBrowserPluginAttributeMutation =
     function(name, oldValue, newValue) {
-  if (name == 'internalinstanceid' && !oldValue && !!newValue) {
-    this.browserPluginNode.removeAttribute('internalinstanceid');
+  if (name == BROWSER_PLUGIN_ATTRIBUTE_INTERNALINSTANCEID &&
+      !oldValue && !!newValue) {
+    this.browserPluginNode.removeAttribute(
+        BROWSER_PLUGIN_ATTRIBUTE_INTERNALINSTANCEID);
     this.internalInstanceId = parseInt(newValue);
 
     if (!!this.guestInstanceId && this.guestInstanceId != 0) {
       var isNewWindow = this.deferredAttachState ?
           this.deferredAttachState.isNewWindow : false;
       var params = this.buildAttachParams(isNewWindow);
       guestViewInternalNatives.AttachGuest(
           this.internalInstanceId,
           this.guestInstanceId,
           params,
@@ skipping 72 matching lines @@
 // Returns if <object> is in the render tree.
 WebView.prototype.isPluginInRenderTree = function() {
   return !!this.internalInstanceId && this.internalInstanceId != 0;
 };
 
 WebView.prototype.hasNavigated = function() {
   return !this.beforeFirstNavigation;
 };
 
 WebView.prototype.parseSrcAttribute = function(result) {
-  if (!this.partition.validPartitionId) {
+  if (!this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].validPartitionId) {
     result.error = WebViewConstants.ERROR_MSG_INVALID_PARTITION_ATTRIBUTE;
     return;
   }
-  this.src = this.webviewNode.getAttribute('src');
+  this.attributes[WebViewConstants.ATTRIBUTE_SRC].setValue(
+      this.webviewNode.getAttribute(WebViewConstants.ATTRIBUTE_SRC));
 
-  if (!this.src) {
+  if (!this.attributes[WebViewConstants.ATTRIBUTE_SRC].getValue()) {
     return;
   }
 
   if (this.guestInstanceId == undefined) {
     if (this.beforeFirstNavigation) {
       this.beforeFirstNavigation = false;
       this.createGuest();
     }
     return;
   }
 
   // Navigate to |this.src|.
-  WebViewInternal.navigate(this.guestInstanceId, this.src);
+  WebViewInternal.navigate(
+      this.guestInstanceId,
+      this.attributes[WebViewConstants.ATTRIBUTE_SRC].getValue());
 };
 
 WebView.prototype.parseAttributes = function() {
   if (!this.elementAttached) {
     return;
   }
-  var hasNavigated = this.hasNavigated();
-  var attributeValue = this.webviewNode.getAttribute('partition');
-  var result = this.partition.fromAttribute(attributeValue, hasNavigated);
+  var attributeValue = this.webviewNode.getAttribute(
+      WebViewConstants.ATTRIBUTE_PARTITION);
+  var result = this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].setValue(
+      attributeValue);
   this.parseSrcAttribute(result);
 };
 
 WebView.prototype.createGuest = function() {
   if (this.pendingGuestCreation) {
     return;
   }
+  // TODO(paulmeyer) this looks wacky.

[Fady Samuel, 2014/10/22 21:48:26]

Please ask Istiaque about this. I'm not sure why the code looks like this.

[paulmeyer, 2014/10/23 21:39:55]

This will get cleaned up when I unify the storage/access of attributes in a
later patch.

   var storagePartitionId =
       this.webviewNode.getAttribute(WebViewConstants.ATTRIBUTE_PARTITION) ||
       this.webviewNode[WebViewConstants.ATTRIBUTE_PARTITION];
   var params = {
     'storagePartitionId': storagePartitionId
   };
   GuestViewInternal.createGuest(
       'webview',
       params,
       function(guestInstanceId) {
         this.pendingGuestCreation = false;
         if (!this.elementAttached) {
           GuestViewInternal.destroyGuest(guestInstanceId);
           return;
         }
         this.attachWindow(guestInstanceId, false);
       }.bind(this)
   );
   this.pendingGuestCreation = true;
 };
 
 WebView.prototype.onFrameNameChanged = function(name) {
-  this.name = name || '';
-  if (this.name === '') {
-    this.webviewNode.removeAttribute('name');
+  this.attributes[WebViewConstants.ATTRIBUTE_NAME].setValue(name || '');
+  if (this.attributes[WebViewConstants.ATTRIBUTE_NAME].getValue() === '') {
+    this.webviewNode.removeAttribute(WebViewConstants.ATTRIBUTE_NAME);
   } else {
-    this.webviewNode.setAttribute('name', this.name);
+    this.webviewNode.setAttribute(
+        WebViewConstants.ATTRIBUTE_NAME,
+        this.attributes[WebViewConstants.ATTRIBUTE_NAME].getValue());
   }
 };
 
 WebView.prototype.dispatchEvent = function(webViewEvent) {
   return this.webviewNode.dispatchEvent(webViewEvent);
 };
 
 // Adds an 'on<event>' property on the webview, which can be used to set/unset
 // an event handler.
 WebView.prototype.setupEventProperty = function(eventName) {
@@ skipping 14 matching lines @@
 };
 
 // Updates state upon loadcommit.
 WebView.prototype.onLoadCommit = function(
     baseUrlForDataUrl, currentEntryIndex, entryCount,
     processId, url, isTopLevel) {
   this.baseUrlForDataUrl = baseUrlForDataUrl;
   this.currentEntryIndex = currentEntryIndex;
   this.entryCount = entryCount;
   this.processId = processId;
-  var oldValue = this.webviewNode.getAttribute('src');
+  var oldValue = this.webviewNode.getAttribute(WebViewConstants.ATTRIBUTE_SRC);
   var newValue = url;
   if (isTopLevel && (oldValue != newValue)) {
     // Touching the src attribute triggers a navigation. To avoid
     // triggering a page reload on every guest-initiated navigation,
     // we use the flag ignoreNextSrcAttributeChange here.
     this.ignoreNextSrcAttributeChange = true;
-    this.webviewNode.setAttribute('src', newValue);
+    this.webviewNode.setAttribute(WebViewConstants.ATTRIBUTE_SRC, newValue);
   }
 };
 
 WebView.prototype.onAttach = function(storagePartitionId) {
-  this.webviewNode.setAttribute('partition', storagePartitionId);
-  this.partition.fromAttribute(storagePartitionId, this.hasNavigated());
+  this.webviewNode.setAttribute(WebViewConstants.ATTRIBUTE_PARTITION,
+                                storagePartitionId);
+  this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].setValue(
+      storagePartitionId);
 };
 
 WebView.prototype.buildAttachParams = function(isNewWindow) {
   var params = {
     'allowtransparency': this.allowtransparency || false,
     'autosize': this.webviewNode.hasAttribute(
         WebViewConstants.ATTRIBUTE_AUTOSIZE),
     'instanceId': this.viewInstanceId,
-    'maxheight': parseInt(this.maxheight || 0),
-    'maxwidth': parseInt(this.maxwidth || 0),
-    'minheight': parseInt(this.minheight || 0),
-    'minwidth': parseInt(this.minwidth || 0),
-    'name': this.name,
+    'maxheight': parseInt(this.attributes[WebViewConstants.ATTRIBUTE_MAXHEIGHT].

[Fady Samuel, 2014/10/22 21:48:26]

I feel like the key names should probably also match the attribute names, but
you can probably leave that for another CL.

[paulmeyer, 2014/10/23 21:39:56]

I agree, and hopefully there will be a nice concise way of doing this once the
attribute objects are further along (later CL).

+        getValue() || 0),
+    'maxwidth': parseInt(this.attributes[WebViewConstants.ATTRIBUTE_MAXWIDTH].
+        getValue() || 0),
+    'minheight': parseInt(this.attributes[WebViewConstants.ATTRIBUTE_MINHEIGHT].
+        getValue() || 0),
+    'minwidth': parseInt(this.attributes[WebViewConstants.ATTRIBUTE_MINWIDTH].
+        getValue() || 0),
+    'name': this.attributes[WebViewConstants.ATTRIBUTE_NAME].getValue(),
     // We don't need to navigate new window from here.
-    'src': isNewWindow ? undefined : this.src,
+    'src': isNewWindow ? undefined :
+        this.attributes[WebViewConstants.ATTRIBUTE_SRC].getValue(),
     // If we have a partition from the opener, that will also be already
     // set via this.onAttach().
-    'storagePartitionId': this.partition.toAttribute(),
+    'storagePartitionId': this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].
+        getValue(),
     'userAgentOverride': this.userAgentOverride
   };
   return params;
 };
 
 WebView.prototype.attachWindow = function(guestInstanceId,
                                                   isNewWindow) {
   this.guestInstanceId = guestInstanceId;
   var params = this.buildAttachParams(isNewWindow);
 
@@ skipping 37 matching lines @@
   if (!this.guestInstanceId) {
     return;
   }
   var args = $Array.concat([this.guestInstanceId], $Array.slice(arguments));
   $Function.apply(WebViewInternal.clearData, null, args);
 };
 
 // Injects JavaScript code into the guest page.
 WebView.prototype.executeScript = function(var_args) {
   this.validateExecuteCodeCall();
-  var webviewSrc = this.src;
+  var webviewSrc = this.attributes[WebViewConstants.ATTRIBUTE_SRC].getValue();
   if (this.baseUrlForDataUrl != '') {
     webviewSrc = this.baseUrlForDataUrl;
   }
   var args = $Array.concat([this.guestInstanceId, webviewSrc],
                            $Array.slice(arguments));
   $Function.apply(WebViewInternal.executeScript, null, args);
 };
 
 // Initiates a find-in-page request.
 WebView.prototype.find = function(search_text, options, callback) {
@@ skipping 32 matching lines @@
 WebView.prototype.go = function(relativeIndex, callback) {
   if (!this.guestInstanceId) {
     return;
   }
   WebViewInternal.go(this.guestInstanceId, relativeIndex, callback);
 };
 
 // Injects CSS into the guest page.
 WebView.prototype.insertCSS = function(var_args) {
   this.validateExecuteCodeCall();
-  var webviewSrc = this.src;
+  var webviewSrc = this.attributes[WebViewConstants.ATTRIBUTE_SRC].getValue();
   if (this.baseUrlForDataUrl != '') {
     webviewSrc = this.baseUrlForDataUrl;
   }
   var args = $Array.concat([this.guestInstanceId, webviewSrc],
                            $Array.slice(arguments));
   $Function.apply(WebViewInternal.insertCSS, null, args);
 };
 
 // Indicates whether or not the webview's user agent string has been overridden.
 WebView.prototype.isUserAgentOverridden = function() {
@@ skipping 195 matching lines @@
 WebView.prototype.maybeGetChromeWebViewEvents = function() {};
 
 // Implemented when the experimental WebView API is available.
 WebView.maybeGetExperimentalAPIs = function() {};
 WebView.prototype.maybeGetExperimentalEvents = function() {};
 WebView.prototype.setupExperimentalContextMenus = function() {};
 
 // Exports.
 exports.WebView = WebView;
 exports.WebViewInternal = WebViewInternal;