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/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);
  35   SharedQuadState* shared_state = quad_sink.CreateSharedQuadState();
  36   shared_state->SetAll(gfx::Transform(),
  37                        rect.size(),
  38                        rect,
  39                        rect,
  40                        false,
  41                        1,
  42                        SkXfermode::kSrcOver_Mode);
  43   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
  44   quad->SetNew(shared_state, rect, rect, color, false);
  45   SolidColorDrawQuad* quad_ptr = quad.get();
  46   quad_sink.Append(quad.PassAs<DrawQuad>());
  47   return quad_ptr;
  48 }
  49
  50 SolidColorDrawQuad* AddClippedQuad(TestRenderPass* pass,
  51                                    const gfx::Rect& rect,
  52                                    SkColor color) {
  53   MockQuadCuller quad_sink(pass);
  54   SharedQuadState* shared_state = quad_sink.CreateSharedQuadState();
  55   shared_state->SetAll(gfx::Transform(),
  56                        rect.size(),
  57                        rect,
  58                        rect,
  59                        true,
  60                        1,
  61                        SkXfermode::kSrcOver_Mode);
  62   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
  63   quad->SetNew(shared_state, rect, rect, color, false);
  64   SolidColorDrawQuad* quad_ptr = quad.get();
  65   quad_sink.Append(quad.PassAs<DrawQuad>());
  66   return quad_ptr;
  67 }
  68
  69 SolidColorDrawQuad* AddTransformedQuad(TestRenderPass* pass,
  70                                        const gfx::Rect& rect,
  71                                        SkColor color,
  72                                        const gfx::Transform& transform) {
  73   MockQuadCuller quad_sink(pass);
  74   SharedQuadState* shared_state = quad_sink.CreateSharedQuadState();
  75   shared_state->SetAll(
  76       transform, rect.size(), rect, rect, false, 1, SkXfermode::kSrcOver_Mode);
  77   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
  78   quad->SetNew(shared_state, rect, rect, color, false);
  79   SolidColorDrawQuad* quad_ptr = quad.get();
  80   quad_sink.Append(quad.PassAs<DrawQuad>());
  81   return quad_ptr;
  82 }
  83
  84 void AddRenderPassQuad(TestRenderPass* to_pass,
  85                        TestRenderPass* contributing_pass) {
  86   MockQuadCuller quad_sink(to_pass);
  87   gfx::Rect output_rect = contributing_pass->output_rect;
  88   SharedQuadState* shared_state = quad_sink.CreateSharedQuadState();
  89   shared_state->SetAll(gfx::Transform(),
  90                        output_rect.size(),
  91                        output_rect,
  92                        output_rect,
  93                        false,
  94                        1,
  95                        SkXfermode::kSrcOver_Mode);
  96   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
  97   quad->SetNew(shared_state,
  98                output_rect,
  99                output_rect,
 100                contributing_pass->id,
 101                false,
 102                0,
 103                output_rect,
 104                gfx::RectF(),
 105                FilterOperations(),
 106                FilterOperations());
 107   quad_sink.Append(quad.PassAs<DrawQuad>());
 108 }
 109
 110 void AddRenderPassQuad(TestRenderPass* to_pass,
 111                        TestRenderPass* contributing_pass,
 112                        ResourceProvider::ResourceId mask_resource_id,
 113                        const FilterOperations& filters,
 114                        gfx::Transform transform) {
 115   MockQuadCuller quad_sink(to_pass);
 116   gfx::Rect output_rect = contributing_pass->output_rect;
 117   SharedQuadState* shared_state = quad_sink.CreateSharedQuadState();
 118   shared_state->SetAll(transform,
 119                        output_rect.size(),
 120                        output_rect,
 121                        output_rect,
 122                        false,
 123                        1,
 124                        SkXfermode::kSrcOver_Mode);
 125   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
 126   quad->SetNew(shared_state,
 127                output_rect,
 128                output_rect,
 129                contributing_pass->id,
 130                false,
 131                mask_resource_id,
 132                output_rect,
 133                gfx::RectF(),
 134                filters,
 135                FilterOperations());
 136   quad_sink.Append(quad.PassAs<DrawQuad>());
 137 }
 138
 139 }  // namespace cc