Home | History | Annotate | Download | only in test
      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
    144