Implement bump-scroll browser-test.

Review URL: https://codereview.chromium.org/421433002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@288185 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 267 insertions, 1 deletions

diff --git a/remoting/webapp/browser_test/browser_test.js b/remoting/webapp/browser_test/browser_test.js
index 4785175..a35e57d 100644
--- a/remoting/webapp/browser_test/browser_test.js
+++ b/remoting/webapp/browser_test/browser_test.js
@@ -324,7 +324,7 @@ browserTest.ensureHostStartedWithPIN = function(pin) {
 browserTest.ensureRemoteConnectionEnabled = function(pin) {
   browserTest.ensureHostStartedWithPIN(pin).then(function(){
     browserTest.automationController_.send(true);
-  }).catch(function(errorMessage){
+  }, function(errorMessage){
     console.error(errorMessage);
     browserTest.automationController_.send(false);
   });
diff --git a/remoting/webapp/browser_test/bump_scroll_browser_test.js b/remoting/webapp/browser_test/bump_scroll_browser_test.js
new file mode 100644
index 0000000..cc94734
--- /dev/null
+++ b/remoting/webapp/browser_test/bump_scroll_browser_test.js
@@ -0,0 +1,266 @@
+// 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.
+
+/**
+ * @fileoverview
+ * @suppress {checkTypes}
+ * Browser test for the scenario below:
+ * 1. Enter full-screen mode
+ * 2. Move the mouse to each edge; verify that the desktop bump-scrolls.
+ */
+
+'use strict';
+
+/** @constructor */
+browserTest.FakeClientSession = function() {
+  this.pluginPosition = {
+    top: 0,
+    left: 0
+  };
+  this.defineEvents(Object.keys(remoting.ClientSession.Events));
+};
+
+base.extend(browserTest.FakeClientSession, base.EventSource);
+
+browserTest.FakeClientSession.prototype.getPluginPositionForTesting =
+    function() {
+  return this.pluginPosition;
+};
+
+
+/** @constructor */
+browserTest.Bump_Scroll = function() {
+  // To aviod dependencies on the actual host desktop size, we simulate a
+  // desktop larger or smaller than the client window. The exact value is
+  // arbitrary, but must be positive.
+  this.kHostDesktopSizeDelta = 10;
+};
+
+browserTest.Bump_Scroll.prototype.run = function(data) {
+  browserTest.expect(typeof data.pin == 'string');
+
+  if (!remoting.isAppsV2) {
+    browserTest.fail(
+        'Bump-scroll requires full-screen, which can only be activated ' +
+        'programmatically in apps v2.')
+  }
+
+  this.testVerifyScroll().then(function() {
+    return browserTest.connectMe2Me();
+  }).then(function() {
+    return browserTest.enterPIN(data.pin);
+  }).then(
+    this.noScrollWindowed.bind(this)
+  ).then(
+    this.activateFullscreen.bind(this)
+  ).then(
+    this.noScrollSmaller.bind(this)
+    // The order of these operations is important. Because the plugin starts
+    // scrolled to the top-left, it needs to be scrolled right and down first.
+  ).then(
+    this.scrollDirection.bind(this, 1.0, 0.5)  // Right edge
+  ).then(
+    this.scrollDirection.bind(this, 0.5, 1.0)  // Bottom edge
+  ).then(
+    this.scrollDirection.bind(this, 0.0, 0.5)  // Left edge
+  ).then(
+    this.scrollDirection.bind(this, 0.5, 0.0)  // Top edge
+  ).then(
+    function(value) {
+      browserTest.disconnect();
+      return browserTest.pass(value);
+    },
+    function(error) {
+      browserTest.disconnect();
+      return browserTest.fail(error);
+    }
+  );
+};
+
+browserTest.Bump_Scroll.prototype.noScrollWindowed = function() {
+  remoting.clientSession.pluginWidthForBumpScrollTesting =
+      window.innerWidth + this.kHostDesktopSizeDelta;
+  remoting.clientSession.pluginHeightForBumpScrollTesting =
+      window.innerHeight + this.kHostDesktopSizeDelta;
+  this.moveMouseTo(0, 0);
+  return this.verifyScroll(undefined, undefined);
+};
+
+browserTest.Bump_Scroll.prototype.noScrollSmaller = function() {
+  remoting.clientSession.pluginWidthForBumpScrollTesting =
+      window.innerWidth - this.kHostDesktopSizeDelta;
+  remoting.clientSession.pluginHeightForBumpScrollTesting =
+      window.innerHeight - this.kHostDesktopSizeDelta;
+  this.moveMouseTo(0, 0);
+  return this.verifyScroll(undefined, undefined);
+};
+
+browserTest.Bump_Scroll.prototype.scrollDirection =
+    function(widthFraction, heightFraction) {
+  remoting.clientSession.pluginWidthForBumpScrollTesting =
+      screen.width + this.kHostDesktopSizeDelta;
+  remoting.clientSession.pluginHeightForBumpScrollTesting =
+      screen.height + this.kHostDesktopSizeDelta;
+  var expectedTop = heightFraction == 0.0 ? 0 :
+                    heightFraction == 1.0 ? -this.kHostDesktopSizeDelta :
+                    undefined;
+  var expectedLeft = widthFraction == 0.0 ? 0 :
+                     widthFraction == 1.0 ? -this.kHostDesktopSizeDelta :
+                     undefined;
+  var result = this.verifyScroll(expectedTop, expectedLeft);
+  this.moveMouseTo(widthFraction * screen.width,
+                   heightFraction * screen.height);
+  return result;
+};
+
+browserTest.Bump_Scroll.prototype.activateFullscreen = function() {
+  return new Promise(function(fulfill, reject) {
+    remoting.fullscreen.activate(true, function() {
+      // The onFullscreen callback is invoked before the window has
+      // resized, so defer fulfilling the promise so that innerWidth
+      // and innerHeight are correct.
+      base.Promise.sleep(1000).then(fulfill);
+    });
+    base.Promise.sleep(5000).then(function(){
+      reject('Timed out waiting for full-screen');
+    });
+  });
+};
+
+browserTest.Bump_Scroll.prototype.moveMouseTo = function(x, y) {
+  var e = {
+    bubbles: true,
+    cancelable: false,
+    view: window,
+    detail: 0,
+    screenX: x,
+    screenY: y,
+    clientX: x,
+    clientY: y,
+    ctrlKey: false,
+    altKey: false,
+    shiftKey: false,
+    metaKey: false,
+    button: 0,
+    relatedTarget: undefined
+  };
+  var event = document.createEvent('MouseEvents');
+  event.initMouseEvent('mousemove',
+                       e.bubbles, e.cancelable, e.view, e.detail,
+                       e.screenX, e.screenY, e.clientX, e.clientY,
+                       e.ctrlKey, e.altKey, e.shiftKey, e.metaKey,
+                       e.button, document.documentElement);
+  document.documentElement.dispatchEvent(event);
+};
+
+// verifyScroll is complicated enough to warrant a test
+browserTest.Bump_Scroll.prototype.testVerifyScroll = function() {
+  var STARTED = remoting.ClientSession.Events.bumpScrollStarted;
+  var STOPPED = remoting.ClientSession.Events.bumpScrollStopped;
+  var fakeSession = new browserTest.FakeClientSession;
+  var that = this;
+
+  // No events raised (e.g. windowed mode).
+  var result = this.verifyScroll(undefined, undefined, fakeSession)
+
+  .then(function() {
+    // Start and end events raised, but no scrolling (e.g. full-screen mode
+    // with host desktop <= window size).
+    fakeSession = new browserTest.FakeClientSession;
+    var result = that.verifyScroll(undefined, undefined, fakeSession);
+    fakeSession.raiseEvent(STARTED, {});
+    fakeSession.raiseEvent(STOPPED, {});
+    return result;
+
+  }).then(function() {
+    // Start and end events raised, with incorrect scrolling.
+    fakeSession = new browserTest.FakeClientSession;
+    var result = base.Promise.negate(
+        that.verifyScroll(2, 2, fakeSession));
+    fakeSession.raiseEvent(STARTED, {});
+    fakeSession.pluginPosition.top = 1;
+    fakeSession.pluginPosition.left = 1;
+    fakeSession.raiseEvent(STOPPED, {});
+    return result;
+
+  }).then(function() {
+    // Start event raised, but not end event.
+    fakeSession = new browserTest.FakeClientSession;
+    var result = base.Promise.negate(
+        that.verifyScroll(2, 2, fakeSession));
+    fakeSession.raiseEvent(STARTED, {});
+    fakeSession.pluginPosition.top = 2;
+    fakeSession.pluginPosition.left = 2;
+    return result;
+
+  }).then(function() {
+    // Start and end events raised, with correct scrolling.
+    fakeSession = new browserTest.FakeClientSession;
+    var result = that.verifyScroll(2, 2, fakeSession);
+    fakeSession.raiseEvent(STARTED, {});
+    fakeSession.pluginPosition.top = 2;
+    fakeSession.pluginPosition.left = 2;
+    fakeSession.raiseEvent(STOPPED, {});
+    return result;
+  });
+
+  return result;
+};
+
+/**
+ * Verify that a bump scroll operation takes place and that the top-left corner
+ * of the plugin is as expected when it completes.
+ * @param {number|undefined} expectedTop The expected vertical position of the
+ *    plugin, or undefined if it is not expected to change.
+ * @param {number|undefined} expectedLeft The expected horizontal position of
+ *    the plugin, or undefined if it is not expected to change.
+ * @param {browserTest.FakeClientSession=} opt_clientSession ClientSession-like
+ *     fake, for testing.
+ */
+browserTest.Bump_Scroll.prototype.verifyScroll =
+    function (expectedTop, expectedLeft, opt_clientSession) {
+  var clientSession = opt_clientSession || remoting.clientSession;
+  base.debug.assert(clientSession != null);
+  var STARTED = remoting.ClientSession.Events.bumpScrollStarted;
+  var STOPPED = remoting.ClientSession.Events.bumpScrollStopped;
+
+  var initialPosition = clientSession.getPluginPositionForTesting();
+  var initialTop = initialPosition.top;
+  var initialLeft = initialPosition.left;
+
+  var verifyPluginPosition = function() {
+    var position = clientSession.getPluginPositionForTesting();
+    if (expectedLeft === undefined) {
+      expectedLeft = initialLeft;
+    }
+    if (expectedTop === undefined) {
+      expectedTop = initialTop;
+    }
+    if (position.top != expectedTop || position.left != expectedLeft) {
+      return Promise.reject(
+          new Error('No or incorrect scroll detected: (' +
+                    position.left + ',' + position.top + ' instead of ' +
+                    expectedLeft + ',' + expectedTop + ')'));
+    } else {
+      return Promise.resolve();
+    }
+  };
+
+  var started = browserTest.expectEvent(clientSession, STARTED, 1000);
+  var stopped = browserTest.expectEvent(clientSession, STOPPED, 5000);
+  return started.then(function() {
+    return stopped.then(function() {
+      return verifyPluginPosition();
+    });
+  }, function() {
+    // If no started event is raised, the test might still pass if it asserted
+    // no scrolling.
+    if (expectedTop == undefined && expectedLeft == undefined) {
+      return Promise.resolve();
+    } else {
+      return Promise.reject(
+          new Error('Scroll expected but no start event fired.'));
+    }
+  });
+};