extensions/renderer/resources/guest_view/guest_view_events.js

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Event management for GuestViewContainers.
   6
   7 var EventBindings = require('event_bindings');
   8
   9 var CreateEvent = function(name) {
  10   var eventOpts = {supportsListeners: true, supportsFilters: true};
  11   return new EventBindings.Event(name, undefined, eventOpts);
  12 };
  13
  14 function GuestViewEvents(view) {
  15   this.view = view;
  16   this.on = {};
  17
  18   // |setupEventProperty| is normally called automatically, but these events are
  19   // are registered here because they are dispatched from GuestViewContainer
  20   // instead of in response to extension events.
  21   this.setupEventProperty('contentresize');
  22   this.setupEventProperty('resize');
  23   this.setupEvents();
  24 }
  25
  26 // |GuestViewEvents.EVENTS| is a dictionary of extension events to be listened
  27 //     for, which specifies how each event should be handled. The events are
  28 //     organized by name, and by default will be dispatched as DOM events with
  29 //     the same name.
  30 // |cancelable| (default: false) specifies whether the DOM event's default
  31 //     behavior can be canceled. If the default action associated with the event
  32 //     is prevented, then its dispatch function will return false in its event
  33 //     handler. The event must have a specified |handler| for this to be
  34 //     meaningful.
  35 // |evt| specifies a descriptor object for the extension event. An event
  36 //     listener will be attached to this descriptor.
  37 // |fields| (default: none) specifies the public-facing fields in the DOM event
  38 //     that are accessible to developers.
  39 // |handler| specifies the name of a handler function to be called each time
  40 //     that extension event is caught by its event listener. The DOM event
  41 //     should be dispatched within this handler function (if desired). With no
  42 //     handler function, the DOM event will be dispatched by default each time
  43 //     the extension event is caught.
  44 // |internal| (default: false) specifies that the event will not be dispatched
  45 //     as a DOM event, and will also not appear as an on* property on the view’s
  46 //     element. A |handler| should be specified for all internal events, and
  47 //     |fields| and |cancelable| should be left unspecified (as they are only
  48 //     meaningful for DOM events).
  49 GuestViewEvents.EVENTS = {};
  50
  51 // Sets up the handling of events.
  52 GuestViewEvents.prototype.setupEvents = function() {
  53   for (var eventName in GuestViewEvents.EVENTS) {
  54     this.setupEvent(eventName, GuestViewEvents.EVENTS[eventName]);
  55   }
  56
  57   var events = this.getEvents();
  58   for (var eventName in events) {
  59     this.setupEvent(eventName, events[eventName]);
  60   }
  61 };
  62
  63 // Sets up the handling of the |eventName| event.
  64 GuestViewEvents.prototype.setupEvent = function(eventName, eventInfo) {
  65   if (!eventInfo.internal) {
  66     this.setupEventProperty(eventName);
  67   }
  68
  69   var listenerOpts = { instanceId: this.view.viewInstanceId };
  70   if (eventInfo.handler) {
  71     eventInfo.evt.addListener(function(e) {
  72       this[eventInfo.handler](e, eventName);
  73     }.bind(this), listenerOpts);
  74     return;
  75   }
  76
  77   // Internal events are not dispatched as DOM events.
  78   if (eventInfo.internal) {
  79     return;
  80   }
  81
  82   eventInfo.evt.addListener(function(e) {
  83     var domEvent = this.makeDomEvent(e, eventName);
  84     this.view.dispatchEvent(domEvent);
  85   }.bind(this), listenerOpts);
  86 };
  87
  88 // Constructs a DOM event based on the info for the |eventName| event provided
  89 // in either |GuestViewEvents.EVENTS| or getEvents().
  90 GuestViewEvents.prototype.makeDomEvent = function(event, eventName) {
  91   var eventInfo =
  92       GuestViewEvents.EVENTS[eventName] || this.getEvents()[eventName];
  93
  94   // Internal events are not dispatched as DOM events.
  95   if (eventInfo.internal) {
  96     return null;
  97   }
  98
  99   var details = { bubbles: true };
 100   if (eventInfo.cancelable) {
 101     details.cancelable = true;
 102   }
 103   var domEvent = new Event(eventName, details);
 104   if (eventInfo.fields) {
 105     $Array.forEach(eventInfo.fields, function(field) {
 106       if (event[field] !== undefined) {
 107         domEvent[field] = event[field];
 108       }
 109     }.bind(this));
 110   }
 111
 112   return domEvent;
 113 };
 114
 115 // Adds an 'on<event>' property on the view, which can be used to set/unset
 116 // an event handler.
 117 GuestViewEvents.prototype.setupEventProperty = function(eventName) {
 118   var propertyName = 'on' + eventName.toLowerCase();
 119   $Object.defineProperty(this.view.element, propertyName, {
 120     get: function() {
 121       return this.on[propertyName];
 122     }.bind(this),
 123     set: function(value) {
 124       if (this.on[propertyName]) {
 125         this.view.element.removeEventListener(eventName, this.on[propertyName]);
 126       }
 127       this.on[propertyName] = value;
 128       if (value) {
 129         this.view.element.addEventListener(eventName, value);
 130       }
 131     }.bind(this),
 132     enumerable: true
 133   });
 134 };
 135
 136 // Implemented by the derived event manager, if one exists.
 137 GuestViewEvents.prototype.getEvents = function() { return {}; };
 138
 139 // Exports.
 140 exports.GuestViewEvents = GuestViewEvents;
 141 exports.CreateEvent = CreateEvent;