Create windows for new app window bounds API

chrome/test/data/extensions/platform_apps/window_api/test.js

 // Copyright 2013 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.
 
 var callbackPass = chrome.test.callbackPass;
 var callbackFail = chrome.test.callbackFail;
 var defaultFuzzFactor = 1;
 
 function assertFuzzyEq(expected, actual, fuzzFactor, message) {
   if (!message) {
@@ skipping 31 matching lines @@
     callback(win);
     return;
   }
 
   window.addEventListener('load', callbackPass(function() {
     window.removeEventListener('load', arguments.callee);
     callback(win);
   }));
 }
 
+function assertConstraintsUnspecified(win) {
+  chrome.test.assertEq(null, win.innerBounds.minWidth);
+  chrome.test.assertEq(null, win.innerBounds.minHeight);
+  chrome.test.assertEq(null, win.innerBounds.maxWidth);
+  chrome.test.assertEq(null, win.innerBounds.maxHeight);
+  chrome.test.assertEq(null, win.outerBounds.minWidth);
+  chrome.test.assertEq(null, win.outerBounds.minHeight);
+  chrome.test.assertEq(null, win.outerBounds.maxWidth);
+  chrome.test.assertEq(null, win.outerBounds.maxHeight);
+}
+
+function assertBoundsConsistent(win) {
+  chrome.test.assertTrue(win.innerBounds.left >= win.outerBounds.left);
+  chrome.test.assertTrue(win.innerBounds.top >= win.outerBounds.top);
+  chrome.test.assertTrue(win.innerBounds.width <= win.outerBounds.width);
+  chrome.test.assertTrue(win.innerBounds.height <= win.outerBounds.height);
+
+  if (win.innerBounds.minWidth === null)
+    chrome.test.assertEq(null, win.outerBounds.minWidth);
+  else
+    chrome.test.assertTrue(
+        win.innerBounds.minWidth <= win.outerBounds.minWidth);
+
+  if (win.innerBounds.minHeight === null)
+    chrome.test.assertEq(null, win.outerBounds.minHeight);
+  else
+    chrome.test.assertTrue(
+        win.innerBounds.minHeight <= win.outerBounds.minHeight);
+
+  if (win.innerBounds.maxWidth === null)
+    chrome.test.assertEq(null, win.outerBounds.maxWidth);
+  else
+    chrome.test.assertTrue(
+        win.innerBounds.maxWidth <= win.outerBounds.maxWidth);
+
+  if (win.innerBounds.maxHeight === null)
+    chrome.test.assertEq(null, win.outerBounds.maxHeight);
+  else
+    chrome.test.assertTrue(
+        win.innerBounds.maxHeight <= win.outerBounds.maxHeight);
+}
+
+function testConflictingBoundsProperty(propertyName) {
+  var innerBounds = {};
+  var outerBounds = {};
+  innerBounds[propertyName] = 20;
+  outerBounds[propertyName] = 20;
+  chrome.app.window.create('test.html', {
+    innerBounds: innerBounds,
+    outerBounds: outerBounds
+  }, callbackFail('The ' + propertyName + ' property cannot be specified for ' +
+                  'both inner and outer bounds.')
+  );
+}
+
 function testCreate() {
   chrome.test.runTests([
     function basic() {
       chrome.app.window.create('test.html',
                                {id: 'testId'},
                                callbackPass(function(win) {
         chrome.test.assertEq(typeof win.contentWindow.window, 'object');
         chrome.test.assertTrue(
           typeof win.contentWindow.document !== 'undefined');
         chrome.test.assertFalse(
@@ skipping 84 matching lines @@
       }, callbackPass(function(win) {
         var w = win.contentWindow;
         assertFuzzyEq(400, w.innerWidth, defaultFuzzFactor);
         assertFuzzyEq(450, w.innerHeight, defaultFuzzFactor);
         w.close();
       }));
     }
   ]);
 }
 
+function testInitialBounds() {
+  chrome.test.runTests([
+    function testNoOptions() {
+      chrome.app.window.create('test.html', {
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertTrue(win.innerBounds.width > 0);
+        chrome.test.assertTrue(win.innerBounds.height > 0);
+        chrome.test.assertTrue(win.outerBounds.width > 0);
+        chrome.test.assertTrue(win.outerBounds.height > 0);
+        assertConstraintsUnspecified(win);
+        assertBoundsConsistent(win);
+        win.close();
+      }));
+    },
+    function testInnerBoundsOnly() {
+      var innerBounds = {
+        left: 150,
+        top: 100,
+        width: 400,
+        height: 300
+      };
+      chrome.app.window.create('test.html', {
+        innerBounds: innerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(innerBounds.left, win.innerBounds.left);
+        chrome.test.assertEq(innerBounds.top, win.innerBounds.top);
+        chrome.test.assertEq(innerBounds.width, win.innerBounds.width);
+        chrome.test.assertEq(innerBounds.height, win.innerBounds.height);
+        assertBoundsConsistent(win);
+        assertConstraintsUnspecified(win);
+        win.close();
+      }));
+    },
+    function testOuterBoundsOnly() {
+      var outerBounds = {
+        left: 150,
+        top: 100,
+        width: 400,
+        height: 300
+      };
+      chrome.app.window.create('test.html', {
+        outerBounds: outerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(outerBounds.left, win.outerBounds.left);
+        chrome.test.assertEq(outerBounds.top, win.outerBounds.top);
+        chrome.test.assertEq(outerBounds.width, win.outerBounds.width);
+        chrome.test.assertEq(outerBounds.height, win.outerBounds.height);
+        assertBoundsConsistent(win);
+        assertConstraintsUnspecified(win);
+        win.close();
+      }));
+    },
+    function testFrameless() {
+      var outerBounds = {
+        left: 150,
+        top: 100,
+        width: 400,
+        height: 300
+      };
+      chrome.app.window.create('test.html', {
+        outerBounds: outerBounds,
+        frame: 'none'
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(outerBounds.left, win.outerBounds.left);
+        chrome.test.assertEq(outerBounds.top, win.outerBounds.top);
+        chrome.test.assertEq(outerBounds.width, win.outerBounds.width);
+        chrome.test.assertEq(outerBounds.height, win.outerBounds.height);
+        chrome.test.assertEq(outerBounds.left, win.innerBounds.left);
+        chrome.test.assertEq(outerBounds.top, win.innerBounds.top);
+        chrome.test.assertEq(outerBounds.width, win.innerBounds.width);
+        chrome.test.assertEq(outerBounds.height, win.innerBounds.height);
+        assertConstraintsUnspecified(win);
+        win.close();
+      }));
+    },
+    function testInnerSizeAndOuterPos() {
+      var innerBounds = {
+        width: 400,
+        height: 300
+      };
+      var outerBounds = {
+        left: 150,
+        top: 100
+      };
+      chrome.app.window.create('test.html', {
+        innerBounds: innerBounds,
+        outerBounds: outerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(outerBounds.left, win.outerBounds.left);
+        chrome.test.assertEq(outerBounds.top, win.outerBounds.top);
+        chrome.test.assertEq(innerBounds.width, win.innerBounds.width);
+        chrome.test.assertEq(innerBounds.height, win.innerBounds.height);
+        assertBoundsConsistent(win);
+        assertConstraintsUnspecified(win);
+        win.close();
+      }));
+    },
+    function testInnerAndOuterBoundsEdgeCase() {
+      var innerBounds = {
+        left: 150,
+        height: 300
+      };
+      var outerBounds = {
+        width: 400,
+        top: 100
+      };
+      chrome.app.window.create('test.html', {
+        innerBounds: innerBounds,
+        outerBounds: outerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(innerBounds.left, win.innerBounds.left);
+        chrome.test.assertEq(innerBounds.height, win.innerBounds.height);
+        chrome.test.assertEq(outerBounds.top, win.outerBounds.top);
+        chrome.test.assertEq(outerBounds.width, win.outerBounds.width);
+        assertBoundsConsistent(win);
+        assertConstraintsUnspecified(win);
+        win.close();
+      }));
+    },
+    function testPositionOnly() {
+      var outerBounds = {
+        left: 150,
+        top: 100
+      };
+      chrome.app.window.create('test.html', {
+        outerBounds: outerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(outerBounds.left, win.outerBounds.left);
+        chrome.test.assertEq(outerBounds.top, win.outerBounds.top);
+        chrome.test.assertTrue(win.innerBounds.width > 0);
+        chrome.test.assertTrue(win.innerBounds.height > 0);
+        chrome.test.assertTrue(win.outerBounds.width > 0);
+        chrome.test.assertTrue(win.outerBounds.height > 0);
+        assertBoundsConsistent(win);
+        assertConstraintsUnspecified(win);
+        win.close();
+      }));
+    },
+    function testSizeOnly() {
+      var outerBounds = {
+        width: 500,
+        height: 400
+      };
+      chrome.app.window.create('test.html', {
+        outerBounds: outerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(outerBounds.width, win.outerBounds.width);
+        chrome.test.assertEq(outerBounds.height, win.outerBounds.height);
+        assertBoundsConsistent(win);
+        assertConstraintsUnspecified(win);
+        win.close();
+      }));
+    },
+    function testConflictingProperties() {
+      testConflictingBoundsProperty("width");
+      testConflictingBoundsProperty("height");
+      testConflictingBoundsProperty("left");
+      testConflictingBoundsProperty("top");
+      testConflictingBoundsProperty("minWidth");
+      testConflictingBoundsProperty("minHeight");
+      testConflictingBoundsProperty("maxWidth");
+      testConflictingBoundsProperty("maxHeight");
+    }
+  ]);
+}
+
+function testInitialBoundsInStable() {
+  chrome.test.runTests([
+    function testInnerBounds() {
+      var innerBounds = {
+        width: 600,
+        height: 400
+      };
+      chrome.app.window.create('test.html', {
+        innerBounds: innerBounds
+      }, callbackFail('innerBounds and outerBounds are only available in'+
+                      ' dev channel.')
+      );
+    },
+    function testOuterBounds() {
+      var outerBounds = {
+        width: 600,
+        height: 400
+      };
+      chrome.app.window.create('test.html', {
+        outerBounds: outerBounds
+      }, callbackFail('innerBounds and outerBounds are only available in'+
+                      ' dev channel.')
+      );
+    }
+  ]);
+}
+
+function testInitialConstraints() {
+  chrome.test.runTests([
+    function testMaxInnerConstraints() {
+      var innerBounds = {
+        width: 800,
+        height: 600,
+        maxWidth: 500,
+        maxHeight: 400
+      };
+      chrome.app.window.create('test.html', {
+        innerBounds: innerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(innerBounds.maxWidth, win.innerBounds.width);
+        chrome.test.assertEq(innerBounds.maxHeight, win.innerBounds.height);
+        chrome.test.assertEq(innerBounds.maxWidth, win.innerBounds.maxWidth);
+        chrome.test.assertEq(innerBounds.maxHeight, win.innerBounds.maxHeight);
+        assertBoundsConsistent(win);
+        win.close();
+      }));
+    },
+    function testMinInnerConstraints() {
+      var innerBounds = {
+        width: 100,
+        height: 100,
+        minWidth: 300,
+        minHeight: 200
+      };
+      chrome.app.window.create('test.html', {
+        innerBounds: innerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(innerBounds.minWidth, win.innerBounds.width);
+        chrome.test.assertEq(innerBounds.minHeight, win.innerBounds.height);
+        chrome.test.assertEq(innerBounds.minWidth, win.innerBounds.minWidth);
+        chrome.test.assertEq(innerBounds.minHeight, win.innerBounds.minHeight);
+        assertBoundsConsistent(win);
+        win.close();
+      }));
+    },
+    function testMaxOuterConstraints() {
+      var outerBounds = {
+        width: 800,
+        height: 600,
+        maxWidth: 500,
+        maxHeight: 400
+      };
+      chrome.app.window.create('test.html', {
+        outerBounds: outerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(outerBounds.maxWidth, win.outerBounds.width);
+        chrome.test.assertEq(outerBounds.maxHeight, win.outerBounds.height);
+        chrome.test.assertEq(outerBounds.maxWidth, win.outerBounds.maxWidth);
+        chrome.test.assertEq(outerBounds.maxHeight, win.outerBounds.maxHeight);
+        assertBoundsConsistent(win);
+        win.close();
+      }));
+    },
+    function testMinOuterConstraints() {
+      var outerBounds = {
+        width: 100,
+        height: 100,
+        minWidth: 300,
+        minHeight: 200
+      };
+      chrome.app.window.create('test.html', {
+        outerBounds: outerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(outerBounds.minWidth, win.outerBounds.width);
+        chrome.test.assertEq(outerBounds.minHeight, win.outerBounds.height);
+        chrome.test.assertEq(outerBounds.minWidth, win.outerBounds.minWidth);
+        chrome.test.assertEq(outerBounds.minHeight, win.outerBounds.minHeight);
+        assertBoundsConsistent(win);
+        win.close();
+      }));
+    },
+    function testMixedConstraints() {
+      var innerBounds = {
+        width: 100,
+        minHeight: 300
+      };
+      var outerBounds = {
+        height: 100,
+        minWidth: 400,
+      };
+      chrome.app.window.create('test.html', {
+        innerBounds: innerBounds,
+        outerBounds: outerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(outerBounds.minWidth, win.outerBounds.width);
+        chrome.test.assertEq(innerBounds.minHeight, win.innerBounds.height);
+        chrome.test.assertEq(outerBounds.minWidth, win.outerBounds.minWidth);
+        chrome.test.assertEq(innerBounds.minHeight, win.innerBounds.minHeight);
+        assertBoundsConsistent(win);
+        win.close();
+      }));
+    },
+    function testBadConstraints() {
+      var outerBounds = {
+        width: 500,
+        height: 400,
+        minWidth: 800,
+        minHeight: 700,
+        maxWidth: 300,
+        maxHeight: 200
+      };
+      chrome.app.window.create('test.html', {
+        outerBounds: outerBounds
+      }, callbackPass(function(win) {
+        chrome.test.assertTrue(win != null);
+        chrome.test.assertEq(outerBounds.minWidth, win.outerBounds.width);
+        chrome.test.assertEq(outerBounds.minHeight, win.outerBounds.height);
+        chrome.test.assertEq(outerBounds.minWidth, win.outerBounds.minWidth);
+        chrome.test.assertEq(outerBounds.minHeight, win.outerBounds.minHeight);
+        chrome.test.assertEq(outerBounds.minWidth, win.outerBounds.maxWidth);
+        chrome.test.assertEq(outerBounds.minHeight, win.outerBounds.maxHeight);
+        assertBoundsConsistent(win);
+        win.close();
+      }));
+    },
+  ]);
+}
+

[benwells, 2014/03/05 02:33:30]

These tests are awesome, hopefully they won't suffer from the flakiness plaguing
the other chrome.app.window tests...

 function testSingleton() {
   chrome.test.runTests([
     function noParameterWithId() {
       chrome.app.window.create(
         'test.html', { id: 'singleton-id' },
         callbackPass(function(win) {
           var w = win.contentWindow;
 
           chrome.app.window.create(
             'test.html', { id: 'singleton-id' },
@@ skipping 503 matching lines @@
       callbackFail('frameOptions is only available in dev channel.'));
     }
   ]);
 }
 
 chrome.app.runtime.onLaunched.addListener(function() {
   chrome.test.sendMessage('Launched', function(reply) {
     window[reply]();
   });
 });