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.';
+
+var LOG = function(msg) {
+  window.console.log(msg);
+};
 
 /** @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() {
+  LOG('Partition.toAttribute');
+  if (!this.validPartitionId_) {
+    LOG('Warning we have invalid partition id');
+    return '';
+  }
+  return (this.persist_storage_ ? 'persist:' : '') + this.storage_partition_id_;
+};
+
+Partition.prototype.fromAttribute = function(value, hasNavigated) {
+  LOG('Partition.fromAttribute');
+  LOG('value: ' + value + ', hasNavigated: ' + hasNavigated);
+  var result = {};
+  if (hasNavigated) {
+    result.error = ERROR_MSG_ALREADY_NAVIGATED;
+    return result;
+  }
+  if (!value) {
+    LOG('Partition.fromAttribute got empty 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 120 matching lines @@
   }
 };
 
 // Implemented when the experimental API is available.
 WebViewInternal.maybeRegisterExperimentalAPIs = function(proto) {}
 
 /**
  * @constructor
  */
 function WebViewInternal(webviewNode) {
+  LOG('WebViewInternal.constructor');
   privates(webviewNode).internal = this;
   this.webviewNode = webviewNode;
   this.attached = false;
+
+  this.beforeFirstNavigation_ = true;

[Fady Samuel, 2014/05/29 20:35:23]

We haven't been using _ for privates now. Let's drop that for consistency. I'm
not sure what the style should be for privates... Maybe we should restore the
underscores?

[lazyboy, 2014/05/30 05:48:21]

Ya, underscores are supposed to be for privates according to google js style
guide.
We can do that if we feel like, moved _'s for consistency.
Done.

+  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();
+  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.
@@ skipping 182 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() {
+      window.console.log('getter.partition');
+      var ret = self.partition_.toAttribute();
+      window.console.log('returning: ' + ret);
+      return ret;
+    },
+    set: function(value) {
+      window.console.log('setter.partition, value: ' + value);
+      var result = self.partition_.fromAttribute(value, self.hasNavigated());
+      if (result.error) {
+        throw result.error;
+      }
+      self.webviewNode.setAttribute('partition', value);
+
+      // TODO(lazyboy): CanRemovePartitionAttribute() when removeAttribute().
+    },
+    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) {
+  window.console.log('handleWebviewAttributeMutation, name = ' + name);
   // 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 (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) {
       return;
     }
     WebView.setName(this.instanceId, newValue);
     return;
   } else if (name == 'src') {
     // We treat null attribute (attribute removed) and the empty string as
     // one case.
     oldValue = oldValue || '';
     newValue = newValue || '';
+    LOG('WebViewInternal.handleWebviewAttributeMutation, old = ' + oldValue + ', new = ' + 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);
       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;
     }
+    LOG('srcAttributeChanged');
+    var result = {};
+    this.parseSrcAttribute(result);
+
+    if (result.error) {
+      throw result.error;
+    }
+  } else if (name == 'partition') {
+    LOG('handleWebviewAttributeMutation.partition');
+    LOG('newValue: ' + newValue + ', oldValue: ' + oldValue);
+    // TODO(lazyboy): Do we do extra work here if we get here from
+    // Object.set.partition?
+    this.partition_.fromAttribute(newValue, this.hasNavigated());
   }
-  if (this.browserPluginNode.hasOwnProperty(name)) {
-    this.browserPluginNode[name] = newValue;
-  } else {
-    this.browserPluginNode.setAttribute(name, newValue);
+
+  // No <webview> -> <object> mutation propagation for these attributes.
+  if (name != 'src' && name != 'partition') {
+    if (this.browserPluginNode.hasOwnProperty(name)) {
+      this.browserPluginNode[name] = newValue;
+    } else {
+      this.browserPluginNode.setAttribute(name, newValue);
+    }
   }
 };
 
 /**
  * @private
  */
 WebViewInternal.prototype.handleBrowserPluginAttributeMutation =
     function(name, newValue) {
+  if (name == 'src') {
+    // name == 'src' here implies autoNavigate = true;
+    this.autoNavigate_ = true;
+    this.partition_.fromAttribute('persist:custom_plugin', this.hasNavigated());
+  }
+
   // 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
     // observer which will then propagate that attribute to BrowserPlugin. In
     // cases where we permit assigning a BrowserPlugin attribute the same value
     // again (such as navigation when crashed), this could end up in an infinite
     // loop. Thus, we avoid this loop by only updating the <webview> attribute
@@ skipping 68 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) {
+  LOG('parseSrcAttribute');
+  if (!this.partition_.validPartitionId_) {
+    LOG('ERROR_MSG_INVALID_PARTITION_ATTRIBUTE');
+    result.error = ERROR_MSG_INVALID_PARTITION_ATTRIBUTE;
+    return false;
+  }
+
+  this.src = this.webviewNode.getAttribute('src');
+  LOG('parseSrcAttribute, srcAttribute: ' + this.src);
+
+  if (!this.src) {
+    LOG('src empty');
+    return true;
+  }
+
+  LOG('hasGuestInstanceID: ' + this.hasGuestInstanceID());
+  LOG('beforeFirstNavigation_: ' + this.beforeFirstNavigation_);
+  if (!this.hasGuestInstanceID()) {
+    if (this.beforeFirstNavigation_) {
+      this.beforeFirstNavigation_ = false;
+      this.allocateInstanceId();
+    }
+    return true;
+  }
+
+  LOG('Webview.navigate, i: ' + this.instanceId + ', src = ' + this.src);
+
+  // Navigate to this.src.
+  WebView.navigate(this.instanceId, this.src);
+  return true;
+};
+
+/** @return {boolean} */
+WebViewInternal.prototype.parseAttributes = function() {
+  LOG('parseAttributes');
+  var hasNavigated = this.hasNavigated();
+
+  var attributeValue = this.webviewNode.getAttribute('partition');
+  LOG('parseAttributes, partition.ttributeValue: ' + attributeValue);
+  var result = this.partition_.fromAttribute(attributeValue, hasNavigated);
+  return this.parseSrcAttribute(result);
+};
+
+WebViewInternal.prototype.hasGuestInstanceID = function() {
+  return this.instanceId != undefined;
+};
+
+WebViewInternal.prototype.allocateInstanceId = function() {
+  LOG('allocateInstanceId');
+  //this.viewInstanceId = IdGenerator.GetNextId();
+  LOG('cur partition: ' + this.webviewNode.getAttribute('partition'));
+  LOG('cur partition prop: ' + this.webviewNode['partition']);
+
+  // Parse .src and .partition.
+
+  var self = this;
+  GuestView.allocateInstanceId(
+      'webview',
+      this.viewInstanceId,
+      function(info) {
+        LOG('allocateInstanceId.callback.info: ' + info);
+        self.instanceId = info;
+        // 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;
+        LOG('=== Attach w/o a src');
+
+        if (event.storagePartitionId) {
+          LOG('read partition string: ' + 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 190 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() {
+    LOG('<webview> got detached');
+    LOG('this.customElementDetached was: ' + this.customElementDetached);
+    this.customElementDetached = true;
+  };
+  proto.attachedCallback = function() {
+    LOG('attached, for the first time or subsequent, must init later');
+    LOG('this.customElementDetached was: ' + this.customElementDetached);
+    if (this.customElementDetached) {
+      var otherThis = privates(this).internal;
+      LOG('allocateInstanceId again');
+      otherThis.instanceId = undefined;
+      otherThis.beforeFirstNavigation_ = true;
+      otherThis.validPartitionId_ = true;
+      otherThis.partition_.validPartitionId_ = true;
+
+      otherThis.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 109 matching lines @@
 
 /**
  * Implemented when the experimental API is available.
  * @private
  */
 WebViewInternal.prototype.setupExperimentalContextMenus_ = function() {};
 
 exports.WebView = WebView;
 exports.WebViewInternal = WebViewInternal;
 exports.CreateEvent = CreateEvent;