remoting/webapp/browser_test/bump_scroll_browser_test.js

   1 // Copyright 2014 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 /**
   6  * @fileoverview
   7  * @suppress {checkTypes}
   8  * Browser test for the scenario below:
   9  * 1. Enter full-screen mode
  10  * 2. Move the mouse to each edge; verify that the desktop bump-scrolls.
  11  */
  12
  13 'use strict';
  14
  15 /** @constructor */
  16 browserTest.FakeDesktopViewport = function() {
  17   /** @private */
  18   this.pluginPosition_ = {
  19     top: 0,
  20     left: 0
  21   };
  22   /** @private */
  23   this.bumpScroller_ = new base.EventSourceImpl();
  24   this.bumpScroller_.defineEvents(Object.keys(remoting.BumpScroller.Events));
  25 };
  26
  27 /**
  28  * @param {number} top
  29  * @param {number} left
  30  * @return {void} nothing.
  31  */
  32 browserTest.FakeDesktopViewport.prototype.setPluginPositionForTesting =
  33     function(top, left) {
  34   this.pluginPosition_ = {
  35     top: top,
  36     left: left
  37   };
  38 };
  39
  40 /**
  41  * @return {{top: number, left:number}} The top-left corner of the plugin.
  42  */
  43 browserTest.FakeDesktopViewport.prototype.getPluginPositionForTesting =
  44     function() {
  45   return this.pluginPosition_;
  46 };
  47
  48 /** @return {base.EventSource} */
  49 browserTest.FakeDesktopViewport.prototype.getBumpScrollerForTesting =
  50     function() {
  51   return this.bumpScroller_;
  52 };
  53
  54 browserTest.FakeDesktopViewport.prototype.raiseEvent =
  55     function() {
  56   return this.bumpScroller_.raiseEvent.apply(this.bumpScroller_, arguments);
  57 };
  58
  59 /** @return {remoting.DesktopViewport} */
  60 function getViewportForTesting() {
  61   var desktopApp = /** @type {remoting.DesktopRemoting} */ (remoting.app);
  62   var view = desktopApp.getConnectedViewForTesting();
  63   if (view) {
  64     return view.getViewportForTesting();
  65   }
  66   return null;
  67 }
  68
  69 /** @constructor */
  70 browserTest.Bump_Scroll = function() {
  71   // To avoid dependencies on the actual host desktop size, we simulate a
  72   // desktop larger or smaller than the client window. The exact value is
  73   // arbitrary, but must be positive.
  74   /** @type {number} */
  75   this.kHostDesktopSizeDelta = 10;
  76 };
  77
  78 /**
  79  * @param {{pin:string}} data
  80  */
  81 browserTest.Bump_Scroll.prototype.run = function(data) {
  82   browserTest.expect(typeof data.pin == 'string');
  83
  84   if (!base.isAppsV2()) {
  85     browserTest.fail(
  86         'Bump-scroll requires full-screen, which can only be activated ' +
  87         'programmatically in apps v2.')
  88   }
  89
  90   this.testVerifyScroll().then(function() {
  91     return browserTest.connectMe2Me();
  92   }).then(function() {
  93     return browserTest.enterPIN(data.pin);
  94   }).then(
  95     this.noScrollWindowed.bind(this)
  96   ).then(
  97     this.activateFullscreen.bind(this)
  98   ).then(
  99     this.noScrollSmaller.bind(this)
 100     // The order of these operations is important. Because the plugin starts
 101     // scrolled to the top-left, it needs to be scrolled right and down first.
 102   ).then(
 103     this.scrollDirection.bind(this, 1.0, 0.5)  // Right edge
 104   ).then(
 105     this.scrollDirection.bind(this, 0.5, 1.0)  // Bottom edge
 106   ).then(
 107     this.scrollDirection.bind(this, 0.0, 0.5)  // Left edge
 108   ).then(
 109     this.scrollDirection.bind(this, 0.5, 0.0)  // Top edge
 110   ).then(
 111     function(value) {
 112       browserTest.disconnect();
 113       return browserTest.pass(value);
 114     },
 115     function(error) {
 116       browserTest.disconnect();
 117       return browserTest.fail(error);
 118     }
 119   );
 120 };
 121
 122 /**
 123  * @return {Promise}
 124  */
 125 browserTest.Bump_Scroll.prototype.noScrollWindowed = function() {
 126   var viewport = getViewportForTesting();
 127   viewport.setPluginSizeForBumpScrollTesting(
 128       window.innerWidth + this.kHostDesktopSizeDelta,
 129       window.innerHeight + this.kHostDesktopSizeDelta);
 130   this.moveMouseTo(0, 0);
 131   return this.verifyNoScroll();
 132 };
 133
 134 /**
 135  * @return {Promise}
 136  */
 137 browserTest.Bump_Scroll.prototype.noScrollSmaller = function() {
 138   var viewport = getViewportForTesting();
 139   viewport.setPluginSizeForBumpScrollTesting(
 140       window.innerWidth - this.kHostDesktopSizeDelta,
 141       window.innerHeight - this.kHostDesktopSizeDelta);
 142   this.moveMouseTo(0, 0);
 143   return this.verifyNoScroll();
 144 };
 145
 146 /**
 147  * @param {number} widthFraction
 148  * @param {number} heightFraction
 149  * @return {Promise}
 150  */
 151 browserTest.Bump_Scroll.prototype.scrollDirection =
 152     function(widthFraction, heightFraction) {
 153   var viewport = getViewportForTesting();
 154   viewport.setPluginSizeForBumpScrollTesting(
 155       screen.width + this.kHostDesktopSizeDelta,
 156       screen.height + this.kHostDesktopSizeDelta);
 157   /** @type {number} */
 158   var expectedTop = heightFraction === 0.0 ? 0 :
 159                     heightFraction == 1.0 ? -this.kHostDesktopSizeDelta :
 160                     undefined;
 161   /** @type {number} */
 162   var expectedLeft = widthFraction === 0.0 ? 0 :
 163                      widthFraction === 1.0 ? -this.kHostDesktopSizeDelta :
 164                      undefined;
 165   var result = this.verifyScroll(expectedTop, expectedLeft);
 166   this.moveMouseTo(widthFraction * screen.width,
 167                    heightFraction * screen.height);
 168   return result;
 169 };
 170
 171 /**
 172  * @return {Promise}
 173  */
 174 browserTest.Bump_Scroll.prototype.activateFullscreen = function() {
 175   return new Promise(function(fulfill, reject) {
 176     remoting.fullscreen.activate(true, function() {
 177       // The onFullscreen callback is invoked before the window has
 178       // resized, so defer fulfilling the promise so that innerWidth
 179       // and innerHeight are correct.
 180       base.Promise.sleep(1000).then(fulfill);
 181     });
 182     base.Promise.sleep(5000).then(function(){
 183       reject('Timed out waiting for full-screen');
 184     });
 185   });
 186 };
 187
 188 /**
 189  * @param {number} x
 190  * @param {number} y
 191  */
 192 browserTest.Bump_Scroll.prototype.moveMouseTo = function(x, y) {
 193   var e = {
 194     bubbles: true,
 195     cancelable: false,
 196     view: window,
 197     detail: 0,
 198     screenX: x,
 199     screenY: y,
 200     clientX: x,
 201     clientY: y,
 202     ctrlKey: false,
 203     altKey: false,
 204     shiftKey: false,
 205     metaKey: false,
 206     button: 0,
 207     relatedTarget: undefined
 208   };
 209   var event = document.createEvent('MouseEvents');
 210   event.initMouseEvent('mousemove',
 211                        e.bubbles, e.cancelable, e.view, e.detail,
 212                        e.screenX, e.screenY, e.clientX, e.clientY,
 213                        e.ctrlKey, e.altKey, e.shiftKey, e.metaKey,
 214                        e.button, document.documentElement);
 215   document.documentElement.dispatchEvent(event);
 216 };
 217
 218 /**
 219  * verifyScroll() is complicated enough to warrant a test.
 220  * @return {Promise}
 221  */
 222 browserTest.Bump_Scroll.prototype.testVerifyScroll = function() {
 223   var STARTED = remoting.BumpScroller.Events.bumpScrollStarted;
 224   var STOPPED = remoting.BumpScroller.Events.bumpScrollStopped;
 225   var fakeViewport = new browserTest.FakeDesktopViewport;
 226   var that = this;
 227
 228   // No events raised (e.g. windowed mode).
 229   var result = this.verifyNoScroll(fakeViewport)
 230
 231   .then(function() {
 232     // Start and end events raised, but no scrolling (e.g. full-screen mode
 233     // with host desktop <= window size).
 234     fakeViewport = new browserTest.FakeDesktopViewport;
 235     var result = that.verifyNoScroll(fakeViewport);
 236     fakeViewport.raiseEvent(STARTED, {});
 237     fakeViewport.raiseEvent(STOPPED, {});
 238     return result;
 239
 240   }).then(function() {
 241     // Start and end events raised, with incorrect scrolling.
 242     fakeViewport = new browserTest.FakeDesktopViewport;
 243     var result = base.Promise.negate(
 244         that.verifyScroll(2, 2, fakeViewport));
 245     fakeViewport.raiseEvent(STARTED, {});
 246     fakeViewport.setPluginPositionForTesting(1, 1);
 247     fakeViewport.raiseEvent(STOPPED, {});
 248     return result;
 249
 250   }).then(function() {
 251     // Start event raised, but not end event.
 252     fakeViewport = new browserTest.FakeDesktopViewport;
 253     var result = base.Promise.negate(
 254         that.verifyScroll(2, 2, fakeViewport));
 255     fakeViewport.raiseEvent(STARTED, {});
 256     fakeViewport.setPluginPositionForTesting(2, 2);
 257     return result;
 258
 259   }).then(function() {
 260     // Start and end events raised, with correct scrolling.
 261     fakeViewport = new browserTest.FakeDesktopViewport;
 262     var result = that.verifyScroll(2, 2, fakeViewport);
 263     fakeViewport.raiseEvent(STARTED, {});
 264     fakeViewport.setPluginPositionForTesting(2, 2);
 265     fakeViewport.raiseEvent(STOPPED, {});
 266     return result;
 267   });
 268
 269   return result;
 270 };
 271
 272 /**
 273  * Verify that a bump scroll operation takes place and that the top-left corner
 274  * of the plugin is as expected when it completes.
 275  * @param {number|undefined} expectedTop The expected vertical position of the
 276  *    plugin, or undefined if it is not expected to change.
 277  * @param {number|undefined} expectedLeft The expected horizontal position of
 278  *    the plugin, or undefined if it is not expected to change.
 279  * @param {browserTest.FakeDesktopViewport=} opt_desktopViewport
 280  *     DesktopViewport fake, for testing.
 281  * @return {Promise}
 282  */
 283 browserTest.Bump_Scroll.prototype.verifyScroll =
 284     function (expectedTop, expectedLeft, opt_desktopViewport) {
 285   var desktopViewport = opt_desktopViewport || getViewportForTesting();
 286   base.debug.assert(desktopViewport != null);
 287   var STARTED = remoting.BumpScroller.Events.bumpScrollStarted;
 288   var STOPPED = remoting.BumpScroller.Events.bumpScrollStopped;
 289
 290   var initialPosition = desktopViewport.getPluginPositionForTesting();
 291   var initialTop = initialPosition.top;
 292   var initialLeft = initialPosition.left;
 293
 294   /** @return {Promise} */
 295   var verifyPluginPosition = function() {
 296     var position = desktopViewport.getPluginPositionForTesting();
 297     if (expectedLeft === undefined) {
 298       expectedLeft = initialLeft;
 299     }
 300     if (expectedTop === undefined) {
 301       expectedTop = initialTop;
 302     }
 303     if (position.top != expectedTop || position.left != expectedLeft) {
 304       return Promise.reject(
 305           new Error('No or incorrect scroll detected: (' +
 306                     position.left + ',' + position.top + ' instead of ' +
 307                     expectedLeft + ',' + expectedTop + ')'));
 308     } else {
 309       return Promise.resolve();
 310     }
 311   };
 312
 313   var bumpScroller = desktopViewport.getBumpScrollerForTesting();
 314   var started = browserTest.expectEvent(bumpScroller, STARTED, 1000);
 315   var stopped = browserTest.expectEvent(bumpScroller, STOPPED, 5000);
 316   return started.then(function() {
 317     return stopped;
 318   }, function() {
 319     // If no started event is raised, the test might still pass if it asserted
 320     // no scrolling.
 321     if (expectedTop === undefined && expectedLeft === undefined) {
 322       return Promise.resolve();
 323     } else {
 324       return Promise.reject(
 325           new Error('Scroll expected but no start event fired.'));
 326     }
 327   }).then(function() {
 328     return verifyPluginPosition();
 329   });
 330 };
 331
 332 /**
 333  * @param {browserTest.FakeDesktopViewport=} opt_desktopViewport
 334  *     DesktopViewport fake, for testing.
 335  *
 336  * @return {Promise<boolean>} A promise that resolves to true if no scrolling
 337  *   occurs within a timeout.
 338  */
 339 browserTest.Bump_Scroll.prototype.verifyNoScroll =
 340     function(opt_desktopViewport) {
 341   var desktopViewport = opt_desktopViewport || getViewportForTesting();
 342   var bumpScroller = desktopViewport.getBumpScrollerForTesting();
 343   if (!bumpScroller) {
 344     Promise.resolve(true);
 345   }
 346   return this.verifyScroll(undefined, undefined, desktopViewport);
 347 };