scrollbar_layer_unittest.cc revision 2a99a7e74a7f215066514fe81d2bfa6639d9eddd 
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#include "cc/layers/scrollbar_layer.h"
6
7#include "cc/animation/scrollbar_animation_controller.h"
8#include "cc/layers/append_quads_data.h"
9#include "cc/layers/scrollbar_layer_impl.h"
10#include "cc/quads/solid_color_draw_quad.h"
11#include "cc/resources/prioritized_resource_manager.h"
12#include "cc/resources/priority_calculator.h"
13#include "cc/resources/resource_update_queue.h"
14#include "cc/test/fake_impl_proxy.h"
15#include "cc/test/fake_layer_tree_host_client.h"
16#include "cc/test/fake_layer_tree_host_impl.h"
17#include "cc/test/fake_scrollbar_theme_painter.h"
18#include "cc/test/fake_web_scrollbar.h"
19#include "cc/test/fake_web_scrollbar_theme_geometry.h"
20#include "cc/test/geometry_test_utils.h"
21#include "cc/test/layer_tree_test.h"
22#include "cc/test/mock_quad_culler.h"
23#include "cc/test/test_web_graphics_context_3d.h"
24#include "cc/trees/layer_tree_impl.h"
25#include "cc/trees/single_thread_proxy.h"
26#include "cc/trees/tree_synchronizer.h"
27#include "testing/gmock/include/gmock/gmock.h"
28#include "testing/gtest/include/gtest/gtest.h"
29#include "third_party/WebKit/Source/Platform/chromium/public/WebScrollbar.h"
30#include "third_party/WebKit/Source/Platform/chromium/public/WebScrollbarThemeGeometry.h"
31
32namespace cc {
33namespace {
34
35scoped_ptr<LayerImpl> LayerImplForScrollAreaAndScrollbar(
36    FakeLayerTreeHostImpl* host_impl,
37    scoped_ptr<WebKit::WebScrollbar> scrollbar,
38    bool reverse_order) {
39  scoped_refptr<Layer> layer_tree_root = Layer::Create();
40  scoped_refptr<Layer> child1 = Layer::Create();
41  scoped_refptr<Layer> child2 =
42      ScrollbarLayer::Create(scrollbar.Pass(),
43                             FakeScrollbarThemePainter::Create(false)
44                                 .PassAs<ScrollbarThemePainter>(),
45                             FakeWebScrollbarThemeGeometry::Create(true),
46                             child1->id());
47  layer_tree_root->AddChild(child1);
48  layer_tree_root->InsertChild(child2, reverse_order ? 0 : 1);
49  scoped_ptr<LayerImpl> layer_impl =
50      TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
51                                         scoped_ptr<LayerImpl>(),
52                                         host_impl->active_tree());
53  TreeSynchronizer::PushProperties(layer_tree_root.get(), layer_impl.get());
54  return layer_impl.Pass();
55}
56
57TEST(ScrollbarLayerTest, ResolveScrollLayerPointer) {
58  FakeImplProxy proxy;
59  FakeLayerTreeHostImpl host_impl(&proxy);
60
61  {
62    scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
63    scoped_ptr<LayerImpl> layer_impl_tree_root =
64        LayerImplForScrollAreaAndScrollbar(
65            &host_impl, scrollbar.Pass(), false);
66
67    LayerImpl* cc_child1 = layer_impl_tree_root->children()[0];
68    ScrollbarLayerImpl* cc_child2 = static_cast<ScrollbarLayerImpl*>(
69        layer_impl_tree_root->children()[1]);
70
71    EXPECT_EQ(cc_child1->horizontal_scrollbar_layer(), cc_child2);
72  }
73  {
74    // another traverse order
75    scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
76    scoped_ptr<LayerImpl> layer_impl_tree_root =
77        LayerImplForScrollAreaAndScrollbar(
78            &host_impl, scrollbar.Pass(), true);
79
80    ScrollbarLayerImpl* cc_child1 = static_cast<ScrollbarLayerImpl*>(
81        layer_impl_tree_root->children()[0]);
82    LayerImpl* cc_child2 = layer_impl_tree_root->children()[1];
83
84    EXPECT_EQ(cc_child2->horizontal_scrollbar_layer(), cc_child1);
85  }
86}
87
88TEST(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
89  FakeImplProxy proxy;
90  FakeLayerTreeHostImpl host_impl(&proxy);
91
92  // Create and attach a non-overlay scrollbar.
93  scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
94  static_cast<FakeWebScrollbar*>(scrollbar.get())->set_overlay(false);
95  scoped_ptr<LayerImpl> layer_impl_tree_root =
96      LayerImplForScrollAreaAndScrollbar(&host_impl, scrollbar.Pass(), false);
97  ScrollbarLayerImpl* scrollbar_layer_impl =
98      static_cast<ScrollbarLayerImpl*>(layer_impl_tree_root->children()[1]);
99
100  // When the scrollbar is not an overlay scrollbar, the scroll should be
101  // responded to on the main thread as the compositor does not yet implement
102  // scrollbar scrolling.
103  EXPECT_EQ(InputHandlerClient::ScrollOnMainThread,
104            scrollbar_layer_impl->TryScroll(gfx::Point(0, 0),
105                                            InputHandlerClient::Gesture));
106
107  // Create and attach an overlay scrollbar.
108  scrollbar = FakeWebScrollbar::Create();
109  static_cast<FakeWebScrollbar*>(scrollbar.get())->set_overlay(true);
110
111  layer_impl_tree_root =
112      LayerImplForScrollAreaAndScrollbar(&host_impl, scrollbar.Pass(), false);
113  scrollbar_layer_impl =
114      static_cast<ScrollbarLayerImpl*>(layer_impl_tree_root->children()[1]);
115
116  // The user shouldn't be able to drag an overlay scrollbar and the scroll
117  // may be handled in the compositor.
118  EXPECT_EQ(InputHandlerClient::ScrollIgnored,
119            scrollbar_layer_impl->TryScroll(gfx::Point(0, 0),
120                                            InputHandlerClient::Gesture));
121}
122
123TEST(ScrollbarLayerTest, ScrollOffsetSynchronization) {
124  FakeImplProxy proxy;
125  FakeLayerTreeHostImpl host_impl(&proxy);
126
127  scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
128  scoped_refptr<Layer> layer_tree_root = Layer::Create();
129  scoped_refptr<Layer> content_layer = Layer::Create();
130  scoped_refptr<Layer> scrollbar_layer =
131      ScrollbarLayer::Create(scrollbar.Pass(),
132                             FakeScrollbarThemePainter::Create(false)
133                                 .PassAs<ScrollbarThemePainter>(),
134                             FakeWebScrollbarThemeGeometry::Create(true),
135                             layer_tree_root->id());
136  layer_tree_root->AddChild(content_layer);
137  layer_tree_root->AddChild(scrollbar_layer);
138
139  layer_tree_root->SetScrollOffset(gfx::Vector2d(10, 20));
140  layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(30, 50));
141  layer_tree_root->SetBounds(gfx::Size(100, 200));
142  content_layer->SetBounds(gfx::Size(100, 200));
143
144  scoped_ptr<LayerImpl> layer_impl_tree_root =
145      TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
146                                         scoped_ptr<LayerImpl>(),
147                                         host_impl.active_tree());
148  TreeSynchronizer::PushProperties(layer_tree_root.get(),
149                                   layer_impl_tree_root.get());
150
151  ScrollbarLayerImpl* cc_scrollbar_layer =
152      static_cast<ScrollbarLayerImpl*>(layer_impl_tree_root->children()[1]);
153
154  EXPECT_EQ(10.f, cc_scrollbar_layer->CurrentPos());
155  EXPECT_EQ(100, cc_scrollbar_layer->TotalSize());
156  EXPECT_EQ(30, cc_scrollbar_layer->Maximum());
157
158  layer_tree_root->SetScrollOffset(gfx::Vector2d(100, 200));
159  layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(300, 500));
160  layer_tree_root->SetBounds(gfx::Size(1000, 2000));
161  content_layer->SetBounds(gfx::Size(1000, 2000));
162
163  ScrollbarAnimationController* scrollbar_controller =
164      layer_impl_tree_root->scrollbar_animation_controller();
165  layer_impl_tree_root =
166      TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
167                                         layer_impl_tree_root.Pass(),
168                                         host_impl.active_tree());
169  TreeSynchronizer::PushProperties(layer_tree_root.get(),
170                                   layer_impl_tree_root.get());
171  EXPECT_EQ(scrollbar_controller,
172            layer_impl_tree_root->scrollbar_animation_controller());
173
174  EXPECT_EQ(100.f, cc_scrollbar_layer->CurrentPos());
175  EXPECT_EQ(1000, cc_scrollbar_layer->TotalSize());
176  EXPECT_EQ(300, cc_scrollbar_layer->Maximum());
177
178  layer_impl_tree_root->ScrollBy(gfx::Vector2d(12, 34));
179
180  EXPECT_EQ(112.f, cc_scrollbar_layer->CurrentPos());
181  EXPECT_EQ(1000, cc_scrollbar_layer->TotalSize());
182  EXPECT_EQ(300, cc_scrollbar_layer->Maximum());
183}
184
185TEST(ScrollbarLayerTest, SolidColorDrawQuads) {
186  LayerTreeSettings layer_tree_settings;
187  layer_tree_settings.solid_color_scrollbars = true;
188  layer_tree_settings.solid_color_scrollbar_thickness_dip = 3;
189  FakeImplProxy proxy;
190  FakeLayerTreeHostImpl host_impl(layer_tree_settings, &proxy);
191
192  scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
193  static_cast<FakeWebScrollbar*>(scrollbar.get())->set_overlay(true);
194  scoped_ptr<LayerImpl> layer_impl_tree_root =
195      LayerImplForScrollAreaAndScrollbar(&host_impl, scrollbar.Pass(), false);
196  ScrollbarLayerImpl* scrollbar_layer_impl =
197      static_cast<ScrollbarLayerImpl*>(layer_impl_tree_root->children()[1]);
198  scrollbar_layer_impl->SetThumbSize(gfx::Size(4, 4));
199  scrollbar_layer_impl->SetViewportWithinScrollableArea(
200      gfx::RectF(10.f, 0.f, 40.f, 0.f), gfx::SizeF(100.f, 100.f));
201
202  // Thickness should be overridden to 3.
203  {
204    MockQuadCuller quad_culler;
205    AppendQuadsData data;
206    scrollbar_layer_impl->AppendQuads(&quad_culler, &data);
207
208    const QuadList& quads = quad_culler.quad_list();
209    ASSERT_EQ(1, quads.size());
210    EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
211    EXPECT_RECT_EQ(gfx::Rect(1, 0, 4, 3), quads[0]->rect);
212  }
213
214  // Contents scale should scale the draw quad.
215  scrollbar_layer_impl->draw_properties().contents_scale_x = 2.f;
216  scrollbar_layer_impl->draw_properties().contents_scale_y = 2.f;
217  {
218    MockQuadCuller quad_culler;
219    AppendQuadsData data;
220    scrollbar_layer_impl->AppendQuads(&quad_culler, &data);
221
222    const QuadList& quads = quad_culler.quad_list();
223    ASSERT_EQ(1, quads.size());
224    EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
225    EXPECT_RECT_EQ(gfx::Rect(2, 0, 8, 6), quads[0]->rect);
226  }
227  scrollbar_layer_impl->draw_properties().contents_scale_x = 1.f;
228  scrollbar_layer_impl->draw_properties().contents_scale_y = 1.f;
229
230  // For solid color scrollbars, position and size should reflect the
231  // viewport, not the geometry object.
232  scrollbar_layer_impl->SetViewportWithinScrollableArea(
233      gfx::RectF(40.f, 0.f, 20.f, 0.f),
234      gfx::SizeF(100.f, 100.f));
235  {
236    MockQuadCuller quad_culler;
237    AppendQuadsData data;
238    scrollbar_layer_impl->AppendQuads(&quad_culler, &data);
239
240    const QuadList& quads = quad_culler.quad_list();
241    ASSERT_EQ(1, quads.size());
242    EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
243    EXPECT_RECT_EQ(gfx::Rect(4, 0, 2, 3), quads[0]->rect);
244  }
245}
246
247TEST(ScrollbarLayerTest, LayerDrivenSolidColorDrawQuads) {
248  LayerTreeSettings layer_tree_settings;
249  layer_tree_settings.solid_color_scrollbars = true;
250  layer_tree_settings.solid_color_scrollbar_thickness_dip = 3;
251  FakeImplProxy proxy;
252  FakeLayerTreeHostImpl host_impl(layer_tree_settings, &proxy);
253
254  scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
255  static_cast<FakeWebScrollbar*>(scrollbar.get())->set_overlay(true);
256  scoped_ptr<LayerImpl> layer_impl_tree_root =
257      LayerImplForScrollAreaAndScrollbar(&host_impl, scrollbar.Pass(), false);
258  ScrollbarLayerImpl* scrollbar_layer_impl =
259      static_cast<ScrollbarLayerImpl*>(layer_impl_tree_root->children()[1]);
260
261  // Make sure that this ends up calling SetViewportWithinScrollableArea.
262  layer_impl_tree_root->SetHorizontalScrollbarLayer(scrollbar_layer_impl);
263  layer_impl_tree_root->SetMaxScrollOffset(gfx::Vector2d(8, 8));
264  layer_impl_tree_root->SetBounds(gfx::Size(2, 2));
265  layer_impl_tree_root->ScrollBy(gfx::Vector2dF(4.f, 0.f));
266
267  {
268    MockQuadCuller quad_culler;
269    AppendQuadsData data;
270    scrollbar_layer_impl->AppendQuads(&quad_culler, &data);
271
272    const QuadList& quads = quad_culler.quad_list();
273    ASSERT_EQ(1, quads.size());
274    EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
275    EXPECT_RECT_EQ(gfx::Rect(4, 0, 2, 3), quads[0]->rect);
276  }
277}
278
279class ScrollbarLayerTestMaxTextureSize : public LayerTreeTest {
280 public:
281  ScrollbarLayerTestMaxTextureSize() {}
282
283  void SetScrollbarBounds(gfx::Size bounds) { bounds_ = bounds; }
284
285  virtual void BeginTest() OVERRIDE {
286    layer_tree_host()->InitializeRendererIfNeeded();
287
288    scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
289    scrollbar_layer_ =
290        ScrollbarLayer::Create(scrollbar.Pass(),
291                               FakeScrollbarThemePainter::Create(false)
292                                   .PassAs<ScrollbarThemePainter>(),
293                               FakeWebScrollbarThemeGeometry::Create(true),
294                               1);
295    scrollbar_layer_->SetLayerTreeHost(layer_tree_host());
296    scrollbar_layer_->SetBounds(bounds_);
297    layer_tree_host()->root_layer()->AddChild(scrollbar_layer_);
298
299    scroll_layer_ = Layer::Create();
300    scrollbar_layer_->SetScrollLayerId(scroll_layer_->id());
301    layer_tree_host()->root_layer()->AddChild(scroll_layer_);
302
303    PostSetNeedsCommitToMainThread();
304  }
305
306  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
307    const int kMaxTextureSize =
308        impl->GetRendererCapabilities().max_texture_size;
309
310    // Check first that we're actually testing something.
311    EXPECT_GT(scrollbar_layer_->bounds().width(), kMaxTextureSize);
312
313    EXPECT_EQ(scrollbar_layer_->content_bounds().width(),
314              kMaxTextureSize - 1);
315    EXPECT_EQ(scrollbar_layer_->content_bounds().height(),
316              kMaxTextureSize - 1);
317
318    EndTest();
319  }
320
321  virtual void AfterTest() OVERRIDE {}
322
323 private:
324  scoped_refptr<ScrollbarLayer> scrollbar_layer_;
325  scoped_refptr<Layer> scroll_layer_;
326  gfx::Size bounds_;
327};
328
329TEST_F(ScrollbarLayerTestMaxTextureSize, RunTest) {
330  scoped_ptr<TestWebGraphicsContext3D> context =
331      TestWebGraphicsContext3D::Create();
332  int max_size = 0;
333  context->getIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
334  SetScrollbarBounds(gfx::Size(max_size + 100, max_size + 100));
335  RunTest(true);
336}
337
338class MockLayerTreeHost : public LayerTreeHost {
339 public:
340  MockLayerTreeHost(LayerTreeHostClient* client,
341                    const LayerTreeSettings& settings)
342      : LayerTreeHost(client, settings) {
343      Initialize(scoped_ptr<Thread>(NULL));
344  }
345};
346
347
348class ScrollbarLayerTestResourceCreation : public testing::Test {
349 public:
350  ScrollbarLayerTestResourceCreation()
351      : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
352
353  void TestResourceUpload(int expected_resources) {
354    layer_tree_host_.reset(
355        new MockLayerTreeHost(&fake_client_, layer_tree_settings_));
356
357    scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
358    scoped_refptr<Layer> layer_tree_root = Layer::Create();
359    scoped_refptr<Layer> content_layer = Layer::Create();
360    scoped_refptr<Layer> scrollbar_layer =
361        ScrollbarLayer::Create(scrollbar.Pass(),
362                               FakeScrollbarThemePainter::Create(false)
363                                   .PassAs<ScrollbarThemePainter>(),
364                               FakeWebScrollbarThemeGeometry::Create(true),
365                               layer_tree_root->id());
366    layer_tree_root->AddChild(content_layer);
367    layer_tree_root->AddChild(scrollbar_layer);
368
369    layer_tree_host_->InitializeRendererIfNeeded();
370    layer_tree_host_->contents_texture_manager()->
371        SetMaxMemoryLimitBytes(1024 * 1024);
372    layer_tree_host_->SetRootLayer(layer_tree_root);
373
374    scrollbar_layer->SetIsDrawable(true);
375    scrollbar_layer->SetBounds(gfx::Size(100, 100));
376    layer_tree_root->SetScrollOffset(gfx::Vector2d(10, 20));
377    layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(30, 50));
378    layer_tree_root->SetBounds(gfx::Size(100, 200));
379    content_layer->SetBounds(gfx::Size(100, 200));
380    scrollbar_layer->draw_properties().content_bounds = gfx::Size(100, 200);
381    scrollbar_layer->draw_properties().visible_content_rect =
382        gfx::Rect(0, 0, 100, 200);
383    scrollbar_layer->CreateRenderSurface();
384    scrollbar_layer->draw_properties().render_target = scrollbar_layer;
385
386    testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
387    EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
388
389    PriorityCalculator calculator;
390    ResourceUpdateQueue queue;
391    OcclusionTracker occlusion_tracker(gfx::Rect(), false);
392
393    scrollbar_layer->SetTexturePriorities(calculator);
394    layer_tree_host_->contents_texture_manager()->PrioritizeTextures();
395    scrollbar_layer->Update(&queue, &occlusion_tracker, NULL);
396    EXPECT_EQ(0, queue.FullUploadSize());
397    EXPECT_EQ(expected_resources, queue.PartialUploadSize());
398
399    testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
400  }
401
402 protected:
403  FakeLayerTreeHostClient fake_client_;
404  LayerTreeSettings layer_tree_settings_;
405  scoped_ptr<MockLayerTreeHost> layer_tree_host_;
406};
407
408TEST_F(ScrollbarLayerTestResourceCreation, ResourceUpload) {
409  layer_tree_settings_.solid_color_scrollbars = false;
410  TestResourceUpload(2);
411}
412
413TEST_F(ScrollbarLayerTestResourceCreation, SolidColorNoResourceUpload) {
414  layer_tree_settings_.solid_color_scrollbars = true;
415  TestResourceUpload(0);
416}
417
418TEST(ScrollbarLayerTest, PinchZoomScrollbarUpdates) {
419  FakeImplProxy proxy;
420  FakeLayerTreeHostImpl host_impl(&proxy);
421
422  scoped_refptr<Layer> layer_tree_root = Layer::Create();
423  layer_tree_root->SetScrollable(true);
424
425  scoped_refptr<Layer> content_layer = Layer::Create();
426  scoped_ptr<WebKit::WebScrollbar> scrollbar1(FakeWebScrollbar::Create());
427  scoped_refptr<Layer> scrollbar_layer_horizontal =
428      ScrollbarLayer::Create(scrollbar1.Pass(),
429                             FakeScrollbarThemePainter::Create(false)
430                                 .PassAs<ScrollbarThemePainter>(),
431                             FakeWebScrollbarThemeGeometry::Create(true),
432                             Layer::PINCH_ZOOM_ROOT_SCROLL_LAYER_ID);
433  scoped_ptr<WebKit::WebScrollbar> scrollbar2(FakeWebScrollbar::Create());
434  scoped_refptr<Layer> scrollbar_layer_vertical =
435      ScrollbarLayer::Create(scrollbar2.Pass(),
436                             FakeScrollbarThemePainter::Create(false)
437                                 .PassAs<ScrollbarThemePainter>(),
438                             FakeWebScrollbarThemeGeometry::Create(true),
439                             Layer::PINCH_ZOOM_ROOT_SCROLL_LAYER_ID);
440
441  layer_tree_root->AddChild(content_layer);
442  layer_tree_root->AddChild(scrollbar_layer_horizontal);
443  layer_tree_root->AddChild(scrollbar_layer_vertical);
444
445  layer_tree_root->SetScrollOffset(gfx::Vector2d(10, 20));
446  layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(30, 50));
447  layer_tree_root->SetBounds(gfx::Size(100, 200));
448  content_layer->SetBounds(gfx::Size(100, 200));
449
450  scoped_ptr<LayerImpl> layer_impl_tree_root =
451      TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
452                                         scoped_ptr<LayerImpl>(),
453                                         host_impl.active_tree());
454  TreeSynchronizer::PushProperties(layer_tree_root.get(),
455                                   layer_impl_tree_root.get());
456
457  ScrollbarLayerImpl* pinch_zoom_horizontal =
458      static_cast<ScrollbarLayerImpl*>(layer_impl_tree_root->children()[1]);
459  ScrollbarLayerImpl* pinch_zoom_vertical =
460      static_cast<ScrollbarLayerImpl*>(layer_impl_tree_root->children()[2]);
461
462  // Need a root layer in the active tree in order for DidUpdateScroll()
463  // to work.
464  host_impl.active_tree()->SetRootLayer(layer_impl_tree_root.Pass());
465  host_impl.active_tree()->FindRootScrollLayer();
466
467  // Manually set the pinch-zoom layers: normally this is done by
468  // LayerTreeHost.
469  host_impl.active_tree()->
470      SetPinchZoomHorizontalLayerId(pinch_zoom_horizontal->id());
471  host_impl.active_tree()->
472      SetPinchZoomVerticalLayerId(pinch_zoom_vertical->id());
473
474  host_impl.active_tree()->DidUpdateScroll();
475
476  EXPECT_EQ(10.f, pinch_zoom_horizontal->CurrentPos());
477  EXPECT_EQ(100, pinch_zoom_horizontal->TotalSize());
478  EXPECT_EQ(30, pinch_zoom_horizontal->Maximum());
479  EXPECT_EQ(20.f, pinch_zoom_vertical->CurrentPos());
480  EXPECT_EQ(200, pinch_zoom_vertical->TotalSize());
481  EXPECT_EQ(50, pinch_zoom_vertical->Maximum());
482}
483
484}  // namespace
485}  // namespace cc
486