<webview>: Move contentload event from content 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.
 
 // Shim that simulates a <webview> tag via Mutation Observers.
 //
 // The actual tag is implemented via the browser plugin. The internals of this
 // are hidden via Shadow DOM.
 
 var watchForTag = require('tagWatcher').watchForTag;
 var eventBindings = require('event_bindings');
 
 /** @type {Array.<string>} */
 var WEB_VIEW_ATTRIBUTES = ['name', 'src', 'partition', 'autosize', 'minheight',
     'minwidth', 'maxheight', 'maxwidth'];
 
 
 // All exposed api methods for <webview>, these are forwarded to the browser
 // plugin.
 var WEB_VIEW_API_METHODS = [
   'getProcessId',
   'reload',
   'stop',
   'terminate'
 ];
 
 var WEB_VIEW_EVENTS = {
   'close': [],
   'consolemessage': ['level', 'message', 'line', 'sourceId'],
-  'contentload' : [],
   'exit' : ['processId', 'reason'],
   'loadabort' : ['url', 'isTopLevel', 'reason'],
-  'loadcommit' : ['url', 'isTopLevel'],
   'loadredirect' : ['oldUrl', 'newUrl', 'isTopLevel'],
   'loadstart' : ['url', 'isTopLevel'],
-  'loadstop' : [],
   'responsive' : ['processId'],
   'sizechanged': ['oldHeight', 'oldWidth', 'newHeight', 'newWidth'],
   'unresponsive' : ['processId']
 };
 
 var createEvent = function(name) {
   var eventOpts = {supportsListeners: true, supportsFilters: true};
   return new eventBindings.Event(name, undefined, eventOpts);
 };
 
+var contentLoadEvent = createEvent('webview.onContentLoad');
 var loadCommitEvent = createEvent('webview.onLoadCommit');
 var loadStopEvent = createEvent('webview.onLoadStop');
 
+var WEB_VIEW_EXT_EVENTS = {
+  'contentload': {
+    evt: contentLoadEvent,
+    fields: []
+  },
+  'loadcommit': {
+    customHandler: function(WebView, event) {
+      WebView.currentEntryIndex_ = event.currentEntryIndex;
+      WebView.entryCount_ = event.entryCount;
+    },
+    evt: loadCommitEvent,
+    fields: ['url', 'isTopLevel']
+  }
+  ,
+  'loadstop': {
+    evt: loadStopEvent,
+    fields: []
+  }
+};
+
+
 // The <webview> tags we wish to watch for (watchForTag) does not belong to the
 // current scope's "document" reference. We need to wait until the document
 // begins loading, since only then will the "document" reference
 // point to the page's document (it will be reset between now and then).
 // We can't listen for the "readystatechange" event on the document (because
 // the object that it's dispatched on doesn't exist yet), but we can instead
 // do it at the window level in the capturing phase.
 window.addEventListener('readystatechange', function(e) {
   if (document.readyState != 'loading') {
     return;
@@ skipping 239 matching lines @@
     }
   }
 };
 
 /**
  * @private
  */
 WebView.prototype.setupWebviewNodeEvents_ = function() {
   var self = this;
   var webviewNode = this.webviewNode_;
-  // TODO(fsamuel): Generalize this further as we add more events.
-  var onAttached = function(e) {
+  this.browserPluginNode_.addEventListener('-internal-attached', function(e) {
     var detail = e.detail ? JSON.parse(e.detail) : {};
-    loadCommitEvent.addListener(function(event) {
-      var webviewEvent = new Event('loadcommit', {bubbles: true});
-      var attribs = WEB_VIEW_EVENTS['loadcommit'];
-      $Array.forEach(attribs, function(attribName) {
-        webviewEvent[attribName] = event[attribName];
-      });
-      self.currentEntryIndex_ = event.currentEntryIndex;
-      self.entryCount_ = event.entryCount;
-      webviewNode.dispatchEvent(webviewEvent);
-    }, {instanceId: detail.windowId});
-
-    loadStopEvent.addListener(function(event) {
-      var webviewEvent = new Event('loadstop', {bubbles: true});
-      var attribs = WEB_VIEW_EVENTS['loadstop'];
-      $Array.forEach(attribs, function(attribName) {
-        webviewEvent[attribName] = event[attribName];
-      });
-      webviewNode.dispatchEvent(webviewEvent);
-    }, {instanceId: detail.windowId});
-  };
-  this.browserPluginNode_.addEventListener('-internal-attached', onAttached);
+    self.instanceId_ = detail.windowId;
+    for (var eventName in WEB_VIEW_EXT_EVENTS) {
+      self.setupExtEvent_(eventName, WEB_VIEW_EXT_EVENTS[eventName]);
+    }
+  });
 
   for (var eventName in WEB_VIEW_EVENTS) {
     this.setupEvent_(eventName, WEB_VIEW_EVENTS[eventName]);
   }
   this.setupNewWindowEvent_();
   this.setupPermissionEvent_();
 };
 
 /**
  * @private
  */
-WebView.prototype.setupEvent_ = function(eventname, attribs) {
+WebView.prototype.setupExtEvent_ = function(eventName, eventInfo) {
+  var self = this;
   var webviewNode = this.webviewNode_;
-  var internalname = '-internal-' + eventname;
+  eventInfo.evt.addListener(function(event) {
+    var webviewEvent = new Event(eventName, {bubbles: true});
+    $Array.forEach(eventInfo.fields, function(field) {
+      webviewEvent[field] = event[field];
+    });
+    if (eventInfo.customHandler) {
+      eventInfo.customHandler(self, event);
+    }
+    webviewNode.dispatchEvent(webviewEvent);
+  }, {instanceId: self.instanceId_});
+};
+
+/**
+ * @private
+ */
+WebView.prototype.setupEvent_ = function(eventName, attribs) {
+  var webviewNode = this.webviewNode_;
+  var internalname = '-internal-' + eventName;
   this.browserPluginNode_.addEventListener(internalname, function(e) {
-    var evt = new Event(eventname, { bubbles: true });
+    var evt = new Event(eventName, { bubbles: true });
     var detail = e.detail ? JSON.parse(e.detail) : {};
     $Array.forEach(attribs, function(attribName) {
       evt[attribName] = detail[attribName];
     });
     webviewNode.dispatchEvent(evt);
   });
 };
 
 /**
  * @private
@@ skipping 192 matching lines @@
   return [];
 };
 
 /**
  * Implemented when the experimental API is available.
  * @private
  */
 WebView.prototype.maybeSetupExperimentalAPI_ = function() {};
 
 exports.WebView = WebView;