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