src/android_webview/javatests/src/org/chromium/android_webview/test/AwLayoutSizerTest.java

   1 // Copyright 2012 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 package org.chromium.android_webview.test;
   6
   7 import android.test.InstrumentationTestCase;
   8 import android.test.suitebuilder.annotation.SmallTest;
   9 import android.view.View;
  10 import android.view.View.MeasureSpec;
  11
  12 import org.chromium.android_webview.AwLayoutSizer;
  13 import org.chromium.base.test.util.Feature;
  14
  15 /**
  16  * Unittests for the AwLayoutSizer class.
  17  */
  18 public class AwLayoutSizerTest extends InstrumentationTestCase {
  19     static class LayoutSizerDelegate implements AwLayoutSizer.Delegate {
  20         public int requestLayoutCallCount;
  21         public boolean setMeasuredDimensionCalled;
  22         public int measuredWidth;
  23         public int measuredHeight;
  24         public boolean forceZeroHeight;
  25         public boolean heightWrapContent;
  26
  27         @Override
  28         public void requestLayout() {
  29             requestLayoutCallCount++;
  30         }
  31
  32         @Override
  33         public void setMeasuredDimension(int measuredWidth, int measuredHeight) {
  34             setMeasuredDimensionCalled = true;
  35             this.measuredWidth = measuredWidth;
  36             this.measuredHeight = measuredHeight;
  37         }
  38
  39         @Override
  40         public void setForceZeroLayoutHeight(boolean forceZeroHeight) {
  41             this.forceZeroHeight = forceZeroHeight;
  42         }
  43
  44         @Override
  45         public boolean isLayoutParamsHeightWrapContent() {
  46             return heightWrapContent;
  47         }
  48     }
  49
  50     private static final int FIRST_CONTENT_WIDTH = 101;
  51     private static final int FIRST_CONTENT_HEIGHT = 389;
  52     private static final int SECOND_CONTENT_WIDTH = 103;
  53     private static final int SECOND_CONTENT_HEIGHT = 397;
  54
  55     private static final int SMALLER_CONTENT_SIZE = 25;
  56     private static final int AT_MOST_MEASURE_SIZE = 50;
  57     private static final int TOO_LARGE_CONTENT_SIZE = 100;
  58
  59     private static final float INITIAL_PAGE_SCALE = 1.0f;
  60     private static final double DIP_SCALE = 1.0;
  61
  62     @SmallTest
  63     @Feature({"AndroidWebView"})
  64     public void testCanQueryContentSize() {
  65         AwLayoutSizer layoutSizer = new AwLayoutSizer();
  66         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
  67         layoutSizer.setDelegate(delegate);
  68         layoutSizer.setDIPScale(DIP_SCALE);
  69
  70         final int contentWidth = 101;
  71         final int contentHeight = 389;
  72
  73         layoutSizer.onContentSizeChanged(contentWidth, contentHeight);
  74         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
  75         layoutSizer.onMeasure(MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
  76                 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
  77
  78         assertTrue(delegate.setMeasuredDimensionCalled);
  79         assertEquals(contentWidth, delegate.measuredWidth & View.MEASURED_SIZE_MASK);
  80         assertEquals(contentHeight, delegate.measuredHeight & View.MEASURED_SIZE_MASK);
  81     }
  82
  83     @SmallTest
  84     @Feature({"AndroidWebView"})
  85     public void testContentSizeChangeRequestsLayout() {
  86         AwLayoutSizer layoutSizer = new AwLayoutSizer();
  87         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
  88         layoutSizer.setDelegate(delegate);
  89         layoutSizer.setDIPScale(DIP_SCALE);
  90
  91         layoutSizer.onContentSizeChanged(FIRST_CONTENT_WIDTH, FIRST_CONTENT_HEIGHT);
  92         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
  93         final int requestLayoutCallCount = delegate.requestLayoutCallCount;
  94         layoutSizer.onContentSizeChanged(SECOND_CONTENT_WIDTH, SECOND_CONTENT_WIDTH);
  95
  96         assertEquals(requestLayoutCallCount + 1, delegate.requestLayoutCallCount);
  97     }
  98
  99     @SmallTest
 100     @Feature({"AndroidWebView"})
 101     public void testContentSizeChangeDoesNotRequestLayoutIfMeasuredExcatly() {
 102         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 103         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 104         layoutSizer.setDelegate(delegate);
 105         layoutSizer.setDIPScale(DIP_SCALE);
 106
 107         layoutSizer.onContentSizeChanged(FIRST_CONTENT_WIDTH, FIRST_CONTENT_HEIGHT);
 108         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 109         layoutSizer.onMeasure(MeasureSpec.makeMeasureSpec(50, MeasureSpec.EXACTLY),
 110                 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
 111         final int requestLayoutCallCount = delegate.requestLayoutCallCount;
 112         layoutSizer.onContentSizeChanged(SECOND_CONTENT_WIDTH, FIRST_CONTENT_HEIGHT);
 113
 114         assertEquals(requestLayoutCallCount, delegate.requestLayoutCallCount);
 115     }
 116
 117     @SmallTest
 118     @Feature({"AndroidWebView"})
 119     public void testDuplicateContentSizeChangeDoesNotRequestLayout() {
 120         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 121         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 122         layoutSizer.setDelegate(delegate);
 123         layoutSizer.setDIPScale(DIP_SCALE);
 124
 125         layoutSizer.onContentSizeChanged(FIRST_CONTENT_WIDTH, FIRST_CONTENT_HEIGHT);
 126         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 127         layoutSizer.onMeasure(MeasureSpec.makeMeasureSpec(50, MeasureSpec.EXACTLY),
 128                 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
 129         final int requestLayoutCallCount = delegate.requestLayoutCallCount;
 130         layoutSizer.onContentSizeChanged(FIRST_CONTENT_WIDTH, FIRST_CONTENT_HEIGHT);
 131
 132         assertEquals(requestLayoutCallCount, delegate.requestLayoutCallCount);
 133     }
 134
 135     @SmallTest
 136     @Feature({"AndroidWebView"})
 137     public void testContentHeightGrowsTillAtMostSize() {
 138         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 139         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 140         layoutSizer.setDelegate(delegate);
 141         layoutSizer.setDIPScale(DIP_SCALE);
 142
 143         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 144         layoutSizer.onContentSizeChanged(SMALLER_CONTENT_SIZE, SMALLER_CONTENT_SIZE);
 145         layoutSizer.onMeasure(
 146                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST),
 147                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST));
 148         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredWidth);
 149         assertEquals(SMALLER_CONTENT_SIZE, delegate.measuredHeight);
 150
 151         layoutSizer.onContentSizeChanged(TOO_LARGE_CONTENT_SIZE, TOO_LARGE_CONTENT_SIZE);
 152         layoutSizer.onMeasure(
 153                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST),
 154                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST));
 155         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredWidth & View.MEASURED_SIZE_MASK);
 156         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredHeight & View.MEASURED_SIZE_MASK);
 157     }
 158
 159     @SmallTest
 160     @Feature({"AndroidWebView"})
 161     public void testContentHeightGrowthRequestsLayoutInAtMostSizeMode() {
 162         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 163         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 164         layoutSizer.setDelegate(delegate);
 165         layoutSizer.setDIPScale(DIP_SCALE);
 166
 167         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 168         layoutSizer.onContentSizeChanged(SMALLER_CONTENT_SIZE, SMALLER_CONTENT_SIZE);
 169         layoutSizer.onMeasure(
 170                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST),
 171                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST));
 172         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredWidth);
 173         assertEquals(SMALLER_CONTENT_SIZE, delegate.measuredHeight);
 174
 175         int requestLayoutCallCount = delegate.requestLayoutCallCount;
 176         layoutSizer.onContentSizeChanged(SMALLER_CONTENT_SIZE, AT_MOST_MEASURE_SIZE - 1);
 177         assertEquals(requestLayoutCallCount + 1, delegate.requestLayoutCallCount);
 178
 179         // Test that crossing the AT_MOST_MEASURE_SIZE threshold results in a requestLayout.
 180         requestLayoutCallCount = delegate.requestLayoutCallCount;
 181         layoutSizer.onContentSizeChanged(SMALLER_CONTENT_SIZE, AT_MOST_MEASURE_SIZE + 1);
 182         assertEquals(requestLayoutCallCount + 1, delegate.requestLayoutCallCount);
 183     }
 184
 185     @SmallTest
 186     @Feature({"AndroidWebView"})
 187     public void testContentHeightShrinksAfterAtMostSize() {
 188         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 189         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 190         layoutSizer.setDelegate(delegate);
 191         layoutSizer.setDIPScale(DIP_SCALE);
 192
 193         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 194         layoutSizer.onContentSizeChanged(SMALLER_CONTENT_SIZE, SMALLER_CONTENT_SIZE);
 195         layoutSizer.onMeasure(
 196                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST),
 197                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST));
 198         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredWidth);
 199         assertEquals(SMALLER_CONTENT_SIZE, delegate.measuredHeight);
 200
 201         layoutSizer.onContentSizeChanged(TOO_LARGE_CONTENT_SIZE, TOO_LARGE_CONTENT_SIZE);
 202         layoutSizer.onMeasure(
 203                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST),
 204                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST));
 205         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredWidth & View.MEASURED_SIZE_MASK);
 206         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredHeight & View.MEASURED_SIZE_MASK);
 207
 208         int requestLayoutCallCount = delegate.requestLayoutCallCount;
 209         layoutSizer.onContentSizeChanged(TOO_LARGE_CONTENT_SIZE, TOO_LARGE_CONTENT_SIZE + 1);
 210         layoutSizer.onContentSizeChanged(TOO_LARGE_CONTENT_SIZE, TOO_LARGE_CONTENT_SIZE);
 211         assertEquals(requestLayoutCallCount, delegate.requestLayoutCallCount);
 212
 213         requestLayoutCallCount = delegate.requestLayoutCallCount;
 214         layoutSizer.onContentSizeChanged(SMALLER_CONTENT_SIZE, SMALLER_CONTENT_SIZE);
 215         assertEquals(requestLayoutCallCount + 1, delegate.requestLayoutCallCount);
 216         layoutSizer.onMeasure(
 217                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST),
 218                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST));
 219         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredWidth);
 220         assertEquals(SMALLER_CONTENT_SIZE, delegate.measuredHeight);
 221     }
 222
 223     @SmallTest
 224     @Feature({"AndroidWebView"})
 225     public void testScaleChangeRequestsLayout() {
 226         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 227         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 228         layoutSizer.setDelegate(delegate);
 229         layoutSizer.setDIPScale(DIP_SCALE);
 230
 231         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 232         layoutSizer.onContentSizeChanged(FIRST_CONTENT_WIDTH, FIRST_CONTENT_HEIGHT);
 233         layoutSizer.onMeasure(
 234                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.EXACTLY),
 235                 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
 236         final int requestLayoutCallCount = delegate.requestLayoutCallCount;
 237         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE + 0.5f);
 238
 239         assertEquals(requestLayoutCallCount + 1, delegate.requestLayoutCallCount);
 240     }
 241
 242     @SmallTest
 243     @Feature({"AndroidWebView"})
 244     public void testDuplicateScaleChangeDoesNotRequestLayout() {
 245         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 246         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 247         layoutSizer.setDelegate(delegate);
 248         layoutSizer.setDIPScale(DIP_SCALE);
 249
 250         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 251         layoutSizer.onContentSizeChanged(FIRST_CONTENT_WIDTH, FIRST_CONTENT_HEIGHT);
 252         layoutSizer.onMeasure(MeasureSpec.makeMeasureSpec(50, MeasureSpec.EXACTLY),
 253                 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
 254         final int requestLayoutCallCount = delegate.requestLayoutCallCount;
 255         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 256
 257         assertEquals(requestLayoutCallCount, delegate.requestLayoutCallCount);
 258     }
 259
 260     @SmallTest
 261     @Feature({"AndroidWebView"})
 262     public void testScaleChangeGrowsTillAtMostSize() {
 263         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 264         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 265         layoutSizer.setDelegate(delegate);
 266         layoutSizer.setDIPScale(DIP_SCALE);
 267
 268         final float tooLargePageScale = 3.00f;
 269
 270         layoutSizer.onContentSizeChanged(SMALLER_CONTENT_SIZE, SMALLER_CONTENT_SIZE);
 271         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 272         layoutSizer.onMeasure(
 273                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST),
 274                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST));
 275         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredWidth);
 276         assertEquals(SMALLER_CONTENT_SIZE, delegate.measuredHeight);
 277
 278         layoutSizer.onPageScaleChanged(tooLargePageScale);
 279         layoutSizer.onMeasure(
 280                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST),
 281                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST));
 282         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredWidth & View.MEASURED_SIZE_MASK);
 283         assertEquals(AT_MOST_MEASURE_SIZE, delegate.measuredHeight & View.MEASURED_SIZE_MASK);
 284     }
 285
 286     @SmallTest
 287     @Feature({"AndroidWebView"})
 288     public void testFreezeAndUnfreezeDoesntCauseLayout() {
 289         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 290         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 291         layoutSizer.setDelegate(delegate);
 292         layoutSizer.setDIPScale(DIP_SCALE);
 293
 294         final int requestLayoutCallCount = delegate.requestLayoutCallCount;
 295         layoutSizer.freezeLayoutRequests();
 296         layoutSizer.unfreezeLayoutRequests();
 297         assertEquals(requestLayoutCallCount, delegate.requestLayoutCallCount);
 298     }
 299
 300     @SmallTest
 301     @Feature({"AndroidWebView"})
 302     public void testFreezeInhibitsLayoutRequest() {
 303         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 304         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 305         layoutSizer.setDelegate(delegate);
 306         layoutSizer.setDIPScale(DIP_SCALE);
 307
 308         layoutSizer.freezeLayoutRequests();
 309         layoutSizer.onContentSizeChanged(FIRST_CONTENT_WIDTH, FIRST_CONTENT_HEIGHT);
 310         final int requestLayoutCallCount = delegate.requestLayoutCallCount;
 311         layoutSizer.onContentSizeChanged(SECOND_CONTENT_WIDTH, SECOND_CONTENT_WIDTH);
 312         assertEquals(requestLayoutCallCount, delegate.requestLayoutCallCount);
 313     }
 314
 315     @SmallTest
 316     @Feature({"AndroidWebView"})
 317     public void testUnfreezeIssuesLayoutRequest() {
 318         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 319         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 320         layoutSizer.setDelegate(delegate);
 321         layoutSizer.setDIPScale(DIP_SCALE);
 322
 323         layoutSizer.freezeLayoutRequests();
 324         layoutSizer.onContentSizeChanged(FIRST_CONTENT_WIDTH, FIRST_CONTENT_HEIGHT);
 325         final int requestLayoutCallCount = delegate.requestLayoutCallCount;
 326         layoutSizer.onContentSizeChanged(SECOND_CONTENT_WIDTH, SECOND_CONTENT_WIDTH);
 327         assertEquals(requestLayoutCallCount, delegate.requestLayoutCallCount);
 328         layoutSizer.unfreezeLayoutRequests();
 329         assertEquals(requestLayoutCallCount + 1, delegate.requestLayoutCallCount);
 330     }
 331
 332     @SmallTest
 333     @Feature({"AndroidWebView"})
 334     public void testViewportWithExactMeasureSpec() {
 335         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 336         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 337         layoutSizer.setDelegate(delegate);
 338
 339         final float dipScale = 2.0f;
 340         final int measuredWidth = 800;
 341         final int measuredHeight = 400;
 342
 343         layoutSizer.setDIPScale(dipScale);
 344
 345         layoutSizer.onContentSizeChanged(FIRST_CONTENT_WIDTH, FIRST_CONTENT_HEIGHT);
 346         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 347         layoutSizer.onMeasure(MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY),
 348                 MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY));
 349         assertEquals(measuredWidth, delegate.measuredWidth & View.MEASURED_SIZE_MASK);
 350         assertEquals(measuredHeight, delegate.measuredHeight & View.MEASURED_SIZE_MASK);
 351     }
 352
 353     @SmallTest
 354     @Feature({"AndroidWebView"})
 355     public void testViewportDipSizeOverrideRounding() {
 356         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 357         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 358         layoutSizer.setDelegate(delegate);
 359
 360         final float dipScale = 0.666f;
 361
 362         int contentWidth = 9;
 363         int contentHeight = 6;
 364
 365         layoutSizer.setDIPScale(dipScale);
 366         layoutSizer.onContentSizeChanged(contentWidth, contentHeight);
 367         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 368         layoutSizer.onMeasure(MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
 369                 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
 370
 371         assertTrue(delegate.setMeasuredDimensionCalled);
 372         int measuredWidth = delegate.measuredWidth & View.MEASURED_SIZE_MASK;
 373         int measuredHeight = delegate.measuredHeight & View.MEASURED_SIZE_MASK;
 374         assertFalse((int) Math.ceil(measuredWidth / dipScale) == contentWidth);
 375         assertFalse((int) Math.ceil(measuredHeight / dipScale) == contentHeight);
 376
 377         layoutSizer.onSizeChanged(measuredWidth, measuredHeight, 0, 0);
 378     }
 379
 380     @SmallTest
 381     @Feature({"AndroidWebView"})
 382     public void testViewportWithAtMostMeasureSpec() {
 383         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 384         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 385         delegate.heightWrapContent = true;
 386         layoutSizer.setDelegate(delegate);
 387
 388         final float dipScale = 1.5f;
 389         final int pageScale = 2;
 390         final int dipAndPageScale = (int) (dipScale * pageScale);
 391
 392         int contentWidth = 800;
 393         int contentHeight = 400;
 394         int contentWidthPix = contentWidth * dipAndPageScale;
 395         int contentHeightPix = contentHeight * dipAndPageScale;
 396
 397         assertFalse(delegate.forceZeroHeight);
 398
 399         layoutSizer.setDIPScale(dipScale);
 400         layoutSizer.onContentSizeChanged(contentWidth, contentHeight);
 401         layoutSizer.onPageScaleChanged(pageScale);
 402         layoutSizer.onMeasure(MeasureSpec.makeMeasureSpec(contentWidthPix, MeasureSpec.EXACTLY),
 403                 MeasureSpec.makeMeasureSpec(contentHeightPix * 2, MeasureSpec.AT_MOST));
 404
 405         assertTrue(delegate.setMeasuredDimensionCalled);
 406         assertFalse(delegate.forceZeroHeight);
 407
 408         int measuredWidth = delegate.measuredWidth & View.MEASURED_SIZE_MASK;
 409         int measuredHeight = delegate.measuredHeight & View.MEASURED_SIZE_MASK;
 410         layoutSizer.onSizeChanged(measuredWidth, measuredHeight, 0, 0);
 411
 412         assertTrue(delegate.forceZeroHeight);
 413     }
 414
 415     @SmallTest
 416     @Feature({"AndroidWebView"})
 417     public void testFixedLayoutSizeDependsOnHeightWrapContent() {
 418         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 419         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 420         delegate.heightWrapContent = false;
 421         layoutSizer.setDelegate(delegate);
 422         layoutSizer.setDIPScale(DIP_SCALE);
 423
 424         layoutSizer.onContentSizeChanged(TOO_LARGE_CONTENT_SIZE, TOO_LARGE_CONTENT_SIZE);
 425         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 426         layoutSizer.onMeasure(
 427                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST),
 428                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST));
 429         layoutSizer.onSizeChanged(AT_MOST_MEASURE_SIZE, AT_MOST_MEASURE_SIZE, 0, 0);
 430
 431         assertFalse(delegate.forceZeroHeight);
 432
 433         delegate.heightWrapContent = true;
 434         layoutSizer.onSizeChanged(AT_MOST_MEASURE_SIZE, AT_MOST_MEASURE_SIZE, 0, 0);
 435
 436         assertTrue(delegate.forceZeroHeight);
 437     }
 438
 439     @SmallTest
 440     @Feature({"AndroidWebView"})
 441     public void testFixedLayoutSizeDoesNotDependOnMeasureSpec() {
 442         AwLayoutSizer layoutSizer = new AwLayoutSizer();
 443         LayoutSizerDelegate delegate = new LayoutSizerDelegate();
 444         delegate.heightWrapContent = false;
 445         layoutSizer.setDelegate(delegate);
 446         layoutSizer.setDIPScale(DIP_SCALE);
 447
 448         layoutSizer.onContentSizeChanged(TOO_LARGE_CONTENT_SIZE, TOO_LARGE_CONTENT_SIZE);
 449         layoutSizer.onPageScaleChanged(INITIAL_PAGE_SCALE);
 450         layoutSizer.onMeasure(
 451                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST),
 452                 MeasureSpec.makeMeasureSpec(AT_MOST_MEASURE_SIZE, MeasureSpec.AT_MOST));
 453         layoutSizer.onSizeChanged(AT_MOST_MEASURE_SIZE, AT_MOST_MEASURE_SIZE, 0, 0);
 454
 455         assertFalse(delegate.forceZeroHeight);
 456
 457         layoutSizer.onMeasure(
 458                 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
 459                 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
 460         layoutSizer.onSizeChanged(AT_MOST_MEASURE_SIZE, AT_MOST_MEASURE_SIZE, 0, 0);
 461         assertFalse(delegate.forceZeroHeight);
 462     }
 463 }