<webview>: Move name attribute 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 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';
 
 /** @type {Array.<string>} */
 var WEB_VIEW_ATTRIBUTES = [
     'allowtransparency',
     'autosize',
-    'name',
     'partition',
     WEB_VIEW_ATTRIBUTE_MINHEIGHT,
     WEB_VIEW_ATTRIBUTE_MINWIDTH,
     WEB_VIEW_ATTRIBUTE_MAXHEIGHT,
     WEB_VIEW_ATTRIBUTE_MAXWIDTH
 ];
 
 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
 //     accessible to <webview> developers.
 // |customHandler| allows a handler function to be called each time an extension
 //     event is caught by its event listener. The DOM event should be dispatched
 //     within this handler function. With no handler function, the DOM event
 //     will be dispatched by default each time the extension event is caught.
 // |cancelable| (default: false) specifies whether the event's default
 //     behavior can be canceled. If the default action associated with the event
 //     is prevented, then its dispatch function will return false in its event
 //     handler. The event must have a custom handler for this to be meaningful.
+
+var FrameNameChangedEvent = CreateEvent('webview.onFrameNameChanged');
+
 var WEB_VIEW_EVENTS = {
   'close': {
     evt: CreateEvent('webview.onClose'),
     fields: []
   },
   'consolemessage': {
     evt: CreateEvent('webview.onConsoleMessage'),
     fields: ['level', 'message', 'line', 'sourceId']
   },
   'contentload': {
@@ skipping 314 matching lines @@
     get: function() {
       return self.src;
     },
     set: function(value) {
       self.webviewNode.setAttribute('src', value);
     },
     // No setter.
     enumerable: true
   });
 
+  Object.defineProperty(this.webviewNode, 'name', {
+    get: function() {
+      return self.name;
+    },
+    set: function(value) {
+      self.webviewNode.setAttribute('name', 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 39 matching lines @@
 /**
  * @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
   // attribute, if necessary. See BrowserPlugin::UpdateDOMAttribute for more
   // details.
-  if (name == 'src') {
+  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 || '';
     // 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);
@@ skipping 125 matching lines @@
   this.on = {};
   var events = self.getEvents();
   for (var eventName in events) {
     this.setupEventProperty(eventName);
   }
 };
 
 /**
  * @private
  */
+WebViewInternal.prototype.setupNameAttribute = function() {
+  var self = this;
+  FrameNameChangedEvent.addListener(function(event) {
+    self.name = event.name || '';
+    if (self.name === '') {
+      self.webviewNode.removeAttribute('name');
+    } else {
+      self.webviewNode.setAttribute('name', self.name);
+    }
+  }, {instanceId: self.instanceId});
+};
+
+/**
+ * @private
+ */
 WebViewInternal.prototype.setupEvent = function(eventName, eventInfo) {
   var self = this;
   var webviewNode = this.webviewNode;
   eventInfo.evt.addListener(function(event) {
     var details = {bubbles:true};
     if (eventInfo.cancelable)
       details.cancelable = true;
     var webViewEvent = new Event(eventName, details);
     $Array.forEach(eventInfo.fields, function(field) {
       if (event[field] !== undefined) {
@@ skipping 409 matching lines @@
     return;
   }
   WebView.overrideUserAgent(this.instanceId, userAgentOverride);
 };
 
 /** @private */
 WebViewInternal.prototype.attachWindowAndSetUpEvents = function(instanceId) {
   this.instanceId = instanceId;
   var params = {
     'api': 'webview',
-    'instanceId': this.viewInstanceId
+    'instanceId': this.viewInstanceId,
+    'name': this.name
   };
   if (this.userAgentOverride) {
     params['userAgentOverride'] = this.userAgentOverride;
   }
-  this.browserPluginNode['-internal-attach'](this.instanceId, params);
-
+  this.setupNameAttribute();
   var events = this.getEvents();
   for (var eventName in events) {
     this.setupEvent(eventName, events[eventName]);
   }
+
+  this.browserPluginNode['-internal-attach'](this.instanceId, params);
+
   return true;
 };
 
 // Registers browser plugin <object> custom element.
 function registerBrowserPluginElement() {
   var proto = Object.create(HTMLObjectElement.prototype);
 
   proto.createdCallback = function() {
     this.setAttribute('type', 'application/browser-plugin');
     // The <object> node fills in the <webview> container.
@@ skipping 162 matching lines @@
 
 /**
  * Implemented when the experimental API is available.
  * @private
  */
 WebViewInternal.prototype.setupExperimentalContextMenus_ = function() {};
 
 exports.WebView = WebView;
 exports.WebViewInternal = WebViewInternal;
 exports.CreateEvent = CreateEvent;