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

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