Added the infrastructure for surfaceProxy.onResize() and SurfaceView.onResize()

extensions/renderer/resources/guest_view/guest_view.js

 // Copyright 2014 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 a wrapper for a guestview that manages its
 // creation, attaching, and destruction.
 
+var EventBindings = require('event_bindings');
 var GuestViewInternal =
     require('binding').Binding.create('guestViewInternal').generate();
 var GuestViewInternalNatives = requireNative('guest_view_internal');
 
+// Events.
+var CreateEvent = function(name) {
+  var eventOpts = {supportsListeners: true, supportsFilters: true};
+  return new EventBindings.Event(name, undefined, eventOpts);
+};
+var ResizeEvent = CreateEvent('guestViewInternal.onResize');
+
 // Possible states.
 var GUEST_STATE_ATTACHED = 2;
 var GUEST_STATE_CREATED = 1;
 var GUEST_STATE_START = 0;
 
 // Error messages.
 var ERROR_MSG_ALREADY_ATTACHED = 'The guest has already been attached.';
 var ERROR_MSG_ALREADY_CREATED = 'The guest has already been created.';
 var ERROR_MSG_INVALID_STATE = 'The guest is in an invalid state.';
 var ERROR_MSG_NOT_ATTACHED = 'The guest is not attached.';
 var ERROR_MSG_NOT_CREATED = 'The guest has not been created.';
 
+// Properties.
+var PROPERTY_ON_RESIZE = 'onResize';
+
 // Contains and hides the internal implementation details of |GuestView|,
 // including maintaining its state and enforcing the proper usage of its API
 // fucntions.
-
-function GuestViewImpl(viewType, guestInstanceId) {
+function GuestViewImpl(guestView, viewType, guestInstanceId) {
   if (guestInstanceId) {
     this.id = guestInstanceId;
     this.state = GUEST_STATE_CREATED;
   } else {
     this.id = 0;
     this.state = GUEST_STATE_START;
   }
   this.actionQueue = [];
   this.contentWindow = null;
+  this.guestView = guestView;
   this.pendingAction = null;
   this.viewType = viewType;
   this.internalInstanceId = 0;
+
+  this.setupOnResize();
 }
 
+// Sets up the onResize property on the GuestView.
+GuestViewImpl.prototype.setupOnResize = function() {
+  Object.defineProperty(this.guestView, PROPERTY_ON_RESIZE, {
+    get: function() {
+      return this[PROPERTY_ON_RESIZE];
+    }.bind(this),
+    set: function(value) {
+      this[PROPERTY_ON_RESIZE] = value;
+    }.bind(this),
+    enumerable: true
+  });
+
+  this.callOnResize = function(e) {
+    if (!this[PROPERTY_ON_RESIZE]) {
+      return;
+    }
+    this[PROPERTY_ON_RESIZE](e.oldWidth, e.oldHeight, e.newWidth, e.newHeight);
+  }.bind(this);
+};
+
 // Callback wrapper that is used to call the callback of the pending action (if
 // one exists), and then performs the next action in the queue.
 GuestViewImpl.prototype.handleCallback = function(callback) {
   if (callback) {
     callback();
   }
   this.pendingAction = null;
   this.performNextAction();
 };
 
@@ skipping 102 matching lines @@
   // createGuest() callback, handle potential creation failure, and advance the
   // queue.
   var callbackWrapper = function(callback, guestInstanceId) {
     this.id = guestInstanceId;
 
     // Check if creation failed.
     if (this.id === 0) {
       this.state = GUEST_STATE_START;
     }
 
+    ResizeEvent.addListener(this.callOnResize, {instanceId: this.id});
     this.handleCallback(callback);
   };
 
   GuestViewInternal.createGuest(this.viewType,
                                 createParams,
                                 callbackWrapper.bind(this, callback));
 
   this.state = GUEST_STATE_CREATED;
 };
 
 // Internal implementation of destroy().
 GuestViewImpl.prototype.destroyImpl = function(callback) {
   // Check the current state.
   if (!this.checkState('destroy')) {
     this.handleCallback(callback);
     return;
   }
 
   if (this.state == GUEST_STATE_START) {
     // destroy() does nothing in this case.
     this.handleCallback(callback);
     return;
   }
 
   GuestViewInternal.destroyGuest(this.id,
                                  this.handleCallback.bind(this, callback));
 
+  // Reset the state of the destroyed guest;
   this.contentWindow = null;
   this.id = 0;
   this.internalInstanceId = 0;
   this.state = GUEST_STATE_START;
+  if (ResizeEvent.hasListener(this.callOnResize)) {
+    ResizeEvent.removeListener(this.callOnResize);
+  }
 };
 
 // Internal implementation of detach().
 GuestViewImpl.prototype.detachImpl = function(callback) {
   // Check the current state.
   if (!this.checkState('detach')) {
     this.handleCallback(callback);
     return;
   }
 
@@ skipping 15 matching lines @@
   }
 
   GuestViewInternal.setAutoSize(this.id, autoSizeParams,
                                 this.handleCallback.bind(this, callback));
 };
 
 // The exposed interface to a guestview. Exposes in its API the functions
 // attach(), create(), destroy(), and getId(). All other implementation details
 // are hidden.
 function GuestView(viewType, guestInstanceId) {
-  privates(this).internal = new GuestViewImpl(viewType, guestInstanceId);
+  privates(this).internal = new GuestViewImpl(this, viewType, guestInstanceId);
 }
 
 // Attaches the guestview to the container with ID |internalInstanceId|.
 GuestView.prototype.attach = function(
     internalInstanceId, viewInstanceId, attachParams, callback) {
   var internal = privates(this).internal;
   internal.actionQueue.push(internal.attachImpl.bind(
       internal, internalInstanceId, viewInstanceId, attachParams, callback));
   internal.performNextAction();
 };
@@ skipping 37 matching lines @@
 };
 
 // Returns the ID for this guestview.
 GuestView.prototype.getId = function() {
   var internal = privates(this).internal;
   return internal.id;
 };
 
 // Exports
 exports.GuestView = GuestView;