Remove BrowserPlugin's -internal-attach method

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.
 
 // 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 IdGenerator = requireNative('id_generator');
 // TODO(lazyboy): Rename this to WebViewInternal and call WebViewInternal
 // something else.
 var WebView = require('webViewInternal').WebView;
 var WebViewEvents = require('webViewEvents').WebViewEvents;
+var guestViewInternalNatives = requireNative('guest_view_internal');
 
 var WEB_VIEW_ATTRIBUTE_AUTOSIZE = 'autosize';
 var WEB_VIEW_ATTRIBUTE_MAXHEIGHT = 'maxheight';
 var WEB_VIEW_ATTRIBUTE_MAXWIDTH = 'maxwidth';
 var WEB_VIEW_ATTRIBUTE_MINHEIGHT = 'minheight';
 var WEB_VIEW_ATTRIBUTE_MINWIDTH = 'minwidth';
 var AUTO_SIZE_ATTRIBUTES = [
   WEB_VIEW_ATTRIBUTE_AUTOSIZE,
   WEB_VIEW_ATTRIBUTE_MAXHEIGHT,
   WEB_VIEW_ATTRIBUTE_MAXWIDTH,
   WEB_VIEW_ATTRIBUTE_MINHEIGHT,
   WEB_VIEW_ATTRIBUTE_MINWIDTH
 ];
 
 var WEB_VIEW_ATTRIBUTE_PARTITION = 'partition';
 
-var PLUGIN_METHOD_ATTACH = '-internal-attach';
-
 var ERROR_MSG_ALREADY_NAVIGATED =
     'The object has already navigated, so its partition cannot be changed.';
 var ERROR_MSG_INVALID_PARTITION_ATTRIBUTE = 'Invalid partition attribute.';
 
 /** @type {Array.<string>} */
 var WEB_VIEW_ATTRIBUTES = [
     'allowtransparency',
 ];
 
 /** @class representing state of storage partition. */
@@ skipping 97 matching lines @@
       // window.DOMContentLoaded event).
       // So copy from property if copying from attribute fails.
       browserPluginNode.setAttribute(
         attributeName, this.webviewNode[attributeName]);
     }
   }, this);
 
   return browserPluginNode;
 };
 
-WebViewInternal.prototype.getInstanceId = function() {
-  return this.instanceId;
+WebViewInternal.prototype.getGuestInstanceId = function() {
+  return this.guestInstanceId;
 };
 
 /**
  * Resets some state upon reattaching <webview> element to the DOM.
  */
-WebViewInternal.prototype.resetUponReattachment = function() {
-  this.instanceId = undefined;
-  this.beforeFirstNavigation = true;
-  this.validPartitionId = true;
-  this.partition.validPartitionId = true;
+WebViewInternal.prototype.reset = function() {
+  // If guestInstanceId is defined then the <webview> has navigated and has
+  // 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) {
+    this.guestInstanceId = undefined;
+    this.beforeFirstNavigation = true;
+    this.validPartitionId = true;
+    this.partition.validPartitionId = true;
+  }
+  this.internalInstanceId = 0;
 };
 
 // Sets <webview>.request property.
 WebViewInternal.prototype.setRequestPropertyOnWebViewNode = function(request) {
   Object.defineProperty(
       this.webviewNode,
       'request',
       {
         value: request,
         enumerable: true
@@ skipping 46 matching lines @@
  */
 WebViewInternal.prototype.canGoForward = function() {
   return this.currentEntryIndex >= 0 &&
       this.currentEntryIndex < (this.entryCount - 1);
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.clearData = function() {
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     return;
   }
-  var args = $Array.concat([this.instanceId], $Array.slice(arguments));
+  var args = $Array.concat([this.guestInstanceId], $Array.slice(arguments));
   $Function.apply(WebView.clearData, null, args);
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.getProcessId = function() {
   return this.processId;
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.go = function(relativeIndex) {
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     return;
   }
-  WebView.go(this.instanceId, relativeIndex);
+  WebView.go(this.guestInstanceId, relativeIndex);
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.print = function() {
   this.executeScript({code: 'window.print();'});
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.reload = function() {
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     return;
   }
-  WebView.reload(this.instanceId);
+  WebView.reload(this.guestInstanceId);
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.stop = function() {
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     return;
   }
-  WebView.stop(this.instanceId);
+  WebView.stop(this.guestInstanceId);
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.terminate = function() {
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     return;
   }
-  WebView.terminate(this.instanceId);
+  WebView.terminate(this.guestInstanceId);
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.validateExecuteCodeCall  = function() {
   var ERROR_MSG_CANNOT_INJECT_SCRIPT = '<webview>: ' +
       'Script cannot be injected into content until the page has loaded.';
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     throw new Error(ERROR_MSG_CANNOT_INJECT_SCRIPT);
   }
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.executeScript = function(var_args) {
   this.validateExecuteCodeCall();
-  var args = $Array.concat([this.instanceId, this.src],
+  var args = $Array.concat([this.guestInstanceId, this.src],
                            $Array.slice(arguments));
   $Function.apply(WebView.executeScript, null, args);
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.insertCSS = function(var_args) {
   this.validateExecuteCodeCall();
-  var args = $Array.concat([this.instanceId, this.src],
+  var args = $Array.concat([this.guestInstanceId, this.src],
                            $Array.slice(arguments));
   $Function.apply(WebView.insertCSS, null, args);
 };
 
 WebViewInternal.prototype.setupAutoSizeProperties = function() {
   var self = this;
   $Array.forEach(AUTO_SIZE_ATTRIBUTES, function(attributeName) {
     this[attributeName] = this.webviewNode.getAttribute(attributeName);
     Object.defineProperty(this.webviewNode, attributeName, {
       get: function() {
@@ skipping 134 matching lines @@
  */
 WebViewInternal.prototype.handleWebviewAttributeMutation =
       function(name, oldValue, newValue) {
   // 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.
   if (AUTO_SIZE_ATTRIBUTES.indexOf(name) > -1) {
     this[name] = newValue;
-    if (!this.instanceId) {
+    if (!this.guestInstanceId) {
       return;
     }
     // Convert autosize attribute to boolean.
     var autosize = this.webviewNode.hasAttribute(WEB_VIEW_ATTRIBUTE_AUTOSIZE);
-    GuestViewInternal.setAutoSize(this.instanceId, {
+    GuestViewInternal.setAutoSize(this.guestInstanceId, {
       'enableAutoSize': autosize,
       'min': {
         'width': parseInt(this.minwidth || 0),
         'height': parseInt(this.minheight || 0)
       },
       'max': {
         'width': parseInt(this.maxwidth || 0),
         'height': parseInt(this.maxheight || 0)
       }
     });
     return;
   } else if (name == '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;
-    if (!this.instanceId) {
+    if (!this.guestInstanceId) {
       return;
     }
-    WebView.setName(this.instanceId, newValue);
+    WebView.setName(this.guestInstanceId, newValue);
     return;
   } else if (name == '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 != '') {
@@ skipping 32 matching lines @@
   } else {
     this.browserPluginNode.setAttribute(name, newValue);
   }
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.handleBrowserPluginAttributeMutation =
     function(name, oldValue, newValue) {
-  if (name == 'internalbindings' && !oldValue && newValue) {
-    this.browserPluginNode.removeAttribute('internalbindings');
-
-    if (this.deferredAttachState) {
-      var self = this;
-      // A setTimeout is necessary for the binding to be initialized properly.
+  if (name == 'internalinstanceid' && !oldValue && !!newValue) {
+    this.browserPluginNode.removeAttribute('internalinstanceid');
+    this.internalInstanceId = parseInt(newValue);
+    if (this.deferredAttachState && !!this.guestInstanceId &&
+            this.guestInstanceId != 0) {
       window.setTimeout(function() {
-        if (self.hasBindings()) {
-          var params = self.buildAttachParams(
-              self.deferredAttachState.isNewWindow);
-          self.browserPluginNode[PLUGIN_METHOD_ATTACH](self.instanceId, params);
-          self.deferredAttachState = null;
-        }
-      }, 0);
+        var isNewWindow = this.deferredAttachState ?
+            this.deferredAttachState.isNewWindow : false;
+        var params = this.buildAttachParams(isNewWindow);
+        guestViewInternalNatives.AttachGuest(
+            this.internalInstanceId,
+            this.guestInstanceId,
+            params);
+      }.bind(this), 0);
     }
     return;
   }
 
   // This observer monitors mutations to attributes of the BrowserPlugin and
   // updates the <webview> attributes accordingly.
   // |newValue| is null if the attribute |name| has been removed.
   if (newValue != null) {
     // Update the <webview> attribute to match the BrowserPlugin attribute.
     // Note: Calling setAttribute on <webview> will trigger its mutation
@@ skipping 66 matching lines @@
        newHeight >= minHeight &&
        newHeight <= maxHeight)) {
     node.style.width = newWidth + 'px';
     node.style.height = newHeight + 'px';
     // Only fire the DOM event if the size of the <webview> has actually
     // changed.
     this.dispatchEvent(webViewEvent);
   }
 };
 
-// Returns true if Browser Plugin bindings is available.
-// Bindings are unavailable if <object> is not in the render tree.
-WebViewInternal.prototype.hasBindings = function() {
-  return 'function' == typeof this.browserPluginNode[PLUGIN_METHOD_ATTACH];
+// Returns if <object> is in the render tree.
+WebViewInternal.prototype.isPluginInRenderTree = function() {
+  return !!this.internalInstanceId && this.internalInstanceId != 0;
 };
 
 WebViewInternal.prototype.hasNavigated = function() {
   return !this.beforeFirstNavigation;
 };
 
 /** @return {boolean} */
 WebViewInternal.prototype.parseSrcAttribute = function(result) {
   if (!this.partition.validPartitionId) {
     result.error = ERROR_MSG_INVALID_PARTITION_ATTRIBUTE;
@@ skipping 11 matching lines @@
 
   if (!this.hasGuestInstanceID()) {
     if (this.beforeFirstNavigation) {
       this.beforeFirstNavigation = false;
       this.allocateInstanceId();
     }
     return true;
   }
 
   // Navigate to this.src.
-  WebView.navigate(this.instanceId, this.src);
+  WebView.navigate(this.guestInstanceId, this.src);
   return true;
 };
 
 /** @return {boolean} */
 WebViewInternal.prototype.parseAttributes = function() {
   var hasNavigated = this.hasNavigated();
   var attributeValue = this.webviewNode.getAttribute('partition');
   var result = this.partition.fromAttribute(attributeValue, hasNavigated);
   return this.parseSrcAttribute(result);
 };
 
 WebViewInternal.prototype.hasGuestInstanceID = function() {
-  return this.instanceId != undefined;
+  return this.guestInstanceId != undefined;
 };
 
 WebViewInternal.prototype.allocateInstanceId = function() {
   var storagePartitionId =
       this.webviewNode.getAttribute(WEB_VIEW_ATTRIBUTE_PARTITION) ||
       this.webviewNode[WEB_VIEW_ATTRIBUTE_PARTITION];
   var params = {
     'storagePartitionId': storagePartitionId,
   };
   var self = this;
   GuestViewInternal.createGuest(
       'webview',
       params,
-      function(instanceId) {
+      function(guestInstanceId) {
         // TODO(lazyboy): Make sure this.autoNavigate_ stuff correctly updated
         // |self.src| at this point.
-        self.attachWindow(instanceId, false);
+        self.attachWindow(guestInstanceId, false);
       });
 };
 
 WebViewInternal.prototype.onFrameNameChanged = function(name) {
   this.name = name || '';
   if (this.name === '') {
     this.webviewNode.removeAttribute('name');
   } else {
     this.webviewNode.setAttribute('name', this.name);
   }
@@ skipping 56 matching lines @@
 
 /** @private */
 WebViewInternal.prototype.isUserAgentOverridden = function() {
   return !!this.userAgentOverride &&
       this.userAgentOverride != navigator.userAgent;
 };
 
 /** @private */
 WebViewInternal.prototype.setUserAgentOverride = function(userAgentOverride) {
   this.userAgentOverride = userAgentOverride;
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     // If we are not attached yet, then we will pick up the user agent on
     // attachment.
     return;
   }
-  WebView.overrideUserAgent(this.instanceId, userAgentOverride);
+  WebView.overrideUserAgent(this.guestInstanceId, userAgentOverride);
 };
 
 /** @private */
 WebViewInternal.prototype.find = function(search_text, options, callback) {
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     return;
   }
-  WebView.find(this.instanceId, search_text, options, callback);
+  WebView.find(this.guestInstanceId, search_text, options, callback);
 };
 
 /** @private */
 WebViewInternal.prototype.stopFinding = function(action) {
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     return;
   }
-  WebView.stopFinding(this.instanceId, action);
+  WebView.stopFinding(this.guestInstanceId, action);
 };
 
 /** @private */
 WebViewInternal.prototype.setZoom = function(zoomFactor, callback) {
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     return;
   }
-  WebView.setZoom(this.instanceId, zoomFactor, callback);
+  WebView.setZoom(this.guestInstanceId, zoomFactor, callback);
 };
 
 WebViewInternal.prototype.getZoom = function(callback) {
-  if (!this.instanceId) {
+  if (!this.guestInstanceId) {
     return;
   }
-  WebView.getZoom(this.instanceId, callback);
+  WebView.getZoom(this.guestInstanceId, callback);
 };
 
 WebViewInternal.prototype.buildAttachParams = function(isNewWindow) {
   var params = {
     'autosize': this.webviewNode.hasAttribute(WEB_VIEW_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,
     // We don't need to navigate new window from here.
     'src': isNewWindow ? undefined : this.src,
     // If we have a partition from the opener, that will also be already
     // set via this.onAttach().
     'storagePartitionId': this.partition.toAttribute(),
     'userAgentOverride': this.userAgentOverride
   };
   return params;
 };
 
-WebViewInternal.prototype.attachWindow = function(instanceId, isNewWindow) {
-  this.instanceId = instanceId;
+WebViewInternal.prototype.attachWindow = function(guestInstanceId,
+                                                  isNewWindow) {
+  this.guestInstanceId = guestInstanceId;
   var params = this.buildAttachParams(isNewWindow);
 
-  if (!this.hasBindings()) {
-    // No bindings means that the plugin isn't there (display: none), we defer
-    // attachWindow in this case.
+  if (!this.isPluginInRenderTree()) {
     this.deferredAttachState = {isNewWindow: isNewWindow};
     return false;
   }
 
   this.deferredAttachState = null;
-  return this.browserPluginNode[PLUGIN_METHOD_ATTACH](this.instanceId, params);
+  return guestViewInternalNatives.AttachGuest(
+      this.internalInstanceId,
+      this.guestInstanceId,
+      params);
 };
 
 // Registers browser plugin <object> custom element.
 function registerBrowserPluginElement() {
   var proto = Object.create(HTMLObjectElement.prototype);
 
   proto.createdCallback = function() {
     this.setAttribute('type', 'application/browser-plugin');
+    this.setAttribute('id', 'browser-plugin-' + IdGenerator.GetNextId());

[Fady Samuel, 2014/08/13 22:24:39]

Note to self: Remove this.

     // The <object> node fills in the <webview> container.
     this.style.width = '100%';
     this.style.height = '100%';
   };
 
   proto.attributeChangedCallback = function(name, oldValue, newValue) {
     var internal = privates(this).internal;
     if (!internal) {
       return;
     }
@@ skipping 30 matching lines @@
     }
     internal.handleWebviewAttributeMutation(name, oldValue, newValue);
   };
 
   proto.detachedCallback = function() {
     var internal = privates(this).internal;
     if (!internal) {
       return;
     }
     internal.elementAttached = false;
+    internal.reset();
   };
 
   proto.attachedCallback = function() {
     var internal = privates(this).internal;
     if (!internal) {
       return;
     }
     if (!internal.elementAttached) {
       internal.elementAttached = true;
-      internal.resetUponReattachment();
       internal.parseAttributes();
     }
   };
 
   var methods = [
     'back',
     'find',
     'forward',
     'canGoBack',
     'canGoForward',
@@ skipping 66 matching lines @@
  * Calls to show contextmenu right away instead of dispatching a 'contextmenu'
  * event.
  * This will be overridden in web_view_experimental.js to implement contextmenu
  * API.
  */
 WebViewInternal.prototype.maybeHandleContextMenu = function(e, webViewEvent) {
   var requestId = e.requestId;
   // Setting |params| = undefined will show the context menu unmodified, hence
   // the 'contextmenu' API is disabled for stable channel.
   var params = undefined;
-  WebView.showContextMenu(this.instanceId, requestId, params);
+  WebView.showContextMenu(this.guestInstanceId, requestId, params);
 };
 
 /**
  * Implemented when the experimental API is available.
  * @private
  */
 WebViewInternal.prototype.setupExperimentalContextMenus = function() {};
 
 exports.WebView = WebView;
 exports.WebViewInternal = WebViewInternal;