Moved constants out of web_view.js and into a new file, web_view_constants.js, so that the constant…

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 WEB_VIEW_ATTRIBUTE_ALLOWTRANSPARENCY = 'allowtransparency';
-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 WEB_VIEW_ATTRIBUTE_PARTITION = 'partition';
 var AUTO_SIZE_ATTRIBUTES = [
-  WEB_VIEW_ATTRIBUTE_AUTOSIZE,
-  WEB_VIEW_ATTRIBUTE_MAXHEIGHT,
-  WEB_VIEW_ATTRIBUTE_MAXWIDTH,
-  WEB_VIEW_ATTRIBUTE_MINHEIGHT,
-  WEB_VIEW_ATTRIBUTE_MINWIDTH
+  WebViewConstants.ATTRIBUTE_AUTOSIZE,
+  WebViewConstants.ATTRIBUTE_MAXHEIGHT,
+  WebViewConstants.ATTRIBUTE_MAXWIDTH,
+  WebViewConstants.ATTRIBUTE_MINHEIGHT,
+  WebViewConstants.ATTRIBUTE_MINWIDTH
 ];
 
-// Error messages.
-var ERROR_MSG_ALREADY_NAVIGATED =
-    'The object has already navigated, so its partition cannot be changed.';
-var ERROR_MSG_CANNOT_INJECT_SCRIPT = '<webview>: ' +
-    'Script cannot be injected into content until the page has loaded.';
-var ERROR_MSG_CONTENTWINDOW_NOT_AVAILABLE = '<webview>: ' +
-    'contentWindow is not available at this time. It will become available ' +
-    'when the page has finished loading.';
-var ERROR_MSG_INVALID_PARTITION_ATTRIBUTE = 'Invalid partition attribute.';
-
 // 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 = ERROR_MSG_ALREADY_NAVIGATED;
+    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 = ERROR_MSG_INVALID_PARTITION_ATTRIBUTE;
+      result.error = WebViewConstants.ERROR_MSG_INVALID_PARTITION_ATTRIBUTE;
       return result;
     }
     this.persistStorage = true;
   } else {
     this.persistStorage = false;
   }
 
   this.storagePartitionId = value;
   return result;
 };
@@ skipping 90 matching lines @@
   }.bind(this));
   this.webviewNode.addEventListener('blur', function(e) {
     // Blur the BrowserPlugin when the <webview> loses focus.
     this.browserPluginNode.blur();
   }.bind(this));
 };
 
 // Validation helper function for executeScript() and insertCSS().
 WebView.prototype.validateExecuteCodeCall  = function() {
   if (!this.guestInstanceId) {
-    throw new Error(ERROR_MSG_CANNOT_INJECT_SCRIPT);
+    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);
     Object.defineProperty(this.webviewNode, attributeName, {
       get: function() {
         return this[attributeName];
       }.bind(this),
       set: function(value) {
         this.webviewNode.setAttribute(attributeName, value);
       }.bind(this),
       enumerable: true
     });
   }.bind(this), this);
 };
 
 WebView.prototype.setupWebviewNodeProperties = function() {
   this.setupAutoSizeProperties();
 
   Object.defineProperty(this.webviewNode,
-                        WEB_VIEW_ATTRIBUTE_ALLOWTRANSPARENCY, {
+                        WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY, {
     get: function() {
       return this.allowtransparency;
     }.bind(this),
     set: function(value) {
-      this.webviewNode.setAttribute(WEB_VIEW_ATTRIBUTE_ALLOWTRANSPARENCY,
-                                    value);
+      this.webviewNode.setAttribute(
+          WebViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY,
+          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(ERROR_MSG_CONTENTWINDOW_NOT_AVAILABLE);
+      window.console.error(
+          WebViewConstants.ERROR_MSG_CONTENTWINDOW_NOT_AVAILABLE);
     }.bind(this),
     // No setter.
     enumerable: true
   });
 
   Object.defineProperty(this.webviewNode, 'name', {
     get: function() {
       return this.name;
     }.bind(this),
     set: function(value) {
@@ skipping 60 matching lines @@
 // 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;
     if (!this.guestInstanceId) {
       return;
     }
     // Convert autosize attribute to boolean.
-    var autosize = this.webviewNode.hasAttribute(WEB_VIEW_ATTRIBUTE_AUTOSIZE);
+    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)
       },
       'max': {
         'width': parseInt(this.maxwidth || 0),
         'height': parseInt(this.maxheight || 0)
       }
     });
     return;
-  } else if (name == WEB_VIEW_ATTRIBUTE_ALLOWTRANSPARENCY) {
+  } 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 != '';
 
@@ skipping 83 matching lines @@
   var newHeight = webViewEvent.newHeight;
 
   var node = this.webviewNode;
 
   var width = node.offsetWidth;
   var height = node.offsetHeight;
 
   // Check the current bounds to make sure we do not resize <webview>
   // outside of current constraints.
   var maxWidth;
-  if (node.hasAttribute(WEB_VIEW_ATTRIBUTE_MAXWIDTH) &&
-      node[WEB_VIEW_ATTRIBUTE_MAXWIDTH]) {
-    maxWidth = node[WEB_VIEW_ATTRIBUTE_MAXWIDTH];
+  if (node.hasAttribute(WebViewConstants.ATTRIBUTE_MAXWIDTH) &&
+      node[WebViewConstants.ATTRIBUTE_MAXWIDTH]) {
+    maxWidth = node[WebViewConstants.ATTRIBUTE_MAXWIDTH];
   } else {
     maxWidth = width;
   }
 
   var minWidth;
-  if (node.hasAttribute(WEB_VIEW_ATTRIBUTE_MINWIDTH) &&
-      node[WEB_VIEW_ATTRIBUTE_MINWIDTH]) {
-    minWidth = node[WEB_VIEW_ATTRIBUTE_MINWIDTH];
+  if (node.hasAttribute(WebViewConstants.ATTRIBUTE_MINWIDTH) &&
+      node[WebViewConstants.ATTRIBUTE_MINWIDTH]) {
+    minWidth = node[WebViewConstants.ATTRIBUTE_MINWIDTH];
   } else {
     minWidth = width;
   }
   if (minWidth > maxWidth) {
     minWidth = maxWidth;
   }
 
   var maxHeight;
-  if (node.hasAttribute(WEB_VIEW_ATTRIBUTE_MAXHEIGHT) &&
-      node[WEB_VIEW_ATTRIBUTE_MAXHEIGHT]) {
-    maxHeight = node[WEB_VIEW_ATTRIBUTE_MAXHEIGHT];
+  if (node.hasAttribute(WebViewConstants.ATTRIBUTE_MAXHEIGHT) &&
+      node[WebViewConstants.ATTRIBUTE_MAXHEIGHT]) {
+    maxHeight = node[WebViewConstants.ATTRIBUTE_MAXHEIGHT];
   } else {
     maxHeight = height;
   }
 
   var minHeight;
-  if (node.hasAttribute(WEB_VIEW_ATTRIBUTE_MINHEIGHT) &&
-      node[WEB_VIEW_ATTRIBUTE_MINHEIGHT]) {
-    minHeight = node[WEB_VIEW_ATTRIBUTE_MINHEIGHT];
+  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(WEB_VIEW_ATTRIBUTE_AUTOSIZE) ||
+  if (!this.webviewNode.hasAttribute(WebViewConstants.ATTRIBUTE_AUTOSIZE) ||
       (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.partition.validPartitionId) {
-    result.error = ERROR_MSG_INVALID_PARTITION_ATTRIBUTE;
+    result.error = WebViewConstants.ERROR_MSG_INVALID_PARTITION_ATTRIBUTE;
     return;
   }
   this.src = this.webviewNode.getAttribute('src');
 
   if (!this.src) {
     return;
   }
 
   if (this.guestInstanceId == undefined) {
     if (this.beforeFirstNavigation) {
@@ skipping 15 matching lines @@
   var attributeValue = this.webviewNode.getAttribute('partition');
   var result = this.partition.fromAttribute(attributeValue, hasNavigated);
   this.parseSrcAttribute(result);
 };
 
 WebView.prototype.createGuest = function() {
   if (this.pendingGuestCreation) {
     return;
   }
   var storagePartitionId =
-      this.webviewNode.getAttribute(WEB_VIEW_ATTRIBUTE_PARTITION) ||
-      this.webviewNode[WEB_VIEW_ATTRIBUTE_PARTITION];
+      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);
@@ skipping 57 matching lines @@
 };
 
 WebView.prototype.onAttach = function(storagePartitionId) {
   this.webviewNode.setAttribute('partition', storagePartitionId);
   this.partition.fromAttribute(storagePartitionId, this.hasNavigated());
 };
 
 WebView.prototype.buildAttachParams = function(isNewWindow) {
   var params = {
     'allowtransparency': this.allowtransparency || false,
-    'autosize': this.webviewNode.hasAttribute(WEB_VIEW_ATTRIBUTE_AUTOSIZE),
+    '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,
     // 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().
@@ skipping 317 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;