Got rid of the internal copies of webview attributes.

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 =
@@ skipping 111 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.attributes[attributeName].setValue(
-        this.webviewNode.getAttribute(attributeName));
     Object.defineProperty(this.webviewNode, attributeName, {
       get: function() {
         return this.attributes[attributeName].getValue();
       }.bind(this),
       set: function(value) {
-        this.webviewNode.setAttribute(attributeName, value);
+        this.attributes[attributeName].setValue(value);
       }.bind(this),
       enumerable: true
     });
   }.bind(this), this);
 };
 
 WebView.prototype.setupWebviewNodeProperties = function() {
   this.setupAutoSizeProperties();
 
   Object.defineProperty(this.webviewNode,
                         WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY, {
     get: function() {
       return this.attributes[WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY].
           getValue();
     }.bind(this),
     set: function(value) {
-      this.webviewNode.setAttribute(
-          WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY,
-          value);
+      this.attributes[WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY].
+          setValue(value);
     }.bind(this),
     enumerable: true
   });
 
   // We cannot use {writable: true} property descriptor because we want a
   // dynamic getter value.
   Object.defineProperty(this.webviewNode, 'contentWindow', {
     get: function() {
       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, WebViewConstants.ATTRIBUTE_NAME, {
     get: function() {
       return this.attributes[WebViewConstants.ATTRIBUTE_NAME].getValue();
     }.bind(this),
     set: function(value) {
-      this.webviewNode.setAttribute(WebViewConstants.ATTRIBUTE_NAME, value);
+      this.attributes[WebViewConstants.ATTRIBUTE_NAME].setValue(value);
     }.bind(this),
     enumerable: true
   });
 
   Object.defineProperty(this.webviewNode,
                         WebViewConstants.ATTRIBUTE_PARTITION, {
     get: function() {
       return this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].getValue();
     }.bind(this),
     set: function(value) {
-      var result = this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].
-          setValue(value);
-      if (result.error) {
-        throw result.error;
-      }
-      this.webviewNode.setAttribute(WebViewConstants.ATTRIBUTE_PARTITION,
-                                    value);
+      this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].setValue(value);
     }.bind(this),
     enumerable: true
   });
 
-  this.attributes[WebViewConstants.ATTRIBUTE_SRC].setValue(
-      this.webviewNode.getAttribute(WebViewConstants.ATTRIBUTE_SRC));
   Object.defineProperty(this.webviewNode, WebViewConstants.ATTRIBUTE_SRC, {
     get: function() {
       return this.attributes[WebViewConstants.ATTRIBUTE_SRC].getValue();
     }.bind(this),
     set: function(value) {
-      this.webviewNode.setAttribute(WebViewConstants.ATTRIBUTE_SRC, value);
+      this.attributes[WebViewConstants.ATTRIBUTE_SRC].setValue(value);
     }.bind(this),
     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);
+      var newValue = this.attributes[mutation.attributeName].getValue();
       if (oldValue != newValue) {
         return;
       }
       this.handleWebviewAttributeMutation(
           mutation.attributeName, oldValue, newValue);
     }.bind(this));
   }.bind(this));
   var params = {
     attributes: true,
     attributeOldValue: true,
     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.attributes[name].setValue(newValue);
+      function(attributeName, oldValue, newValue) {
+  // Certain changes (such as internally-initiated changes) to attributes should
+  // not be handled normally.
+  if (this.attributes[attributeName] &&
+      this.attributes[attributeName].ignoreNextMutation) {
+    this.attributes[attributeName].ignoreNextMutation = false;
+    return;
+  }
+
+  if (AUTO_SIZE_ATTRIBUTES.indexOf(attributeName) > -1) {
     if (!this.guestInstanceId) {
       return;
     }
-    // Convert autosize attribute to boolean.
-    var autosize = this.webviewNode.hasAttribute(
-        WebViewConstants.ATTRIBUTE_AUTOSIZE);
     GuestViewInternal.setAutoSize(this.guestInstanceId, {
-      'enableAutoSize': autosize,
+      'enableAutoSize': this.attributes[WebViewConstants.ATTRIBUTE_AUTOSIZE].
+          getValue(),
       'min': {
         'width': parseInt(this.
             attributes[WebViewConstants.ATTRIBUTE_MINWIDTH].getValue() || 0),
         'height': parseInt(this.
             attributes[WebViewConstants.ATTRIBUTE_MINHEIGHT].getValue() || 0)
       },
       'max': {
         '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) {
+  } else if (attributeName == 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.attributes[WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY].
-        setValue(newValue != '');
-
-    if (!this.guestInstanceId) {
+    if (oldValue === newValue || !this.guestInstanceId) {
       return;
     }
 
     WebViewInternal.setAllowTransparency(
         this.guestInstanceId,
         this.attributes[WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY].
             getValue());
     return;
-  } else if (name == WebViewConstants.ATTRIBUTE_NAME) {
+  } else if (attributeName == 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.attributes[WebViewConstants.ATTRIBUTE_NAME].setValue(newValue);
+
     if (!this.guestInstanceId) {
       return;
     }
     WebViewInternal.setName(this.guestInstanceId, newValue);
     return;
-  } else if (name == WebViewConstants.ATTRIBUTE_SRC) {
+  } else if (attributeName == 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
+    // Once <webview> enters a navigated state, it cannot return 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(WebViewConstants.ATTRIBUTE_SRC, oldValue);
       return;
     }
-    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 == WebViewConstants.ATTRIBUTE_PARTITION) {
-    // Note that throwing error here won't synchronously propagate.
-    this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].setValue(newValue);
+  } else if (attributeName == WebViewConstants.ATTRIBUTE_PARTITION) {
+    this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].handleMutation(
+        oldValue, newValue);
   }
 };
 
 WebView.prototype.handleBrowserPluginAttributeMutation =
-    function(name, oldValue, newValue) {
-  if (name == WebViewConstants.ATTRIBUTE_INTERNALINSTANCEID &&
+    function(attributeName, oldValue, newValue) {
+  if (attributeName == WebViewConstants.ATTRIBUTE_INTERNALINSTANCEID &&
       !oldValue && !!newValue) {
     this.browserPluginNode.removeAttribute(
         WebViewConstants.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(
@@ skipping 52 matching lines @@
   if (node.hasAttribute(WebViewConstants.ATTRIBUTE_MINHEIGHT) &&
       node[WebViewConstants.ATTRIBUTE_MINHEIGHT]) {
     minHeight = node[WebViewConstants.ATTRIBUTE_MINHEIGHT];
   } else {
     minHeight = height;
   }
   if (minHeight > maxHeight) {
     minHeight = maxHeight;
   }
 
-  if (!this.webviewNode.hasAttribute(WebViewConstants.ATTRIBUTE_AUTOSIZE) ||
+  if (!this.attributes[WebViewConstants.ATTRIBUTE_AUTOSIZE].getValue() ||
       (newWidth >= minWidth &&
        newWidth <= maxWidth &&
        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 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.attributes[WebViewConstants.ATTRIBUTE_PARTITION].validPartitionId) {
     result.error = WebViewConstants.ERROR_MSG_INVALID_PARTITION_ATTRIBUTE;
     return;
   }
-  this.attributes[WebViewConstants.ATTRIBUTE_SRC].setValue(
-      this.webviewNode.getAttribute(WebViewConstants.ATTRIBUTE_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.attributes[WebViewConstants.ATTRIBUTE_SRC].getValue());
 };
 
 WebView.prototype.parseAttributes = function() {
   if (!this.elementAttached) {
     return;
   }
-  var attributeValue = this.webviewNode.getAttribute(
-      WebViewConstants.ATTRIBUTE_PARTITION);
-  var result = this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].setValue(
-      attributeValue);
+  var result = {};

[Fady Samuel, 2014/11/03 22:38:18]

Is this necessary?

[paulmeyer, 2014/11/03 22:58:19]

no

   this.parseSrcAttribute(result);
 };
 
 WebView.prototype.createGuest = function() {
   if (this.pendingGuestCreation) {
     return;
   }
-  var storagePartitionId =
-      this.webviewNode.getAttribute(WebViewConstants.ATTRIBUTE_PARTITION) ||
-      this.webviewNode[WebViewConstants.ATTRIBUTE_PARTITION];
   var params = {
-    'storagePartitionId': storagePartitionId
+    'storagePartitionId': this.attributes[
+      WebViewConstants.ATTRIBUTE_PARTITION].getValue()
   };
   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.attributes[WebViewConstants.ATTRIBUTE_NAME].setValue(name || '');
-  if (this.attributes[WebViewConstants.ATTRIBUTE_NAME].getValue() === '') {
+  name = name || '';
+  if (name === '') {
     this.webviewNode.removeAttribute(WebViewConstants.ATTRIBUTE_NAME);
   } else {
-    this.webviewNode.setAttribute(
-        WebViewConstants.ATTRIBUTE_NAME,
-        this.attributes[WebViewConstants.ATTRIBUTE_NAME].getValue());
+    this.attributes[WebViewConstants.ATTRIBUTE_NAME].setValue(name);
   }
 };
 
 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(WebViewConstants.ATTRIBUTE_SRC);
+  var oldValue = this.attributes[WebViewConstants.ATTRIBUTE_SRC].getValue();
   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(WebViewConstants.ATTRIBUTE_SRC, newValue);
   }
 };
 
 WebView.prototype.onAttach = function(storagePartitionId) {
-  this.webviewNode.setAttribute(WebViewConstants.ATTRIBUTE_PARTITION,
-                                storagePartitionId);
   this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].setValue(
       storagePartitionId);
 };
 
 WebView.prototype.buildAttachParams = function(isNewWindow) {
   var params = {
     'allowtransparency': this.attributes[
-      WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY].getValue() || false,
-    'autosize': this.webviewNode.hasAttribute(
-        WebViewConstants.ATTRIBUTE_AUTOSIZE),
+      WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY].getValue(),
+    'autosize': this.attributes[WebViewConstants.ATTRIBUTE_AUTOSIZE].getValue(),
     'instanceId': this.viewInstanceId,
     'maxheight': parseInt(this.attributes[WebViewConstants.ATTRIBUTE_MAXHEIGHT].
         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.attributes[WebViewConstants.ATTRIBUTE_SRC].getValue(),
     // If we have a partition from the opener, that will also be already
     // set via this.onAttach().
     'storagePartitionId': this.attributes[WebViewConstants.ATTRIBUTE_PARTITION].
         getValue(),
     'userAgentOverride': this.userAgentOverride
   };
   return params;
 };
 
 WebView.prototype.attachWindow = function(guestInstanceId,
-                                                  isNewWindow) {
+                                          isNewWindow) {
   this.guestInstanceId = guestInstanceId;
   var params = this.buildAttachParams(isNewWindow);
 
   if (!this.isPluginInRenderTree()) {
     this.deferredAttachState = {isNewWindow: isNewWindow};
     return true;
   }
 
   this.deferredAttachState = null;
   return guestViewInternalNatives.AttachGuest(
@@ skipping 299 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;