cc/surfaces/surfaces_pixeltest.cc

   1 // Copyright 2014 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/output/compositor_frame.h"
   6 #include "cc/quads/render_pass.h"
   7 #include "cc/quads/solid_color_draw_quad.h"
   8 #include "cc/quads/surface_draw_quad.h"
   9 #include "cc/surfaces/surface.h"
  10 #include "cc/surfaces/surface_aggregator.h"
  11 #include "cc/surfaces/surface_manager.h"
  12 #include "cc/test/pixel_comparator.h"
  13 #include "cc/test/pixel_test.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 #if !defined(OS_ANDROID)
  17
  18 namespace cc {
  19 namespace {
  20
  21 class SurfacesPixelTest : public RendererPixelTest<GLRenderer> {
  22  protected:
  23   SurfaceManager manager_;
  24 };
  25
  26 SharedQuadState* CreateAndAppendTestSharedQuadState(
  27     RenderPass* render_pass,
  28     const gfx::Transform& transform,
  29     const gfx::Size& size) {
  30   const gfx::Size content_bounds = size;
  31   const gfx::Rect visible_content_rect = gfx::Rect(size);
  32   const gfx::Rect clip_rect = gfx::Rect(size);
  33   bool is_clipped = false;
  34   float opacity = 1.f;
  35   const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
  36   SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState();
  37   shared_state->SetAll(transform,
  38                        content_bounds,
  39                        visible_content_rect,
  40                        clip_rect,
  41                        is_clipped,
  42                        opacity,
  43                        blend_mode);
  44   return shared_state;
  45 }
  46
  47 // Draws a very simple frame with no surface references.
  48 TEST_F(SurfacesPixelTest, DrawSimpleFrame) {
  49   gfx::Rect rect(device_viewport_size_);
  50   RenderPass::Id id(1, 1);
  51   scoped_ptr<RenderPass> pass = RenderPass::Create();
  52   pass->SetNew(id, rect, rect, gfx::Transform());
  53
  54   CreateAndAppendTestSharedQuadState(
  55       pass.get(), gfx::Transform(), device_viewport_size_);
  56
  57   scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
  58   bool force_anti_aliasing_off = false;
  59   color_quad->SetNew(pass->shared_quad_state_list.back(),
  60                      rect,
  61                      rect,
  62                      SK_ColorGREEN,
  63                      force_anti_aliasing_off);
  64   pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
  65
  66   scoped_ptr<DelegatedFrameData> delegated_frame_data(new DelegatedFrameData);
  67   delegated_frame_data->render_pass_list.push_back(pass.Pass());
  68
  69   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
  70   root_frame->delegated_frame_data = delegated_frame_data.Pass();
  71
  72   Surface root_surface(&manager_, NULL, device_viewport_size_);
  73   root_surface.QueueFrame(root_frame.Pass());
  74
  75   SurfaceAggregator aggregator(&manager_);
  76   scoped_ptr<CompositorFrame> aggregated_frame =
  77       aggregator.Aggregate(root_surface.surface_id());
  78
  79   bool discard_alpha = false;
  80   ExactPixelComparator pixel_comparator(discard_alpha);
  81   RenderPassList* pass_list =
  82       &aggregated_frame->delegated_frame_data->render_pass_list;
  83   EXPECT_TRUE(RunPixelTest(pass_list,
  84                            base::FilePath(FILE_PATH_LITERAL("green.png")),
  85                            pixel_comparator));
  86 }
  87
  88 // Draws a frame with simple surface embedding.
  89 TEST_F(SurfacesPixelTest, DrawSimpleAggregatedFrame) {
  90   gfx::Size child_size(200, 100);
  91   Surface child_surface(&manager_, NULL, child_size);
  92   Surface root_surface(&manager_, NULL, device_viewport_size_);
  93
  94   {
  95     gfx::Rect rect(device_viewport_size_);
  96     RenderPass::Id id(1, 1);
  97     scoped_ptr<RenderPass> pass = RenderPass::Create();
  98     pass->SetNew(id, rect, rect, gfx::Transform());
  99
 100     CreateAndAppendTestSharedQuadState(
 101         pass.get(), gfx::Transform(), device_viewport_size_);
 102
 103     scoped_ptr<SurfaceDrawQuad> surface_quad = SurfaceDrawQuad::Create();
 104     surface_quad->SetNew(pass->shared_quad_state_list.back(),
 105                          gfx::Rect(child_size),
 106                          gfx::Rect(child_size),
 107                          child_surface.surface_id());
 108     pass->quad_list.push_back(surface_quad.PassAs<DrawQuad>());
 109
 110     scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
 111     bool force_anti_aliasing_off = false;
 112     color_quad->SetNew(pass->shared_quad_state_list.back(),
 113                        rect,
 114                        rect,
 115                        SK_ColorYELLOW,
 116                        force_anti_aliasing_off);
 117     pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
 118
 119     scoped_ptr<DelegatedFrameData> delegated_frame_data(new DelegatedFrameData);
 120     delegated_frame_data->render_pass_list.push_back(pass.Pass());
 121
 122     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
 123     root_frame->delegated_frame_data = delegated_frame_data.Pass();
 124
 125     root_surface.QueueFrame(root_frame.Pass());
 126   }
 127
 128   {
 129     gfx::Rect rect(child_size);
 130     RenderPass::Id id(1, 1);
 131     scoped_ptr<RenderPass> pass = RenderPass::Create();
 132     pass->SetNew(id, rect, rect, gfx::Transform());
 133
 134     CreateAndAppendTestSharedQuadState(
 135         pass.get(), gfx::Transform(), child_size);
 136
 137     scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
 138     bool force_anti_aliasing_off = false;
 139     color_quad->SetNew(pass->shared_quad_state_list.back(),
 140                        rect,
 141                        rect,
 142                        SK_ColorBLUE,
 143                        force_anti_aliasing_off);
 144     pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
 145
 146     scoped_ptr<DelegatedFrameData> delegated_frame_data(new DelegatedFrameData);
 147     delegated_frame_data->render_pass_list.push_back(pass.Pass());
 148
 149     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
 150     child_frame->delegated_frame_data = delegated_frame_data.Pass();
 151
 152     child_surface.QueueFrame(child_frame.Pass());
 153   }
 154
 155   SurfaceAggregator aggregator(&manager_);
 156   scoped_ptr<CompositorFrame> aggregated_frame =
 157       aggregator.Aggregate(root_surface.surface_id());
 158
 159   bool discard_alpha = false;
 160   ExactPixelComparator pixel_comparator(discard_alpha);
 161   RenderPassList* pass_list =
 162       &aggregated_frame->delegated_frame_data->render_pass_list;
 163   EXPECT_TRUE(RunPixelTest(pass_list,
 164                            base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")),
 165                            pixel_comparator));
 166 }
 167
 168 // Tests a surface quad that has a non-identity transform into its pass.
 169 TEST_F(SurfacesPixelTest, DrawAggregatedFrameWithSurfaceTransforms) {
 170   gfx::Size child_size(100, 200);
 171   gfx::Size quad_size(100, 100);
 172   // Structure:
 173   // root (200x200) -> left_child (100x200 @ 0x0,
 174   //                   right_child (100x200 @ 0x100)
 175   //   left_child -> top_green_quad (100x100 @ 0x0),
 176   //                 bottom_blue_quad (100x100 @ 0x100)
 177   //   right_child -> top_blue_quad (100x100 @ 0x0),
 178   //                  bottom_green_quad (100x100 @ 0x100)
 179   Surface left_child(&manager_, NULL, child_size);
 180   Surface right_child(&manager_, NULL, child_size);
 181   Surface root_surface(&manager_, NULL, device_viewport_size_);
 182
 183   {
 184     gfx::Rect rect(device_viewport_size_);
 185     RenderPass::Id id(1, 1);
 186     scoped_ptr<RenderPass> pass = RenderPass::Create();
 187     pass->SetNew(id, rect, rect, gfx::Transform());
 188
 189     gfx::Transform surface_transform;
 190     CreateAndAppendTestSharedQuadState(
 191         pass.get(), surface_transform, device_viewport_size_);
 192
 193     scoped_ptr<SurfaceDrawQuad> left_surface_quad = SurfaceDrawQuad::Create();
 194     left_surface_quad->SetNew(pass->shared_quad_state_list.back(),
 195                               gfx::Rect(child_size),
 196                               gfx::Rect(child_size),
 197                               left_child.surface_id());
 198     pass->quad_list.push_back(left_surface_quad.PassAs<DrawQuad>());
 199
 200     surface_transform.Translate(100, 0);
 201     CreateAndAppendTestSharedQuadState(
 202         pass.get(), surface_transform, device_viewport_size_);
 203
 204     scoped_ptr<SurfaceDrawQuad> right_surface_quad = SurfaceDrawQuad::Create();
 205     right_surface_quad->SetNew(pass->shared_quad_state_list.back(),
 206                                gfx::Rect(child_size),
 207                                gfx::Rect(child_size),
 208                                right_child.surface_id());
 209     pass->quad_list.push_back(right_surface_quad.PassAs<DrawQuad>());
 210
 211     scoped_ptr<DelegatedFrameData> delegated_frame_data(new DelegatedFrameData);
 212     delegated_frame_data->render_pass_list.push_back(pass.Pass());
 213
 214     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
 215     root_frame->delegated_frame_data = delegated_frame_data.Pass();
 216
 217     root_surface.QueueFrame(root_frame.Pass());
 218   }
 219
 220   {
 221     gfx::Rect rect(child_size);
 222     RenderPass::Id id(1, 1);
 223     scoped_ptr<RenderPass> pass = RenderPass::Create();
 224     pass->SetNew(id, rect, rect, gfx::Transform());
 225
 226     CreateAndAppendTestSharedQuadState(
 227         pass.get(), gfx::Transform(), child_size);
 228
 229     scoped_ptr<SolidColorDrawQuad> top_color_quad =
 230         SolidColorDrawQuad::Create();
 231     bool force_anti_aliasing_off = false;
 232     top_color_quad->SetNew(pass->shared_quad_state_list.back(),
 233                            gfx::Rect(quad_size),
 234                            gfx::Rect(quad_size),
 235                            SK_ColorGREEN,
 236                            force_anti_aliasing_off);
 237     pass->quad_list.push_back(top_color_quad.PassAs<DrawQuad>());
 238
 239     scoped_ptr<SolidColorDrawQuad> bottom_color_quad =
 240         SolidColorDrawQuad::Create();
 241     bottom_color_quad->SetNew(pass->shared_quad_state_list.back(),
 242                               gfx::Rect(0, 100, 100, 100),
 243                               gfx::Rect(0, 100, 100, 100),
 244                               SK_ColorBLUE,
 245                               force_anti_aliasing_off);
 246     pass->quad_list.push_back(bottom_color_quad.PassAs<DrawQuad>());
 247
 248     scoped_ptr<DelegatedFrameData> delegated_frame_data(new DelegatedFrameData);
 249     delegated_frame_data->render_pass_list.push_back(pass.Pass());
 250
 251     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
 252     child_frame->delegated_frame_data = delegated_frame_data.Pass();
 253
 254     left_child.QueueFrame(child_frame.Pass());
 255   }
 256
 257   {
 258     gfx::Rect rect(child_size);
 259     RenderPass::Id id(1, 1);
 260     scoped_ptr<RenderPass> pass = RenderPass::Create();
 261     pass->SetNew(id, rect, rect, gfx::Transform());
 262
 263     CreateAndAppendTestSharedQuadState(
 264         pass.get(), gfx::Transform(), child_size);
 265
 266     scoped_ptr<SolidColorDrawQuad> top_color_quad =
 267         SolidColorDrawQuad::Create();
 268     bool force_anti_aliasing_off = false;
 269     top_color_quad->SetNew(pass->shared_quad_state_list.back(),
 270                            gfx::Rect(quad_size),
 271                            gfx::Rect(quad_size),
 272                            SK_ColorBLUE,
 273                            force_anti_aliasing_off);
 274     pass->quad_list.push_back(top_color_quad.PassAs<DrawQuad>());
 275
 276     scoped_ptr<SolidColorDrawQuad> bottom_color_quad =
 277         SolidColorDrawQuad::Create();
 278     bottom_color_quad->SetNew(pass->shared_quad_state_list.back(),
 279                               gfx::Rect(0, 100, 100, 100),
 280                               gfx::Rect(0, 100, 100, 100),
 281                               SK_ColorGREEN,
 282                               force_anti_aliasing_off);
 283     pass->quad_list.push_back(bottom_color_quad.PassAs<DrawQuad>());
 284
 285     scoped_ptr<DelegatedFrameData> delegated_frame_data(new DelegatedFrameData);
 286     delegated_frame_data->render_pass_list.push_back(pass.Pass());
 287
 288     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
 289     child_frame->delegated_frame_data = delegated_frame_data.Pass();
 290
 291     right_child.QueueFrame(child_frame.Pass());
 292   }
 293
 294   SurfaceAggregator aggregator(&manager_);
 295   scoped_ptr<CompositorFrame> aggregated_frame =
 296       aggregator.Aggregate(root_surface.surface_id());
 297
 298   bool discard_alpha = false;
 299   ExactPixelComparator pixel_comparator(discard_alpha);
 300   RenderPassList* pass_list =
 301       &aggregated_frame->delegated_frame_data->render_pass_list;
 302   EXPECT_TRUE(RunPixelTest(
 303       pass_list,
 304       base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
 305       pixel_comparator));
 306 }
 307
 308 }  // namespace
 309 }  // namespace cc
 310
 311 #endif  // !defined(OS_ANDROID)