src/cc/layers/picture_image_layer_impl_unittest.cc

   1 // Copyright 2013 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/picture_image_layer_impl.h"
   6
   7 #include "cc/layers/append_quads_data.h"
   8 #include "cc/resources/tile_priority.h"
   9 #include "cc/test/fake_impl_proxy.h"
  10 #include "cc/test/fake_layer_tree_host_impl.h"
  11 #include "cc/test/fake_output_surface.h"
  12 #include "cc/test/fake_picture_layer_tiling_client.h"
  13 #include "cc/test/impl_side_painting_settings.h"
  14 #include "cc/test/mock_quad_culler.h"
  15 #include "cc/trees/layer_tree_impl.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace cc {
  19 namespace {
  20
  21 class TestablePictureImageLayerImpl : public PictureImageLayerImpl {
  22  public:
  23   TestablePictureImageLayerImpl(LayerTreeImpl* tree_impl, int id)
  24       : PictureImageLayerImpl(tree_impl, id) {
  25   }
  26
  27   PictureLayerTilingSet* tilings() { return tilings_.get(); }
  28
  29   friend class PictureImageLayerImplTest;
  30 };
  31
  32 class PictureImageLayerImplTest : public testing::Test {
  33  public:
  34   PictureImageLayerImplTest()
  35       : host_impl_(ImplSidePaintingSettings(), &proxy_) {
  36     tiling_client_.SetTileSize(ImplSidePaintingSettings().default_tile_size);
  37     host_impl_.CreatePendingTree();
  38     host_impl_.InitializeRenderer(CreateFakeOutputSurface());
  39   }
  40
  41   scoped_ptr<TestablePictureImageLayerImpl> CreateLayer(int id,
  42                                                         WhichTree which_tree) {
  43     LayerTreeImpl* tree = NULL;
  44     switch (which_tree) {
  45       case ACTIVE_TREE:
  46         tree = host_impl_.active_tree();
  47         break;
  48       case PENDING_TREE:
  49         tree = host_impl_.pending_tree();
  50         break;
  51       case NUM_TREES:
  52         NOTREACHED();
  53         break;
  54     }
  55     TestablePictureImageLayerImpl* layer =
  56         new TestablePictureImageLayerImpl(tree, id);
  57     layer->SetBounds(gfx::Size(100, 200));
  58     layer->tilings_.reset(new PictureLayerTilingSet(&tiling_client_,
  59                                                     layer->bounds()));
  60     layer->pile_ = tiling_client_.pile();
  61     return make_scoped_ptr(layer);
  62   }
  63
  64   void UpdateDrawProperties() {
  65     host_impl_.pending_tree()->UpdateDrawProperties();
  66   }
  67
  68  protected:
  69   FakeImplProxy proxy_;
  70   FakeLayerTreeHostImpl host_impl_;
  71   FakePictureLayerTilingClient tiling_client_;
  72 };
  73
  74 TEST_F(PictureImageLayerImplTest, CalculateContentsScale) {
  75   scoped_ptr<TestablePictureImageLayerImpl> layer(CreateLayer(1, PENDING_TREE));
  76   layer->SetDrawsContent(true);
  77
  78   float contents_scale_x;
  79   float contents_scale_y;
  80   gfx::Size content_bounds;
  81   layer->CalculateContentsScale(2.f, 3.f, 4.f, false,
  82                                 &contents_scale_x, &contents_scale_y,
  83                                 &content_bounds);
  84   EXPECT_FLOAT_EQ(1.f, contents_scale_x);
  85   EXPECT_FLOAT_EQ(1.f, contents_scale_y);
  86   EXPECT_EQ(layer->bounds(), content_bounds);
  87 }
  88
  89 TEST_F(PictureImageLayerImplTest, AreVisibleResourcesReady) {
  90   scoped_ptr<TestablePictureImageLayerImpl> layer(CreateLayer(1, PENDING_TREE));
  91   layer->SetBounds(gfx::Size(100, 200));
  92   layer->SetDrawsContent(true);
  93
  94   UpdateDrawProperties();
  95
  96   float contents_scale_x;
  97   float contents_scale_y;
  98   gfx::Size content_bounds;
  99   layer->CalculateContentsScale(2.f, 3.f, 4.f, false,
 100                                 &contents_scale_x, &contents_scale_y,
 101                                 &content_bounds);
 102   layer->UpdateTilePriorities();
 103
 104   EXPECT_TRUE(layer->AreVisibleResourcesReady());
 105 }
 106
 107 TEST_F(PictureImageLayerImplTest, IgnoreIdealContentScale) {
 108   scoped_ptr<TestablePictureImageLayerImpl> pending_layer(
 109       CreateLayer(1, PENDING_TREE));
 110   pending_layer->SetDrawsContent(true);
 111
 112   // Set PictureLayerImpl::ideal_contents_scale_ to 2.f which is not equal
 113   // to the content scale used by PictureImageLayerImpl.
 114   const float suggested_ideal_contents_scale = 2.f;
 115   const float device_scale_factor = 3.f;
 116   const float page_scale_factor = 4.f;
 117   const bool animating_transform_to_screen = false;
 118   float contents_scale_x;
 119   float contents_scale_y;
 120   gfx::Size content_bounds;
 121   pending_layer->CalculateContentsScale(suggested_ideal_contents_scale,
 122                                         device_scale_factor,
 123                                         page_scale_factor,
 124                                         animating_transform_to_screen,
 125                                         &contents_scale_x,
 126                                         &contents_scale_y,
 127                                         &content_bounds);
 128
 129   // Push to active layer.
 130   host_impl_.ActivatePendingTree();
 131   scoped_ptr<TestablePictureImageLayerImpl> active_layer(
 132       CreateLayer(1, ACTIVE_TREE));
 133   pending_layer->PushPropertiesTo(active_layer.get());
 134   active_layer->CalculateContentsScale(suggested_ideal_contents_scale,
 135                                        device_scale_factor,
 136                                        page_scale_factor,
 137                                        animating_transform_to_screen,
 138                                        &contents_scale_x,
 139                                        &contents_scale_y,
 140                                        &content_bounds);
 141
 142   // Create tile and resource.
 143   active_layer->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 144   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
 145       active_layer->tilings()->tiling_at(0)->AllTilesForTesting(),
 146       host_impl_.resource_provider());
 147
 148   // Draw.
 149   active_layer->draw_properties().visible_content_rect =
 150       gfx::Rect(active_layer->bounds());
 151   MockQuadCuller quad_culler;
 152   AppendQuadsData data;
 153   active_layer->WillDraw(DRAW_MODE_SOFTWARE, NULL);
 154   active_layer->AppendQuads(&quad_culler, &data);
 155   active_layer->DidDraw(NULL);
 156
 157   EXPECT_EQ(DrawQuad::TILED_CONTENT, quad_culler.quad_list()[0]->material);
 158
 159   // Tiles are ready at correct scale, so should not set had_incomplete_tile.
 160   EXPECT_FALSE(data.had_incomplete_tile);
 161 }
 162
 163 }  // namespace
 164 }  // namespace cc