cc/test/render_pass_test_utils.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 "cc/test/render_pass_test_utils.h"
   6
   7 #include "cc/layers/quad_sink.h"
   8 #include "cc/quads/render_pass_draw_quad.h"
   9 #include "cc/quads/shared_quad_state.h"
  10 #include "cc/quads/solid_color_draw_quad.h"
  11 #include "cc/resources/resource_provider.h"
  12 #include "cc/test/mock_quad_culler.h"
  13 #include "cc/test/render_pass_test_common.h"
  14 #include "third_party/skia/include/core/SkColor.h"
  15 #include "third_party/skia/include/core/SkImageFilter.h"
  16 #include "ui/gfx/rect.h"
  17
  18 namespace cc {
  19
  20 TestRenderPass* AddRenderPass(RenderPassList* pass_list,
  21                               RenderPass::Id id,
  22                               const gfx::Rect& output_rect,
  23                               const gfx::Transform& root_transform) {
  24   scoped_ptr<TestRenderPass> pass(TestRenderPass::Create());
  25   pass->SetNew(id, output_rect, output_rect, root_transform);
  26   TestRenderPass* saved = pass.get();
  27   pass_list->push_back(pass.PassAs<RenderPass>());
  28   return saved;
  29 }
  30
  31 SolidColorDrawQuad* AddQuad(TestRenderPass* pass,
  32                             const gfx::Rect& rect,
  33                             SkColor color) {
  34   MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
  35   SharedQuadState* shared_state =
  36       quad_sink.UseSharedQuadState(SharedQuadState::Create());
  37   shared_state->SetAll(gfx::Transform(),
  38                        rect.size(),
  39                        rect,
  40                        rect,
  41                        false,
  42                        1,
  43                        SkXfermode::kSrcOver_Mode);
  44   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
  45   quad->SetNew(shared_state, rect, rect, color, false);
  46   SolidColorDrawQuad* quad_ptr = quad.get();
  47   quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
  48   return quad_ptr;
  49 }
  50
  51 SolidColorDrawQuad* AddClippedQuad(TestRenderPass* pass,
  52                                    const gfx::Rect& rect,
  53                                    SkColor color) {
  54   MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
  55   SharedQuadState* shared_state =
  56       quad_sink.UseSharedQuadState(SharedQuadState::Create());
  57   shared_state->SetAll(gfx::Transform(),
  58                        rect.size(),
  59                        rect,
  60                        rect,
  61                        true,
  62                        1,
  63                        SkXfermode::kSrcOver_Mode);
  64   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
  65   quad->SetNew(shared_state, rect, rect, color, false);
  66   SolidColorDrawQuad* quad_ptr = quad.get();
  67   quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
  68   return quad_ptr;
  69 }
  70
  71 SolidColorDrawQuad* AddTransformedQuad(TestRenderPass* pass,
  72                                        const gfx::Rect& rect,
  73                                        SkColor color,
  74                                        const gfx::Transform& transform) {
  75   MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
  76   SharedQuadState* shared_state =
  77       quad_sink.UseSharedQuadState(SharedQuadState::Create());
  78   shared_state->SetAll(
  79       transform, rect.size(), rect, rect, false, 1, SkXfermode::kSrcOver_Mode);
  80   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
  81   quad->SetNew(shared_state, rect, rect, color, false);
  82   SolidColorDrawQuad* quad_ptr = quad.get();
  83   quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
  84   return quad_ptr;
  85 }
  86
  87 void AddRenderPassQuad(TestRenderPass* to_pass,
  88                        TestRenderPass* contributing_pass) {
  89   MockQuadCuller quad_sink(&to_pass->quad_list,
  90                            &to_pass->shared_quad_state_list);
  91   gfx::Rect output_rect = contributing_pass->output_rect;
  92   SharedQuadState* shared_state =
  93       quad_sink.UseSharedQuadState(SharedQuadState::Create());
  94   shared_state->SetAll(gfx::Transform(),
  95                        output_rect.size(),
  96                        output_rect,
  97                        output_rect,
  98                        false,
  99                        1,
 100                        SkXfermode::kSrcOver_Mode);
 101   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
 102   quad->SetNew(shared_state,
 103                output_rect,
 104                output_rect,
 105                contributing_pass->id,
 106                false,
 107                0,
 108                output_rect,
 109                gfx::RectF(),
 110                FilterOperations(),
 111                FilterOperations());
 112   quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
 113 }
 114
 115 void AddRenderPassQuad(TestRenderPass* to_pass,
 116                        TestRenderPass* contributing_pass,
 117                        ResourceProvider::ResourceId mask_resource_id,
 118                        const FilterOperations& filters,
 119                        gfx::Transform transform) {
 120   MockQuadCuller quad_sink(&to_pass->quad_list,
 121                            &to_pass->shared_quad_state_list);
 122   gfx::Rect output_rect = contributing_pass->output_rect;
 123   SharedQuadState* shared_state =
 124       quad_sink.UseSharedQuadState(SharedQuadState::Create());
 125   shared_state->SetAll(transform,
 126                        output_rect.size(),
 127                        output_rect,
 128                        output_rect,
 129                        false,
 130                        1,
 131                        SkXfermode::kSrcOver_Mode);
 132   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
 133   quad->SetNew(shared_state,
 134                output_rect,
 135                output_rect,
 136                contributing_pass->id,
 137                false,
 138                mask_resource_id,
 139                output_rect,
 140                gfx::RectF(),
 141                filters,
 142                FilterOperations());
 143   quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
 144 }
 145
 146 }  // namespace cc