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
5package org.chromium.android_webview.test;
6
7import android.test.InstrumentationTestCase;
8import android.test.suitebuilder.annotation.SmallTest;
9import android.view.View;
10import android.view.View.MeasureSpec;
11
12import org.chromium.android_webview.AwLayoutSizer;
13import org.chromium.base.test.util.Feature;
14
15/**
16 * Unittests for the AwLayoutSizer class.
17 */
18public 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}
464