cc/test/pixel_test.h

   1 // Copyright 2013 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 "base/files/file_util.h"
   6 #include "cc/output/gl_renderer.h"
   7 #include "cc/output/software_renderer.h"
   8 #include "cc/quads/render_pass.h"
   9 #include "cc/test/pixel_comparator.h"
  10 #include "cc/trees/layer_tree_settings.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12 #include "ui/gfx/geometry/size.h"
  13 #include "ui/gl/gl_implementation.h"
  14
  15 #ifndef CC_TEST_PIXEL_TEST_H_
  16 #define CC_TEST_PIXEL_TEST_H_
  17
  18 namespace cc {
  19 class CopyOutputResult;
  20 class DirectRenderer;
  21 class FakeOutputSurfaceClient;
  22 class OutputSurface;
  23 class ResourceProvider;
  24 class SoftwareRenderer;
  25 class TestGpuMemoryBufferManager;
  26 class TestSharedBitmapManager;
  27
  28 class PixelTest : public testing::Test, RendererClient {
  29  protected:
  30   PixelTest();
  31   ~PixelTest() override;
  32
  33   bool RunPixelTest(RenderPassList* pass_list,
  34                     const base::FilePath& ref_file,
  35                     const PixelComparator& comparator);
  36
  37   bool RunPixelTestWithReadbackTarget(
  38       RenderPassList* pass_list,
  39       RenderPass* target,
  40       const base::FilePath& ref_file,
  41       const PixelComparator& comparator);
  42
  43   bool RunPixelTestWithReadbackTargetAndArea(RenderPassList* pass_list,
  44                                              RenderPass* target,
  45                                              const base::FilePath& ref_file,
  46                                              const PixelComparator& comparator,
  47                                              const gfx::Rect* copy_rect);
  48
  49   LayerTreeSettings settings_;
  50   gfx::Size device_viewport_size_;
  51   bool disable_picture_quad_image_filtering_;
  52   class PixelTestRendererClient;
  53   scoped_ptr<FakeOutputSurfaceClient> output_surface_client_;
  54   scoped_ptr<OutputSurface> output_surface_;
  55   scoped_ptr<TestSharedBitmapManager> shared_bitmap_manager_;
  56   scoped_ptr<TestGpuMemoryBufferManager> gpu_memory_buffer_manager_;
  57   scoped_ptr<BlockingTaskRunner> main_thread_task_runner_;
  58   scoped_ptr<ResourceProvider> resource_provider_;
  59   scoped_ptr<TextureMailboxDeleter> texture_mailbox_deleter_;
  60   scoped_ptr<DirectRenderer> renderer_;
  61   scoped_ptr<SkBitmap> result_bitmap_;
  62   gfx::Vector2d external_device_viewport_offset_;
  63   gfx::Rect external_device_clip_rect_;
  64
  65   void SetUpGLRenderer(bool use_skia_gpu_backend, bool flipped_output_surface);
  66   void SetUpSoftwareRenderer();
  67
  68   void ForceExpandedViewport(const gfx::Size& surface_expansion);
  69   void ForceViewportOffset(const gfx::Vector2d& viewport_offset);
  70   void ForceDeviceClip(const gfx::Rect& clip);
  71   void EnableExternalStencilTest();
  72
  73   // RendererClient implementation.
  74   void SetFullRootLayerDamage() override {}
  75
  76  private:
  77   void ReadbackResult(base::Closure quit_run_loop,
  78                       scoped_ptr<CopyOutputResult> result);
  79
  80   bool PixelsMatchReference(const base::FilePath& ref_file,
  81                             const PixelComparator& comparator);
  82
  83   scoped_ptr<gfx::DisableNullDrawGLBindings> enable_pixel_output_;
  84 };
  85
  86 template<typename RendererType>
  87 class RendererPixelTest : public PixelTest {
  88  public:
  89   RendererType* renderer() {
  90     return static_cast<RendererType*>(renderer_.get());
  91   }
  92
  93  protected:
  94   void SetUp() override;
  95 };
  96
  97 // Wrappers to differentiate renderers where the the output surface and viewport
  98 // have an externally determined size and offset.
  99 class GLRendererWithExpandedViewport : public GLRenderer {
 100  public:
 101   GLRendererWithExpandedViewport(RendererClient* client,
 102                                  const RendererSettings* settings,
 103                                  OutputSurface* output_surface,
 104                                  ResourceProvider* resource_provider,
 105                                  TextureMailboxDeleter* texture_mailbox_deleter,
 106                                  int highp_threshold_min)
 107       : GLRenderer(client,
 108                    settings,
 109                    output_surface,
 110                    resource_provider,
 111                    texture_mailbox_deleter,
 112                    highp_threshold_min) {}
 113 };
 114
 115 class SoftwareRendererWithExpandedViewport : public SoftwareRenderer {
 116  public:
 117   SoftwareRendererWithExpandedViewport(RendererClient* client,
 118                                        const RendererSettings* settings,
 119                                        OutputSurface* output_surface,
 120                                        ResourceProvider* resource_provider)
 121       : SoftwareRenderer(client, settings, output_surface, resource_provider) {}
 122 };
 123
 124 class GLRendererWithFlippedSurface : public GLRenderer {
 125  public:
 126   GLRendererWithFlippedSurface(RendererClient* client,
 127                                const RendererSettings* settings,
 128                                OutputSurface* output_surface,
 129                                ResourceProvider* resource_provider,
 130                                TextureMailboxDeleter* texture_mailbox_deleter,
 131                                int highp_threshold_min)
 132       : GLRenderer(client,
 133                    settings,
 134                    output_surface,
 135                    resource_provider,
 136                    texture_mailbox_deleter,
 137                    highp_threshold_min) {}
 138 };
 139
 140 template<>
 141 inline void RendererPixelTest<GLRenderer>::SetUp() {
 142   SetUpGLRenderer(false, false);
 143 }
 144
 145 template<>
 146 inline void RendererPixelTest<GLRendererWithExpandedViewport>::SetUp() {
 147   SetUpGLRenderer(false, false);
 148   ForceExpandedViewport(gfx::Size(50, 50));
 149   ForceViewportOffset(gfx::Vector2d(10, 20));
 150 }
 151
 152 template <>
 153 inline void RendererPixelTest<GLRendererWithFlippedSurface>::SetUp() {
 154   SetUpGLRenderer(false, true);
 155 }
 156
 157 template <>
 158 inline void RendererPixelTest<SoftwareRenderer>::SetUp() {
 159   SetUpSoftwareRenderer();
 160 }
 161
 162 template<>
 163 inline void RendererPixelTest<SoftwareRendererWithExpandedViewport>::SetUp() {
 164   SetUpSoftwareRenderer();
 165   ForceExpandedViewport(gfx::Size(50, 50));
 166   ForceViewportOffset(gfx::Vector2d(10, 20));
 167 }
 168
 169 typedef RendererPixelTest<GLRenderer> GLRendererPixelTest;
 170 typedef RendererPixelTest<SoftwareRenderer> SoftwareRendererPixelTest;
 171
 172 }  // namespace cc
 173
 174 #endif  // CC_TEST_PIXEL_TEST_H_