Move allocate instance id 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.
 
 // 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 EventBindings = require('event_bindings');
+var GuestView = require('binding').Binding.create('guestview').generate();
 var IdGenerator = requireNative('id_generator');
 var MessagingNatives = requireNative('messaging_natives');
 var WebRequestEvent = require('webRequestInternal').WebRequestEvent;
 var WebRequestSchema =
     requireNative('schema_registry').GetSchema('webRequest');
 var DeclarativeWebRequestSchema =
     requireNative('schema_registry').GetSchema('declarativeWebRequest');
 var WebView = require('webview').WebView;
 
 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 WEB_VIEW_ATTRIBUTE_PARTITION = 'partition';
+
+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',
     'autosize',
-    'partition',
     WEB_VIEW_ATTRIBUTE_MINHEIGHT,
     WEB_VIEW_ATTRIBUTE_MINWIDTH,
     WEB_VIEW_ATTRIBUTE_MAXHEIGHT,
     WEB_VIEW_ATTRIBUTE_MAXWIDTH
 ];
 
+/** @class representing state of storage partition. */
+function Partition() {
+  this.validPartitionId = true;
+  this.persist_storage_ = false;
+  this.storage_partition_id = '';
+};
+
+Partition.prototype.toAttribute = function() {
+  if (!this.validPartitionId) {
+    return '';
+  }
+  return (this.persist_storage_ ? 'persist:' : '') + this.storage_partition_id;
+};
+
+Partition.prototype.fromAttribute = function(value, hasNavigated) {
+  var result = {};
+  if (hasNavigated) {
+    result.error = 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 = ERROR_MSG_INVALID_PARTITION_ATTRIBUTE;
+      return result;
+    }
+    this.persist_storage_ = true;
+  } else {
+    this.persist_storage_ = false;
+  }
+
+  this.storage_partition_id = value;
+  return result;
+};
+
 var CreateEvent = function(name) {
   var eventOpts = {supportsListeners: true, supportsFilters: true};
   return new EventBindings.Event(name, undefined, eventOpts);
 };
 
 // WEB_VIEW_EVENTS is a map of stable <webview> DOM event names to their
 //     associated extension event descriptor objects.
 // An event listener will be attached to the extension event |evt| specified in
 //     the descriptor.
 // |fields| specifies the public-facing fields in the DOM event that are
@@ skipping 123 matching lines @@
 // Implemented when the experimental API is available.
 WebViewInternal.maybeRegisterExperimentalAPIs = function(proto) {}
 
 /**
  * @constructor
  */
 function WebViewInternal(webviewNode) {
   privates(webviewNode).internal = this;
   this.webviewNode = webviewNode;
   this.attached = false;
+
+  this.beforeFirstNavigation = true;
+  this.validPartitionId = true;
+
   this.browserPluginNode = this.createBrowserPluginNode();
   var shadowRoot = this.webviewNode.createShadowRoot();
   shadowRoot.appendChild(this.browserPluginNode);
 
   this.setupWebviewNodeAttributes();
   this.setupFocusPropagation();
   this.setupWebviewNodeProperties();
+
+  this.viewInstanceId = IdGenerator.GetNextId();
+
+  //this.allocateInstanceId();

[Fady Samuel, 2014/06/04 04:54:18]

Remove this?

+  this.partition = new Partition();
+  this.parseAttributes();
+
   this.setupWebviewNodeEvents();
 }
 
 /**
  * @private
  */
 WebViewInternal.prototype.createBrowserPluginNode = function() {
   // We create BrowserPlugin as a custom element in order to observe changes
   // to attributes synchronously.
   var browserPluginNode = new WebViewInternal.BrowserPlugin();
   privates(browserPluginNode).internal = this;
 
-  var ALL_ATTRIBUTES = WEB_VIEW_ATTRIBUTES.concat(['src']);
-  $Array.forEach(ALL_ATTRIBUTES, function(attributeName) {
+  $Array.forEach(WEB_VIEW_ATTRIBUTES, function(attributeName) {
     // Only copy attributes that have been assigned values, rather than copying
     // a series of undefined attributes to BrowserPlugin.
     if (this.webviewNode.hasAttribute(attributeName)) {
       browserPluginNode.setAttribute(
         attributeName, this.webviewNode.getAttribute(attributeName));
     } else if (this.webviewNode[attributeName]){
       // Reading property using has/getAttribute does not work on
       // document.DOMContentLoaded event (but works on
       // window.DOMContentLoaded event).
       // So copy from property if copying from attribute fails.
       browserPluginNode.setAttribute(
         attributeName, this.webviewNode[attributeName]);
     }
   }, this);
 
   return browserPluginNode;
 };
 
 /**
  * @private
+ * Resets some state upon re-attaching <webview> element to the DOM.
+ */
+WebViewInternal.prototype.resetUponReattachment = function() {
+  this.instanceId = undefined;
+  this.beforeFirstNavigation = true;
+  this.validPartitionId = true;
+  this.partition.validPartitionId = true;
+};
+
+/**
+ * @private
  */
 WebViewInternal.prototype.setupFocusPropagation = function() {
   if (!this.webviewNode.hasAttribute('tabIndex')) {
     // <webview> needs a tabIndex in order to be focusable.
     // TODO(fsamuel): It would be nice to avoid exposing a tabIndex attribute
     // to allow <webview> to be focusable.
     // See http://crbug.com/231664.
     this.webviewNode.setAttribute('tabIndex', -1);
   }
   var self = this;
@@ skipping 162 matching lines @@
   Object.defineProperty(this.webviewNode, 'name', {
     get: function() {
       return self.name;
     },
     set: function(value) {
       self.webviewNode.setAttribute('name', value);
     },
     enumerable: true
   });
 
+  Object.defineProperty(this.webviewNode, 'partition', {
+    get: function() {
+      return self.partition.toAttribute();
+    },
+    set: function(value) {
+      var result = self.partition.fromAttribute(value, self.hasNavigated());
+      if (result.error) {
+        throw result.error;
+      }
+      self.webviewNode.setAttribute('partition', value);
+    },
+    enumerable: true
+  });
+
   // We cannot use {writable: true} property descriptor because we want a
   // dynamic getter value.
   Object.defineProperty(this.webviewNode, 'contentWindow', {
     get: function() {
       if (browserPluginNode.contentWindow)
         return browserPluginNode.contentWindow;
       window.console.error(ERROR_MSG_CONTENTWINDOW_NOT_AVAILABLE);
     },
     // No setter.
     enumerable: true
@@ skipping 10 matching lines @@
 /**
  * @private
  */
 WebViewInternal.prototype.setupWebViewSrcAttributeMutationObserver =
     function() {
   // 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.
   var self = this;
-  this.srcObserver = new MutationObserver(function(mutations) {
+  this.srcAndPartitionObserver = new MutationObserver(function(mutations) {
     $Array.forEach(mutations, function(mutation) {
       var oldValue = mutation.oldValue;
       var newValue = self.webviewNode.getAttribute(mutation.attributeName);
       if (oldValue != newValue) {
         return;
       }
       self.handleWebviewAttributeMutation(
           mutation.attributeName, oldValue, newValue);
     });
   });
   var params = {
     attributes: true,
     attributeOldValue: true,
-    attributeFilter: ['src']
+    attributeFilter: ['src', 'partition']
   };
-  this.srcObserver.observe(this.webviewNode, params);
+  this.srcAndPartitionObserver.observe(this.webviewNode, params);
 };
 
 /**
  * @private
  */
 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
@@ skipping 26 matching lines @@
       // 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);
       return;
     }
     this.src = newValue;
     if (this.ignoreNextSrcAttributeChange) {
       // Don't allow the src mutation observer to see this change.
-      this.srcObserver.takeRecords();
+      this.srcAndPartitionObserver.takeRecords();
       this.ignoreNextSrcAttributeChange = false;
       return;
     }
+    var result = {};
+    this.parseSrcAttribute(result);
+
+    if (result.error) {
+      throw result.error;
+    }
+  } else if (name == 'partition') {
+    // Note that throwing error here won't synchronously propagate.
+    this.partition.fromAttribute(newValue, this.hasNavigated());
   }
+
+  // No <webview> -> <object> mutation propagation for these attributes.
+  if (name == 'src' || name == 'partition') {
+    return;
+  }
+
   if (this.browserPluginNode.hasOwnProperty(name)) {
     this.browserPluginNode[name] = newValue;
   } else {
     this.browserPluginNode.setAttribute(name, newValue);
   }
 };
 
 /**
  * @private
  */
@@ skipping 80 matching lines @@
   if (webViewEvent.newWidth >= minWidth &&
       webViewEvent.newWidth <= maxWidth &&
       webViewEvent.newHeight >= minHeight &&
       webViewEvent.newHeight <= maxHeight) {
     node.style.width = webViewEvent.newWidth + 'px';
     node.style.height = webViewEvent.newHeight + 'px';
   }
   node.dispatchEvent(webViewEvent);
 };
 
+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;
+    return false;
+  }
+  this.src = this.webviewNode.getAttribute('src');
+
+  if (!this.src) {
+    return true;
+  }
+
+  if (!this.hasGuestInstanceID()) {
+    if (this.beforeFirstNavigation) {
+      this.beforeFirstNavigation = false;
+      this.allocateInstanceId();
+    }
+    return true;
+  }
+
+  // Navigate to this.src.
+  WebView.navigate(this.instanceId, 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;
+};
+
+WebViewInternal.prototype.allocateInstanceId = function() {
+  // Parse .src and .partition.
+  var self = this;
+  GuestView.allocateInstanceId(
+      function(instanceId) {
+        self.instanceId = instanceId;
+        // TODO(lazyboy): Make sure this.autoNavigate_ stuff correctly updated
+        // |self.src| at this point.
+        self.attachWindowAndSetUpEvents(self.instanceId, self.src);
+      });
+};
+
 /**
  * @private
  */
 WebViewInternal.prototype.setupWebviewNodeEvents = function() {
-  var self = this;
-  this.viewInstanceId = IdGenerator.GetNextId();
-  var onInstanceIdAllocated = function(e) {
-    var detail = e.detail ? JSON.parse(e.detail) : {};
-    self.attachWindowAndSetUpEvents(detail.windowId);
-  };
-  this.browserPluginNode.addEventListener('-internal-instanceid-allocated',
-                                          onInstanceIdAllocated);
   this.setupWebRequestEvents();
   this.setupExperimentalContextMenus_();
 
   this.on = {};
-  var events = self.getEvents();
+  var events = this.getEvents();
   for (var eventName in events) {
     this.setupEventProperty(eventName);
   }
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.setupNameAttribute = function() {
   var self = this;
@@ skipping 211 matching lines @@
       validateCall();
       if (!webview || !webview.tagName || webview.tagName != '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 webViewInternal = privates(webview).internal;
+        if (event.storagePartitionId) {
+          webViewInternal.webviewNode.setAttribute('partition',
+                                                   event.storagePartitionId);
+          var partition = new Partition();
+          partition.fromAttribute(event.storagePartitionId,
+                                  webViewInternal.hasNavigated());
+          webViewInternal.partition = partition;
+        }
+
         var attached =
-            webViewInternal.attachWindowAndSetUpEvents(event.windowId);
+            webViewInternal.attachWindowAndSetUpEvents(
+                event.windowId, undefined, event.storagePartitionId);
 
         if (!attached) {
           window.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.
         WebView.setPermission(
             self.instanceId, requestId, attached ? 'allow' : 'deny');
@@ skipping 233 matching lines @@
   this.userAgentOverride = userAgentOverride;
   if (!this.instanceId) {
     // If we are not attached yet, then we will pick up the user agent on
     // attachment.
     return;
   }
   WebView.overrideUserAgent(this.instanceId, userAgentOverride);
 };
 
 /** @private */
-WebViewInternal.prototype.attachWindowAndSetUpEvents = function(instanceId) {
+WebViewInternal.prototype.attachWindowAndSetUpEvents = function(
+    instanceId, opt_src, opt_partitionId) {
   this.instanceId = instanceId;
+  // If we have a partition from the opener, use that instead.
+  var storagePartitionId =
+      opt_partitionId ||
+      this.webviewNode.getAttribute(WEB_VIEW_ATTRIBUTE_PARTITION) ||
+      this.webviewNode[WEB_VIEW_ATTRIBUTE_PARTITION];
   var params = {
     'api': 'webview',
     'instanceId': this.viewInstanceId,
-    'name': this.name
+    'name': this.name,
+    'src': opt_src,
+    'storagePartitionId': storagePartitionId,
+    'userAgentOverride': this.userAgentOverride
   };
-  if (this.userAgentOverride) {
-    params['userAgentOverride'] = this.userAgentOverride;
-  }
   this.setupNameAttribute();
   var events = this.getEvents();
   for (var eventName in events) {
     this.setupEvent(eventName, events[eventName]);
   }
 
   return this.browserPluginNode['-internal-attach'](this.instanceId, params);
 };
 
 // Registers browser plugin <object> custom element.
@@ skipping 31 matching lines @@
 }
 
 // Registers <webview> custom element.
 function registerWebViewElement() {
   var proto = Object.create(HTMLElement.prototype);
 
   proto.createdCallback = function() {
     new WebViewInternal(this);
   };
 
+  proto.customElementDetached = false;
+
   proto.attributeChangedCallback = function(name, oldValue, newValue) {
     var internal = privates(this).internal;
     if (!internal) {
       return;
     }
     internal.handleWebviewAttributeMutation(name, oldValue, newValue);
   };
 
+  proto.detachedCallback = function() {
+    this.customElementDetached = true;
+  };
+
+  proto.attachedCallback = function() {
+    if (this.customElementDetached) {
+      var webViewInternal = privates(this).internal;
+      webViewInternal.resetUponReattachment();
+      webViewInternal.allocateInstanceId();
+    }
+    this.customElementDetached = false;
+  };
+
   proto.back = function() {
     this.go(-1);
   };
 
   proto.forward = function() {
     this.go(1);
   };
 
   proto.canGoBack = function() {
     return privates(this).internal.canGoBack();
@@ skipping 103 matching lines @@
 
 /**
  * Implemented when the experimental API is available.
  * @private
  */
 WebViewInternal.prototype.setupExperimentalContextMenus_ = function() {};
 
 exports.WebView = WebView;
 exports.WebViewInternal = WebViewInternal;
 exports.CreateEvent = CreateEvent;