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