src/cc/layers/scrollbar_layer_unittest.cc

   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 "base/containers/hash_tables.h"
   6 #include "cc/animation/scrollbar_animation_controller.h"
   7 #include "cc/layers/append_quads_data.h"
   8 #include "cc/layers/painted_scrollbar_layer.h"
   9 #include "cc/layers/painted_scrollbar_layer_impl.h"
  10 #include "cc/layers/scrollbar_layer_interface.h"
  11 #include "cc/layers/solid_color_scrollbar_layer.h"
  12 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
  13 #include "cc/quads/solid_color_draw_quad.h"
  14 #include "cc/resources/resource_update_queue.h"
  15 #include "cc/test/fake_impl_proxy.h"
  16 #include "cc/test/fake_layer_tree_host.h"
  17 #include "cc/test/fake_layer_tree_host_client.h"
  18 #include "cc/test/fake_layer_tree_host_impl.h"
  19 #include "cc/test/fake_painted_scrollbar_layer.h"
  20 #include "cc/test/fake_scrollbar.h"
  21 #include "cc/test/geometry_test_utils.h"
  22 #include "cc/test/layer_tree_test.h"
  23 #include "cc/test/mock_occlusion_tracker.h"
  24 #include "cc/test/test_web_graphics_context_3d.h"
  25 #include "cc/trees/layer_tree_host.h"
  26 #include "cc/trees/layer_tree_impl.h"
  27 #include "cc/trees/occlusion_tracker.h"
  28 #include "cc/trees/single_thread_proxy.h"
  29 #include "cc/trees/tree_synchronizer.h"
  30 #include "testing/gmock/include/gmock/gmock.h"
  31 #include "testing/gtest/include/gtest/gtest.h"
  32
  33 namespace cc {
  34 namespace {
  35
  36 LayerImpl* LayerImplForScrollAreaAndScrollbar(FakeLayerTreeHost* host,
  37                                               scoped_ptr<Scrollbar> scrollbar,
  38                                               bool reverse_order,
  39                                               bool use_solid_color_scrollbar,
  40                                               int thumb_thickness,
  41                                               int track_start) {
  42   scoped_refptr<Layer> layer_tree_root = Layer::Create();
  43   scoped_refptr<Layer> child1 = Layer::Create();
  44   scoped_refptr<Layer> child2;
  45   if (use_solid_color_scrollbar) {
  46     const bool kIsLeftSideVerticalScrollbar = false;
  47     child2 = SolidColorScrollbarLayer::Create(scrollbar->Orientation(),
  48                                               thumb_thickness,
  49                                               track_start,
  50                                               kIsLeftSideVerticalScrollbar,
  51                                               child1->id());
  52   } else {
  53     child2 = PaintedScrollbarLayer::Create(scrollbar.Pass(), child1->id());
  54   }
  55   child2->ToScrollbarLayer()->SetClipLayer(layer_tree_root->id());
  56   layer_tree_root->AddChild(child1);
  57   layer_tree_root->InsertChild(child2, reverse_order ? 0 : 1);
  58   host->SetRootLayer(layer_tree_root);
  59   return host->CommitAndCreateLayerImplTree();
  60 }
  61
  62 TEST(ScrollbarLayerTest, ResolveScrollLayerPointer) {
  63   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
  64   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
  65   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
  66   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
  67       host.get(), scrollbar.Pass(), false, false, 0, 0);
  68
  69   LayerImpl* cc_child1 = layer_impl_tree_root->children()[0];
  70   PaintedScrollbarLayerImpl* cc_child2 =
  71       static_cast<PaintedScrollbarLayerImpl*>(
  72           layer_impl_tree_root->children()[1]);
  73
  74   EXPECT_EQ(cc_child1->scrollbars()->size(), 1UL);
  75   EXPECT_EQ(*(cc_child1->scrollbars()->begin()), cc_child2);
  76 }
  77
  78 TEST(ScrollbarLayerTest, ResolveScrollLayerPointer_ReverseOrder) {
  79   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
  80   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
  81   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
  82   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
  83       host.get(), scrollbar.Pass(), true, false, 0, 0);
  84
  85   PaintedScrollbarLayerImpl* cc_child1 =
  86       static_cast<PaintedScrollbarLayerImpl*>(
  87           layer_impl_tree_root->children()[0]);
  88   LayerImpl* cc_child2 = layer_impl_tree_root->children()[1];
  89
  90   EXPECT_EQ(cc_child2->scrollbars()->size(), 1UL);
  91   EXPECT_EQ(*(cc_child2->scrollbars()->begin()), cc_child1);
  92 }
  93
  94 TEST(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
  95   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
  96   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
  97
  98   // Create and attach a non-overlay scrollbar.
  99   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
 100   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
 101       host.get(), scrollbar.Pass(), false, false, 0, 0);
 102   PaintedScrollbarLayerImpl* scrollbar_layer_impl =
 103       static_cast<PaintedScrollbarLayerImpl*>(
 104           layer_impl_tree_root->children()[1]);
 105
 106   // When the scrollbar is not an overlay scrollbar, the scroll should be
 107   // responded to on the main thread as the compositor does not yet implement
 108   // scrollbar scrolling.
 109   EXPECT_EQ(InputHandler::ScrollOnMainThread,
 110             scrollbar_layer_impl->TryScroll(gfx::Point(0, 0),
 111                                             InputHandler::Gesture));
 112
 113   // Create and attach an overlay scrollbar.
 114   scrollbar.reset(new FakeScrollbar(false, false, true));
 115
 116   layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
 117       host.get(), scrollbar.Pass(), false, false, 0, 0);
 118   scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
 119       layer_impl_tree_root->children()[1]);
 120
 121   // The user shouldn't be able to drag an overlay scrollbar and the scroll
 122   // may be handled in the compositor.
 123   EXPECT_EQ(InputHandler::ScrollIgnored,
 124             scrollbar_layer_impl->TryScroll(gfx::Point(0, 0),
 125                                             InputHandler::Gesture));
 126 }
 127
 128 TEST(PaintedScrollbarLayerTest, ScrollOffsetSynchronization) {
 129   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 130   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
 131
 132   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
 133   scoped_refptr<Layer> layer_tree_root = Layer::Create();
 134   scoped_refptr<Layer> scroll_layer = Layer::Create();
 135   scoped_refptr<Layer> content_layer = Layer::Create();
 136   scoped_refptr<Layer> scrollbar_layer =
 137       PaintedScrollbarLayer::Create(scrollbar.Pass(), layer_tree_root->id());
 138
 139   // Choose bounds to give max_scroll_offset = (30, 50).
 140   layer_tree_root->SetBounds(gfx::Size(70, 150));
 141   scroll_layer->SetScrollClipLayerId(layer_tree_root->id());
 142   scroll_layer->SetScrollOffset(gfx::Vector2d(10, 20));
 143   scroll_layer->SetBounds(gfx::Size(100, 200));
 144   content_layer->SetBounds(gfx::Size(100, 200));
 145
 146   host->SetRootLayer(layer_tree_root);
 147   layer_tree_root->AddChild(scroll_layer);
 148   scroll_layer->AddChild(content_layer);
 149   layer_tree_root->AddChild(scrollbar_layer);
 150   scrollbar_layer->ToScrollbarLayer()->SetScrollLayer(scroll_layer->id());
 151   scrollbar_layer->ToScrollbarLayer()->SetClipLayer(layer_tree_root->id());
 152
 153   layer_tree_root->SavePaintProperties();
 154   content_layer->SavePaintProperties();
 155
 156   LayerImpl* layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
 157
 158   ScrollbarLayerImplBase* cc_scrollbar_layer =
 159       static_cast<PaintedScrollbarLayerImpl*>(
 160           layer_impl_tree_root->children()[1]);
 161
 162   EXPECT_EQ(10.f, cc_scrollbar_layer->current_pos());
 163   EXPECT_EQ(30, cc_scrollbar_layer->maximum());
 164
 165   layer_tree_root->SetBounds(gfx::Size(700, 1500));
 166   layer_tree_root->SavePaintProperties();
 167   scroll_layer->SetBounds(gfx::Size(1000, 2000));
 168   scroll_layer->SetScrollOffset(gfx::Vector2d(100, 200));
 169   scroll_layer->SavePaintProperties();
 170   content_layer->SetBounds(gfx::Size(1000, 2000));
 171   content_layer->SavePaintProperties();
 172
 173   ScrollbarAnimationController* scrollbar_controller =
 174       layer_impl_tree_root->scrollbar_animation_controller();
 175   layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
 176   EXPECT_EQ(scrollbar_controller,
 177             layer_impl_tree_root->scrollbar_animation_controller());
 178
 179   EXPECT_EQ(100.f, cc_scrollbar_layer->current_pos());
 180   EXPECT_EQ(300, cc_scrollbar_layer->maximum());
 181
 182   LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0];
 183   scroll_layer_impl->ScrollBy(gfx::Vector2d(12, 34));
 184
 185   EXPECT_EQ(112.f, cc_scrollbar_layer->current_pos());
 186   EXPECT_EQ(300, cc_scrollbar_layer->maximum());
 187 }
 188
 189 #define UPDATE_AND_EXTRACT_LAYER_POINTERS()                         \
 190   do {                                                              \
 191     scrollbar_layer->UpdateThumbAndTrackGeometry();                 \
 192     root_clip_layer_impl = host->CommitAndCreateLayerImplTree();    \
 193     root_layer_impl = root_clip_layer_impl->children()[0];          \
 194     scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>( \
 195         root_layer_impl->children()[1]);                            \
 196     scrollbar_layer_impl->ScrollbarParametersDidChange();           \
 197   } while (false)
 198
 199 TEST(ScrollbarLayerTest, UpdatePropertiesOfScrollBarWhenThumbRemoved) {
 200   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 201   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
 202   scoped_refptr<Layer> root_clip_layer = Layer::Create();
 203   scoped_refptr<Layer> root_layer = Layer::Create();
 204   scoped_refptr<Layer> content_layer = Layer::Create();
 205   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
 206       FakePaintedScrollbarLayer::Create(false, true, root_layer->id());
 207
 208   root_layer->SetScrollClipLayerId(root_clip_layer->id());
 209   // Give the root-clip a size that will result in MaxScrollOffset = (80, 0).
 210   root_clip_layer->SetBounds(gfx::Size(20, 50));
 211   root_layer->SetBounds(gfx::Size(100, 50));
 212   content_layer->SetBounds(gfx::Size(100, 50));
 213
 214   host->SetRootLayer(root_clip_layer);
 215   root_clip_layer->AddChild(root_layer);
 216   root_layer->AddChild(content_layer);
 217   root_layer->AddChild(scrollbar_layer);
 218
 219   root_layer->SetScrollOffset(gfx::Vector2d(0, 0));
 220   scrollbar_layer->SetBounds(gfx::Size(70, 10));
 221   scrollbar_layer->SetScrollLayer(root_layer->id());
 222   scrollbar_layer->SetClipLayer(root_clip_layer->id());
 223   scrollbar_layer->fake_scrollbar()->set_location(gfx::Point(20, 10));
 224   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
 225   scrollbar_layer->fake_scrollbar()->set_thumb_thickness(10);
 226   scrollbar_layer->fake_scrollbar()->set_thumb_length(4);
 227
 228   scrollbar_layer->UpdateThumbAndTrackGeometry();
 229   LayerImpl* root_clip_layer_impl = NULL;
 230   LayerImpl* root_layer_impl = NULL;
 231   PaintedScrollbarLayerImpl* scrollbar_layer_impl = NULL;
 232
 233   UPDATE_AND_EXTRACT_LAYER_POINTERS();
 234   EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
 235             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 236
 237   scrollbar_layer->fake_scrollbar()->set_has_thumb(false);
 238
 239   UPDATE_AND_EXTRACT_LAYER_POINTERS();
 240   EXPECT_EQ(gfx::Rect(10, 0, 0, 0).ToString(),
 241             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 242 }
 243
 244 TEST(ScrollbarLayerTest, ThumbRect) {
 245   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 246   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
 247   scoped_refptr<Layer> root_clip_layer = Layer::Create();
 248   scoped_refptr<Layer> root_layer = Layer::Create();
 249   scoped_refptr<Layer> content_layer = Layer::Create();
 250   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
 251       FakePaintedScrollbarLayer::Create(false, true, root_layer->id());
 252
 253   root_layer->SetScrollClipLayerId(root_clip_layer->id());
 254   // Give the root-clip a size that will result in MaxScrollOffset = (80, 0).
 255   root_clip_layer->SetBounds(gfx::Size(20, 50));
 256   root_layer->SetBounds(gfx::Size(100, 50));
 257   content_layer->SetBounds(gfx::Size(100, 50));
 258
 259   host->SetRootLayer(root_clip_layer);
 260   root_clip_layer->AddChild(root_layer);
 261   root_layer->AddChild(content_layer);
 262   root_layer->AddChild(scrollbar_layer);
 263
 264   root_layer->SetScrollOffset(gfx::Vector2d(0, 0));
 265   scrollbar_layer->SetBounds(gfx::Size(70, 10));
 266   scrollbar_layer->SetScrollLayer(root_layer->id());
 267   scrollbar_layer->SetClipLayer(root_clip_layer->id());
 268   scrollbar_layer->fake_scrollbar()->set_location(gfx::Point(20, 10));
 269   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
 270   scrollbar_layer->fake_scrollbar()->set_thumb_thickness(10);
 271   scrollbar_layer->fake_scrollbar()->set_thumb_length(4);
 272   scrollbar_layer->UpdateThumbAndTrackGeometry();
 273   LayerImpl* root_clip_layer_impl = NULL;
 274   LayerImpl* root_layer_impl = NULL;
 275   PaintedScrollbarLayerImpl* scrollbar_layer_impl = NULL;
 276
 277   // Thumb is at the edge of the scrollbar (should be inset to
 278   // the start of the track within the scrollbar layer's
 279   // position).
 280   UPDATE_AND_EXTRACT_LAYER_POINTERS();
 281   EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
 282             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 283
 284   // Under-scroll (thumb position should clamp and be unchanged).
 285   root_layer->SetScrollOffset(gfx::Vector2d(-5, 0));
 286
 287   UPDATE_AND_EXTRACT_LAYER_POINTERS();
 288   EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
 289             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 290
 291   // Over-scroll (thumb position should clamp on the far side).
 292   root_layer->SetScrollOffset(gfx::Vector2d(85, 0));
 293
 294   UPDATE_AND_EXTRACT_LAYER_POINTERS();
 295   EXPECT_EQ(gfx::Rect(56, 0, 4, 10).ToString(),
 296             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 297
 298   // Change thumb thickness and length.
 299   scrollbar_layer->fake_scrollbar()->set_thumb_thickness(4);
 300   scrollbar_layer->fake_scrollbar()->set_thumb_length(6);
 301
 302   UPDATE_AND_EXTRACT_LAYER_POINTERS();
 303   EXPECT_EQ(gfx::Rect(54, 0, 6, 4).ToString(),
 304             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 305
 306   // Shrink the scrollbar layer to cover only the track.
 307   scrollbar_layer->SetBounds(gfx::Size(50, 10));
 308   scrollbar_layer->fake_scrollbar()->set_location(gfx::Point(30, 10));
 309   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
 310
 311   UPDATE_AND_EXTRACT_LAYER_POINTERS();
 312   EXPECT_EQ(gfx::Rect(44, 0, 6, 4).ToString(),
 313             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 314
 315   // Shrink the track in the non-scrolling dimension so that it only covers the
 316   // middle third of the scrollbar layer (this does not affect the thumb
 317   // position).
 318   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 12, 50, 6));
 319
 320   UPDATE_AND_EXTRACT_LAYER_POINTERS();
 321   EXPECT_EQ(gfx::Rect(44, 0, 6, 4).ToString(),
 322             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 323 }
 324
 325 TEST(ScrollbarLayerTest, SolidColorDrawQuads) {
 326   const int kThumbThickness = 3;
 327   const int kTrackStart = 1;
 328   const int kTrackLength = 100;
 329
 330   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 331   LayerTreeSettings layer_tree_settings;
 332   scoped_ptr<FakeLayerTreeHost> host =
 333       FakeLayerTreeHost::Create(&client, layer_tree_settings);
 334
 335   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, true));
 336   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
 337       host.get(), scrollbar.Pass(), false, true, kThumbThickness, kTrackStart);
 338   ScrollbarLayerImplBase* scrollbar_layer_impl =
 339       static_cast<SolidColorScrollbarLayerImpl*>(
 340           layer_impl_tree_root->children()[1]);
 341   scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
 342   scrollbar_layer_impl->SetCurrentPos(10.f);
 343   scrollbar_layer_impl->SetMaximum(100);
 344   scrollbar_layer_impl->SetVisibleToTotalLengthRatio(0.4f);
 345
 346   // Thickness should be overridden to 3.
 347   {
 348     MockOcclusionTracker<LayerImpl> occlusion_tracker;
 349     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 350     AppendQuadsData data;
 351     scrollbar_layer_impl->AppendQuads(
 352         render_pass.get(), occlusion_tracker, &data);
 353
 354     const QuadList& quads = render_pass->quad_list;
 355     ASSERT_EQ(1u, quads.size());
 356     EXPECT_EQ(DrawQuad::SOLID_COLOR, quads.front()->material);
 357     EXPECT_RECT_EQ(gfx::Rect(6, 0, 39, 3), quads.front()->rect);
 358   }
 359
 360   // Contents scale should scale the draw quad.
 361   scrollbar_layer_impl->draw_properties().contents_scale_x = 2.f;
 362   scrollbar_layer_impl->draw_properties().contents_scale_y = 2.f;
 363   {
 364     MockOcclusionTracker<LayerImpl> occlusion_tracker;
 365     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 366     AppendQuadsData data;
 367     scrollbar_layer_impl->AppendQuads(
 368         render_pass.get(), occlusion_tracker, &data);
 369
 370     const QuadList& quads = render_pass->quad_list;
 371     ASSERT_EQ(1u, quads.size());
 372     EXPECT_EQ(DrawQuad::SOLID_COLOR, quads.front()->material);
 373     EXPECT_RECT_EQ(gfx::Rect(12, 0, 78, 6), quads.front()->rect);
 374   }
 375   scrollbar_layer_impl->draw_properties().contents_scale_x = 1.f;
 376   scrollbar_layer_impl->draw_properties().contents_scale_y = 1.f;
 377
 378   // For solid color scrollbars, position and size should reflect the
 379   // current viewport state.
 380   scrollbar_layer_impl->SetVisibleToTotalLengthRatio(0.2f);
 381   {
 382     MockOcclusionTracker<LayerImpl> occlusion_tracker;
 383     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 384     AppendQuadsData data;
 385     scrollbar_layer_impl->AppendQuads(
 386         render_pass.get(), occlusion_tracker, &data);
 387
 388     const QuadList& quads = render_pass->quad_list;
 389     ASSERT_EQ(1u, quads.size());
 390     EXPECT_EQ(DrawQuad::SOLID_COLOR, quads.front()->material);
 391     EXPECT_RECT_EQ(gfx::Rect(8, 0, 19, 3), quads.front()->rect);
 392   }
 393
 394   // We shouldn't attempt div-by-zero when the maximum is zero.
 395   scrollbar_layer_impl->SetCurrentPos(0.f);
 396   scrollbar_layer_impl->SetMaximum(0);
 397   {
 398     MockOcclusionTracker<LayerImpl> occlusion_tracker;
 399     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 400     AppendQuadsData data;
 401     scrollbar_layer_impl->AppendQuads(
 402         render_pass.get(), occlusion_tracker, &data);
 403
 404     const QuadList& quads = render_pass->quad_list;
 405     ASSERT_EQ(1u, quads.size());
 406     EXPECT_EQ(DrawQuad::SOLID_COLOR, quads.front()->material);
 407     EXPECT_RECT_EQ(gfx::Rect(1, 0, 19, 3), quads.front()->rect);
 408   }
 409 }
 410
 411 TEST(ScrollbarLayerTest, LayerDrivenSolidColorDrawQuads) {
 412   const int kThumbThickness = 3;
 413   const int kTrackStart = 0;
 414   const int kTrackLength = 10;
 415
 416   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 417   LayerTreeSettings layer_tree_settings;
 418   scoped_ptr<FakeLayerTreeHost> host =
 419       FakeLayerTreeHost::Create(&client, layer_tree_settings);
 420
 421   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, true));
 422
 423   {
 424     scoped_refptr<Layer> layer_tree_root = Layer::Create();
 425     scoped_refptr<Layer> scroll_layer = Layer::Create();
 426     scroll_layer->SetScrollClipLayerId(layer_tree_root->id());
 427     scoped_refptr<Layer> child1 = Layer::Create();
 428     scoped_refptr<Layer> child2;
 429     const bool kIsLeftSideVerticalScrollbar = false;
 430     child2 = SolidColorScrollbarLayer::Create(scrollbar->Orientation(),
 431                                               kThumbThickness,
 432                                               kTrackStart,
 433                                               kIsLeftSideVerticalScrollbar,
 434                                               child1->id());
 435     child2->ToScrollbarLayer()->SetScrollLayer(scroll_layer->id());
 436     child2->ToScrollbarLayer()->SetClipLayer(layer_tree_root->id());
 437     scroll_layer->AddChild(child1);
 438     scroll_layer->InsertChild(child2, 1);
 439     layer_tree_root->AddChild(scroll_layer);
 440     host->SetRootLayer(layer_tree_root);
 441   }
 442   LayerImpl* layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
 443   LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0];
 444
 445   ScrollbarLayerImplBase* scrollbar_layer_impl =
 446       static_cast<PaintedScrollbarLayerImpl*>(scroll_layer_impl->children()[1]);
 447
 448   // Choose layer bounds to give max_scroll_offset = (8, 8).
 449   layer_impl_tree_root->SetBounds(gfx::Size(2, 2));
 450   scroll_layer_impl->SetBounds(gfx::Size(10, 10));
 451   scroll_layer_impl->ScrollBy(gfx::Vector2dF(4.f, 0.f));
 452
 453   scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
 454   scrollbar_layer_impl->SetCurrentPos(4.f);
 455   scrollbar_layer_impl->SetMaximum(8);
 456
 457   {
 458     MockOcclusionTracker<LayerImpl> occlusion_tracker;
 459     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 460
 461     AppendQuadsData data;
 462     scrollbar_layer_impl->AppendQuads(
 463         render_pass.get(), occlusion_tracker, &data);
 464
 465     const QuadList& quads = render_pass->quad_list;
 466     ASSERT_EQ(1u, quads.size());
 467     EXPECT_EQ(DrawQuad::SOLID_COLOR, quads.front()->material);
 468     EXPECT_RECT_EQ(gfx::Rect(3, 0, 3, 3), quads.front()->rect);
 469   }
 470 }
 471
 472 class ScrollbarLayerSolidColorThumbTest : public testing::Test {
 473  public:
 474   ScrollbarLayerSolidColorThumbTest() {
 475     LayerTreeSettings layer_tree_settings;
 476     host_impl_.reset(new FakeLayerTreeHostImpl(
 477         layer_tree_settings, &proxy_, &shared_bitmap_manager_));
 478
 479     const int kThumbThickness = 3;
 480     const int kTrackStart = 0;
 481     const bool kIsLeftSideVerticalScrollbar = false;
 482     const bool kIsOverlayScrollbar = false;
 483
 484     horizontal_scrollbar_layer_ =
 485         SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(),
 486                                              1,
 487                                              HORIZONTAL,
 488                                              kThumbThickness,
 489                                              kTrackStart,
 490                                              kIsLeftSideVerticalScrollbar,
 491                                              kIsOverlayScrollbar);
 492     vertical_scrollbar_layer_ =
 493         SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(),
 494                                              2,
 495                                              VERTICAL,
 496                                              kThumbThickness,
 497                                              kTrackStart,
 498                                              kIsLeftSideVerticalScrollbar,
 499                                              kIsOverlayScrollbar);
 500   }
 501
 502  protected:
 503   FakeImplProxy proxy_;
 504   TestSharedBitmapManager shared_bitmap_manager_;
 505   scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
 506   scoped_ptr<SolidColorScrollbarLayerImpl> horizontal_scrollbar_layer_;
 507   scoped_ptr<SolidColorScrollbarLayerImpl> vertical_scrollbar_layer_;
 508 };
 509
 510 TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbLength) {
 511   horizontal_scrollbar_layer_->SetCurrentPos(0);
 512   horizontal_scrollbar_layer_->SetMaximum(10);
 513
 514   // Simple case - one third of the scrollable area is visible, so the thumb
 515   // should be one third as long as the track.
 516   horizontal_scrollbar_layer_->SetVisibleToTotalLengthRatio(0.33f);
 517   horizontal_scrollbar_layer_->SetBounds(gfx::Size(100, 3));
 518   EXPECT_EQ(33, horizontal_scrollbar_layer_->ComputeThumbQuadRect().width());
 519
 520   // The thumb's length should never be less than its thickness.
 521   horizontal_scrollbar_layer_->SetVisibleToTotalLengthRatio(0.01f);
 522   horizontal_scrollbar_layer_->SetBounds(gfx::Size(100, 3));
 523   EXPECT_EQ(3, horizontal_scrollbar_layer_->ComputeThumbQuadRect().width());
 524 }
 525
 526 TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbPosition) {
 527   horizontal_scrollbar_layer_->SetBounds(gfx::Size(100, 3));
 528   horizontal_scrollbar_layer_->SetVisibleToTotalLengthRatio(0.1f);
 529
 530   horizontal_scrollbar_layer_->SetCurrentPos(0);
 531   horizontal_scrollbar_layer_->SetMaximum(100);
 532   EXPECT_EQ(0, horizontal_scrollbar_layer_->ComputeThumbQuadRect().x());
 533   EXPECT_EQ(10, horizontal_scrollbar_layer_->ComputeThumbQuadRect().width());
 534
 535   horizontal_scrollbar_layer_->SetCurrentPos(100);
 536   // The thumb is 10px long and the track is 100px, so the maximum thumb
 537   // position is 90px.
 538   EXPECT_EQ(90, horizontal_scrollbar_layer_->ComputeThumbQuadRect().x());
 539
 540   horizontal_scrollbar_layer_->SetCurrentPos(80);
 541   // The scroll position is 80% of the maximum, so the thumb's position should
 542   // be at 80% of its maximum or 72px.
 543   EXPECT_EQ(72, horizontal_scrollbar_layer_->ComputeThumbQuadRect().x());
 544 }
 545
 546 TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbVerticalAdjust) {
 547   SolidColorScrollbarLayerImpl* layers[2] =
 548       { horizontal_scrollbar_layer_.get(), vertical_scrollbar_layer_.get() };
 549   for (size_t i = 0; i < 2; ++i) {
 550     layers[i]->SetVisibleToTotalLengthRatio(0.2f);
 551     layers[i]->SetCurrentPos(25);
 552     layers[i]->SetMaximum(100);
 553   }
 554   layers[0]->SetBounds(gfx::Size(100, 3));
 555   layers[1]->SetBounds(gfx::Size(3, 100));
 556
 557   EXPECT_RECT_EQ(gfx::RectF(20.f, 0.f, 20.f, 3.f),
 558                  horizontal_scrollbar_layer_->ComputeThumbQuadRect());
 559   EXPECT_RECT_EQ(gfx::RectF(0.f, 20.f, 3.f, 20.f),
 560                  vertical_scrollbar_layer_->ComputeThumbQuadRect());
 561
 562   horizontal_scrollbar_layer_->SetVerticalAdjust(10.f);
 563   vertical_scrollbar_layer_->SetVerticalAdjust(10.f);
 564
 565   // The vertical adjustment factor has two effects:
 566   // 1.) Moves the horizontal scrollbar down
 567   // 2.) Increases the vertical scrollbar's effective track length which both
 568   // increases the thumb's length and its position within the track.
 569   EXPECT_RECT_EQ(gfx::Rect(20.f, 10.f, 20.f, 3.f),
 570                  horizontal_scrollbar_layer_->ComputeThumbQuadRect());
 571   EXPECT_RECT_EQ(gfx::Rect(0.f, 22, 3.f, 22.f),
 572                  vertical_scrollbar_layer_->ComputeThumbQuadRect());
 573 }
 574
 575 class ScrollbarLayerTestMaxTextureSize : public LayerTreeTest {
 576  public:
 577   ScrollbarLayerTestMaxTextureSize() {}
 578
 579   void SetScrollbarBounds(const gfx::Size& bounds) { bounds_ = bounds; }
 580
 581   virtual void BeginTest() OVERRIDE {
 582     scroll_layer_ = Layer::Create();
 583     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 584
 585     scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
 586     scrollbar_layer_ =
 587         PaintedScrollbarLayer::Create(scrollbar.Pass(), scroll_layer_->id());
 588     scrollbar_layer_->SetScrollLayer(scroll_layer_->id());
 589     scrollbar_layer_->SetLayerTreeHost(layer_tree_host());
 590     scrollbar_layer_->SetBounds(bounds_);
 591     layer_tree_host()->root_layer()->AddChild(scrollbar_layer_);
 592
 593     PostSetNeedsCommitToMainThread();
 594   }
 595
 596   virtual void DidCommitAndDrawFrame() OVERRIDE {
 597     const int kMaxTextureSize =
 598         layer_tree_host()->GetRendererCapabilities().max_texture_size;
 599
 600     // Check first that we're actually testing something.
 601     EXPECT_GT(scrollbar_layer_->bounds().width(), kMaxTextureSize);
 602
 603     EXPECT_EQ(scrollbar_layer_->content_bounds().width(),
 604               kMaxTextureSize - 1);
 605     EXPECT_EQ(scrollbar_layer_->content_bounds().height(),
 606               kMaxTextureSize - 1);
 607
 608     EndTest();
 609   }
 610
 611   virtual void AfterTest() OVERRIDE {}
 612
 613  private:
 614   scoped_refptr<PaintedScrollbarLayer> scrollbar_layer_;
 615   scoped_refptr<Layer> scroll_layer_;
 616   gfx::Size bounds_;
 617 };
 618
 619 TEST_F(ScrollbarLayerTestMaxTextureSize, DirectRenderer) {
 620   scoped_ptr<TestWebGraphicsContext3D> context =
 621       TestWebGraphicsContext3D::Create();
 622   int max_size = 0;
 623   context->getIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
 624   SetScrollbarBounds(gfx::Size(max_size + 100, max_size + 100));
 625   RunTest(true, false, true);
 626 }
 627
 628 TEST_F(ScrollbarLayerTestMaxTextureSize, DelegatingRenderer) {
 629   scoped_ptr<TestWebGraphicsContext3D> context =
 630       TestWebGraphicsContext3D::Create();
 631   int max_size = 0;
 632   context->getIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
 633   SetScrollbarBounds(gfx::Size(max_size + 100, max_size + 100));
 634   RunTest(true, true, true);
 635 }
 636
 637 class FakeLayerTreeHost : public LayerTreeHost {
 638  public:
 639   FakeLayerTreeHost(FakeLayerTreeHostClient* client,
 640                     const LayerTreeSettings& settings)
 641       : LayerTreeHost(client, NULL, settings),
 642         next_id_(1),
 643         total_ui_resource_created_(0),
 644         total_ui_resource_deleted_(0) {
 645     InitializeSingleThreaded(client, base::MessageLoopProxy::current());
 646   }
 647
 648   virtual UIResourceId CreateUIResource(UIResourceClient* content) OVERRIDE {
 649     total_ui_resource_created_++;
 650     UIResourceId nid = next_id_++;
 651     ui_resource_bitmap_map_.insert(
 652         std::make_pair(nid, content->GetBitmap(nid, false)));
 653     return nid;
 654   }
 655
 656   // Deletes a UI resource.  May safely be called more than once.
 657   virtual void DeleteUIResource(UIResourceId id) OVERRIDE {
 658     UIResourceBitmapMap::iterator iter = ui_resource_bitmap_map_.find(id);
 659     if (iter != ui_resource_bitmap_map_.end()) {
 660       ui_resource_bitmap_map_.erase(iter);
 661       total_ui_resource_deleted_++;
 662     }
 663   }
 664
 665   size_t UIResourceCount() { return ui_resource_bitmap_map_.size(); }
 666   int TotalUIResourceDeleted() { return total_ui_resource_deleted_; }
 667   int TotalUIResourceCreated() { return total_ui_resource_created_; }
 668
 669   gfx::Size ui_resource_size(UIResourceId id) {
 670     UIResourceBitmapMap::iterator iter = ui_resource_bitmap_map_.find(id);
 671     if (iter != ui_resource_bitmap_map_.end())
 672       return iter->second.GetSize();
 673     return gfx::Size();
 674   }
 675
 676   UIResourceBitmap* ui_resource_bitmap(UIResourceId id) {
 677     UIResourceBitmapMap::iterator iter = ui_resource_bitmap_map_.find(id);
 678     if (iter != ui_resource_bitmap_map_.end())
 679       return &iter->second;
 680     return NULL;
 681   }
 682
 683  private:
 684   typedef base::hash_map<UIResourceId, UIResourceBitmap>
 685       UIResourceBitmapMap;
 686   UIResourceBitmapMap ui_resource_bitmap_map_;
 687
 688   int next_id_;
 689   int total_ui_resource_created_;
 690   int total_ui_resource_deleted_;
 691 };
 692
 693 class ScrollbarLayerTestResourceCreationAndRelease : public testing::Test {
 694  public:
 695   ScrollbarLayerTestResourceCreationAndRelease()
 696       : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 697
 698   void TestResourceUpload(int num_updates,
 699                           size_t expected_resources,
 700                           int expected_created,
 701                           int expected_deleted,
 702                           bool use_solid_color_scrollbar) {
 703     layer_tree_host_.reset(
 704         new FakeLayerTreeHost(&fake_client_, layer_tree_settings_));
 705
 706     scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, false));
 707     scoped_refptr<Layer> layer_tree_root = Layer::Create();
 708     scoped_refptr<Layer> content_layer = Layer::Create();
 709     scoped_refptr<Layer> scrollbar_layer;
 710     if (use_solid_color_scrollbar) {
 711       const int kThumbThickness = 3;
 712       const int kTrackStart = 0;
 713       const bool kIsLeftSideVerticalScrollbar = false;
 714       scrollbar_layer =
 715           SolidColorScrollbarLayer::Create(scrollbar->Orientation(),
 716                                            kThumbThickness,
 717                                            kTrackStart,
 718                                            kIsLeftSideVerticalScrollbar,
 719                                            layer_tree_root->id());
 720     } else {
 721       scrollbar_layer = PaintedScrollbarLayer::Create(scrollbar.Pass(),
 722                                                       layer_tree_root->id());
 723     }
 724     layer_tree_root->AddChild(content_layer);
 725     layer_tree_root->AddChild(scrollbar_layer);
 726
 727     layer_tree_host_->SetRootLayer(layer_tree_root);
 728
 729     scrollbar_layer->SetIsDrawable(true);
 730     scrollbar_layer->SetBounds(gfx::Size(100, 100));
 731     layer_tree_root->SetScrollOffset(gfx::Vector2d(10, 20));
 732     layer_tree_root->SetBounds(gfx::Size(100, 200));
 733     content_layer->SetBounds(gfx::Size(100, 200));
 734     scrollbar_layer->draw_properties().content_bounds = gfx::Size(100, 200);
 735     scrollbar_layer->draw_properties().visible_content_rect =
 736         gfx::Rect(0, 0, 100, 200);
 737     scrollbar_layer->CreateRenderSurface();
 738     scrollbar_layer->draw_properties().render_target = scrollbar_layer.get();
 739
 740     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 741     EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
 742
 743     ResourceUpdateQueue queue;
 744     gfx::Rect screen_space_clip_rect;
 745     OcclusionTracker<Layer> occlusion_tracker(screen_space_clip_rect);
 746
 747     scrollbar_layer->SavePaintProperties();
 748     for (int update_counter = 0; update_counter < num_updates; update_counter++)
 749       scrollbar_layer->Update(&queue, &occlusion_tracker);
 750
 751     // A non-solid-color scrollbar should have requested two textures.
 752     EXPECT_EQ(expected_resources, layer_tree_host_->UIResourceCount());
 753     EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
 754     EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 755
 756     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 757
 758     scrollbar_layer->ClearRenderSurface();
 759   }
 760
 761  protected:
 762   FakeLayerTreeHostClient fake_client_;
 763   LayerTreeSettings layer_tree_settings_;
 764   scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
 765 };
 766
 767 TEST_F(ScrollbarLayerTestResourceCreationAndRelease, ResourceUpload) {
 768   bool use_solid_color_scrollbars = false;
 769   TestResourceUpload(0, 0, 0, 0, use_solid_color_scrollbars);
 770   int num_updates[3] = {1, 5, 10};
 771   for (int j = 0; j < 3; j++) {
 772     TestResourceUpload(num_updates[j],
 773                        2,
 774                        num_updates[j] * 2,
 775                        (num_updates[j] - 1) * 2,
 776                        use_solid_color_scrollbars);
 777   }
 778 }
 779
 780 TEST_F(ScrollbarLayerTestResourceCreationAndRelease,
 781        SolidColorNoResourceUpload) {
 782   bool use_solid_color_scrollbars = true;
 783   TestResourceUpload(0, 0, 0, 0, use_solid_color_scrollbars);
 784   TestResourceUpload(1, 0, 0, 0, use_solid_color_scrollbars);
 785 }
 786
 787 TEST_F(ScrollbarLayerTestResourceCreationAndRelease, TestResourceUpdate) {
 788   FakeLayerTreeHostClient fake_client_(FakeLayerTreeHostClient::DIRECT_3D);
 789   LayerTreeSettings layer_tree_settings_;
 790   scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
 791
 792   layer_tree_host_.reset(
 793       new FakeLayerTreeHost(&fake_client_, layer_tree_settings_));
 794
 795   gfx::Point scrollbar_location(0, 185);
 796   scoped_refptr<Layer> layer_tree_root = Layer::Create();
 797   scoped_refptr<Layer> content_layer = Layer::Create();
 798   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
 799       FakePaintedScrollbarLayer::Create(false, true, layer_tree_root->id());
 800
 801   layer_tree_root->AddChild(content_layer);
 802   layer_tree_root->AddChild(scrollbar_layer);
 803
 804   layer_tree_host_->SetRootLayer(layer_tree_root);
 805
 806   scrollbar_layer->SetIsDrawable(true);
 807   scrollbar_layer->SetBounds(gfx::Size(100, 15));
 808   scrollbar_layer->SetPosition(scrollbar_location);
 809   layer_tree_root->SetBounds(gfx::Size(100, 200));
 810   content_layer->SetBounds(gfx::Size(100, 200));
 811
 812   scrollbar_layer->draw_properties().content_bounds = gfx::Size(100, 200);
 813   scrollbar_layer->draw_properties().visible_content_rect =
 814       gfx::Rect(0, 0, 100, 200);
 815
 816   scrollbar_layer->CreateRenderSurface();
 817   scrollbar_layer->draw_properties().render_target = scrollbar_layer.get();
 818
 819   testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 820   EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
 821
 822   ResourceUpdateQueue queue;
 823   gfx::Rect screen_space_clip_rect;
 824   size_t resource_count;
 825   int expected_created, expected_deleted;
 826   OcclusionTracker<Layer> occlusion_tracker(screen_space_clip_rect);
 827   scrollbar_layer->SavePaintProperties();
 828
 829   resource_count = 2;
 830   expected_created = 2;
 831   expected_deleted = 0;
 832   EXPECT_TRUE(scrollbar_layer->Update(&queue, &occlusion_tracker));
 833   EXPECT_NE(0, scrollbar_layer->track_resource_id());
 834   EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
 835   EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
 836   EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
 837   EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 838
 839   resource_count = 0;
 840   expected_created = 2;
 841   expected_deleted = 2;
 842   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
 843   EXPECT_TRUE(scrollbar_layer->Update(&queue, &occlusion_tracker));
 844   EXPECT_EQ(0, scrollbar_layer->track_resource_id());
 845   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
 846   EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
 847   EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
 848   EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 849
 850   resource_count = 0;
 851   expected_created = 2;
 852   expected_deleted = 2;
 853   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
 854   EXPECT_FALSE(scrollbar_layer->Update(&queue, &occlusion_tracker));
 855   EXPECT_EQ(0, scrollbar_layer->track_resource_id());
 856   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
 857   EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
 858   EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
 859   EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 860
 861   resource_count = 2;
 862   expected_created = 4;
 863   expected_deleted = 2;
 864   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
 865   EXPECT_TRUE(scrollbar_layer->Update(&queue, &occlusion_tracker));
 866   EXPECT_NE(0, scrollbar_layer->track_resource_id());
 867   EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
 868   EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
 869   EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
 870   EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 871
 872   resource_count = 1;
 873   expected_created = 5;
 874   expected_deleted = 4;
 875   scrollbar_layer->fake_scrollbar()->set_has_thumb(false);
 876   EXPECT_TRUE(scrollbar_layer->Update(&queue, &occlusion_tracker));
 877   EXPECT_NE(0, scrollbar_layer->track_resource_id());
 878   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
 879   EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
 880   EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
 881   EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 882
 883   resource_count = 0;
 884   expected_created = 5;
 885   expected_deleted = 5;
 886   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(0, 0, 0, 0));
 887   EXPECT_TRUE(scrollbar_layer->Update(&queue, &occlusion_tracker));
 888   EXPECT_EQ(0, scrollbar_layer->track_resource_id());
 889   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
 890   EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
 891   EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
 892   EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 893
 894   resource_count = 2;
 895   expected_created = 7;
 896   expected_deleted = 5;
 897   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
 898   scrollbar_layer->fake_scrollbar()->set_has_thumb(true);
 899   EXPECT_TRUE(scrollbar_layer->Update(&queue, &occlusion_tracker));
 900   EXPECT_NE(0, scrollbar_layer->track_resource_id());
 901   EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
 902
 903   resource_count = 1;
 904   expected_created = 8;
 905   expected_deleted = 7;
 906   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
 907   scrollbar_layer->fake_scrollbar()->set_has_thumb(false);
 908   scrollbar_layer->SetBounds(gfx::Size(90, 15));
 909   EXPECT_TRUE(scrollbar_layer->Update(&queue, &occlusion_tracker));
 910   EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
 911   EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
 912   EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 913   EXPECT_EQ(
 914       gfx::Size(90, 15),
 915       layer_tree_host_->ui_resource_size(scrollbar_layer->track_resource_id()));
 916
 917   scrollbar_layer->ResetNeedsDisplayForTesting();
 918   EXPECT_FALSE(scrollbar_layer->Update(&queue, &occlusion_tracker));
 919   EXPECT_NE(0, scrollbar_layer->track_resource_id());
 920   EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
 921   EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
 922   EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
 923   EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
 924
 925   testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 926   scrollbar_layer->ClearRenderSurface();
 927 }
 928
 929 class ScaledScrollbarLayerTestResourceCreation : public testing::Test {
 930  public:
 931   ScaledScrollbarLayerTestResourceCreation()
 932       : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 933
 934   void TestResourceUpload(const float test_scale) {
 935     layer_tree_host_.reset(
 936         new FakeLayerTreeHost(&fake_client_, layer_tree_settings_));
 937
 938     gfx::Point scrollbar_location(0, 185);
 939     scoped_refptr<Layer> layer_tree_root = Layer::Create();
 940     scoped_refptr<Layer> content_layer = Layer::Create();
 941     scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
 942         FakePaintedScrollbarLayer::Create(false, true, layer_tree_root->id());
 943
 944     layer_tree_root->AddChild(content_layer);
 945     layer_tree_root->AddChild(scrollbar_layer);
 946
 947     layer_tree_host_->SetRootLayer(layer_tree_root);
 948
 949     scrollbar_layer->SetIsDrawable(true);
 950     scrollbar_layer->SetBounds(gfx::Size(100, 15));
 951     scrollbar_layer->SetPosition(scrollbar_location);
 952     layer_tree_root->SetBounds(gfx::Size(100, 200));
 953     content_layer->SetBounds(gfx::Size(100, 200));
 954     gfx::SizeF scaled_size =
 955         gfx::ScaleSize(scrollbar_layer->bounds(), test_scale, test_scale);
 956     gfx::PointF scaled_location =
 957         gfx::ScalePoint(scrollbar_layer->position(), test_scale, test_scale);
 958     scrollbar_layer->draw_properties().content_bounds =
 959         gfx::Size(scaled_size.width(), scaled_size.height());
 960     scrollbar_layer->draw_properties().contents_scale_x = test_scale;
 961     scrollbar_layer->draw_properties().contents_scale_y = test_scale;
 962     scrollbar_layer->draw_properties().visible_content_rect =
 963         gfx::Rect(scaled_location.x(),
 964                   scaled_location.y(),
 965                   scaled_size.width(),
 966                   scaled_size.height());
 967     scrollbar_layer->CreateRenderSurface();
 968     scrollbar_layer->draw_properties().render_target = scrollbar_layer.get();
 969
 970     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 971     EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
 972
 973     ResourceUpdateQueue queue;
 974     gfx::Rect screen_space_clip_rect;
 975     OcclusionTracker<Layer> occlusion_tracker(screen_space_clip_rect);
 976     scrollbar_layer->SavePaintProperties();
 977     scrollbar_layer->Update(&queue, &occlusion_tracker);
 978
 979     // Verify that we have not generated any content uploads that are larger
 980     // than their destination textures.
 981
 982     gfx::Size track_size = layer_tree_host_->ui_resource_size(
 983         scrollbar_layer->track_resource_id());
 984     gfx::Size thumb_size = layer_tree_host_->ui_resource_size(
 985         scrollbar_layer->thumb_resource_id());
 986
 987     EXPECT_LE(track_size.width(), scrollbar_layer->content_bounds().width());
 988     EXPECT_LE(track_size.height(), scrollbar_layer->content_bounds().height());
 989     EXPECT_LE(thumb_size.width(), scrollbar_layer->content_bounds().width());
 990     EXPECT_LE(thumb_size.height(), scrollbar_layer->content_bounds().height());
 991
 992     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 993
 994     scrollbar_layer->ClearRenderSurface();
 995   }
 996
 997  protected:
 998   FakeLayerTreeHostClient fake_client_;
 999   LayerTreeSettings layer_tree_settings_;
1000   scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
1001 };
1002
1003 TEST_F(ScaledScrollbarLayerTestResourceCreation, ScaledResourceUpload) {
1004   // Pick a test scale that moves the scrollbar's (non-zero) position to
1005   // a non-pixel-aligned location.
1006   TestResourceUpload(.041f);
1007   TestResourceUpload(1.41f);
1008   TestResourceUpload(4.1f);
1009 }
1010
1011 class ScaledScrollbarLayerTestScaledRasterization : public testing::Test {
1012  public:
1013   ScaledScrollbarLayerTestScaledRasterization()
1014       : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
1015
1016   void TestScale(const gfx::Rect scrollbar_rect, const float test_scale) {
1017     layer_tree_host_.reset(
1018         new FakeLayerTreeHost(&fake_client_, layer_tree_settings_));
1019
1020     bool paint_during_update = true;
1021     bool has_thumb = false;
1022     scoped_refptr<Layer> layer_tree_root = Layer::Create();
1023     scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
1024         FakePaintedScrollbarLayer::Create(paint_during_update,
1025                                           has_thumb,
1026                                           layer_tree_root->id());
1027
1028     layer_tree_root->AddChild(scrollbar_layer);
1029
1030     layer_tree_host_->SetRootLayer(layer_tree_root);
1031
1032     scrollbar_layer->SetBounds(scrollbar_rect.size());
1033     scrollbar_layer->SetPosition(scrollbar_rect.origin());
1034     scrollbar_layer->fake_scrollbar()->set_location(scrollbar_rect.origin());
1035     scrollbar_layer->fake_scrollbar()->set_track_rect(scrollbar_rect);
1036     gfx::SizeF scaled_size =
1037         gfx::ScaleSize(scrollbar_layer->bounds(), test_scale, test_scale);
1038     gfx::PointF scaled_location =
1039         gfx::ScalePoint(scrollbar_layer->position(), test_scale, test_scale);
1040     scrollbar_layer->draw_properties().content_bounds =
1041         gfx::Size(scaled_size.width(), scaled_size.height());
1042     scrollbar_layer->draw_properties().contents_scale_x = test_scale;
1043     scrollbar_layer->draw_properties().contents_scale_y = test_scale;
1044     scrollbar_layer->draw_properties().visible_content_rect =
1045         gfx::Rect(scaled_location.x(),
1046                   scaled_location.y(),
1047                   scaled_size.width(),
1048                   scaled_size.height());
1049
1050     ResourceUpdateQueue queue;
1051     gfx::Rect screen_space_clip_rect;
1052     OcclusionTracker<Layer> occlusion_tracker(screen_space_clip_rect);
1053     scrollbar_layer->SavePaintProperties();
1054
1055     scrollbar_layer->Update(&queue, &occlusion_tracker);
1056
1057     UIResourceBitmap* bitmap = layer_tree_host_->ui_resource_bitmap(
1058         scrollbar_layer->track_resource_id());
1059
1060     DCHECK(bitmap);
1061
1062     AutoLockUIResourceBitmap locked_bitmap(*bitmap);
1063
1064     const SkColor* pixels =
1065         reinterpret_cast<const SkColor*>(locked_bitmap.GetPixels());
1066     SkColor color = argb_to_skia(
1067         scrollbar_layer->fake_scrollbar()->paint_fill_color());
1068     int width = bitmap->GetSize().width();
1069     int height = bitmap->GetSize().height();
1070
1071     // Make sure none of the corners of the bitmap were inadvertently clipped.
1072     EXPECT_EQ(color, pixels[0])
1073         << "Top left pixel doesn't match scrollbar color.";
1074
1075     EXPECT_EQ(color, pixels[width - 1])
1076         << "Top right pixel doesn't match scrollbar color.";
1077
1078     EXPECT_EQ(color, pixels[width * (height - 1)])
1079         << "Bottom left pixel doesn't match scrollbar color.";
1080
1081     EXPECT_EQ(color, pixels[width * height - 1])
1082         << "Bottom right pixel doesn't match scrollbar color.";
1083   }
1084
1085  protected:
1086   // On Android, Skia uses ABGR
1087   static SkColor argb_to_skia(SkColor c) {
1088       return (SkColorGetA(c) << SK_A32_SHIFT) |
1089              (SkColorGetR(c) << SK_R32_SHIFT) |
1090              (SkColorGetG(c) << SK_G32_SHIFT) |
1091              (SkColorGetB(c) << SK_B32_SHIFT);
1092   }
1093
1094   FakeLayerTreeHostClient fake_client_;
1095   LayerTreeSettings layer_tree_settings_;
1096   scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
1097 };
1098
1099 TEST_F(ScaledScrollbarLayerTestScaledRasterization, TestLostPrecisionInClip) {
1100   // Try rasterization at coordinates and scale that caused problematic
1101   // rounding and clipping errors.
1102   // Vertical Scrollbars.
1103   TestScale(gfx::Rect(1240, 0, 15, 1333), 2.7754839f);
1104   TestScale(gfx::Rect(1240, 0, 15, 677), 2.46677136f);
1105
1106   // Horizontal Scrollbars.
1107   TestScale(gfx::Rect(0, 1240, 1333, 15), 2.7754839f);
1108   TestScale(gfx::Rect(0, 1240, 677, 15), 2.46677136f);
1109 }
1110
1111 }  // namespace
1112 }  // namespace cc