cc/test/pixel_test.cc

   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 "cc/test/pixel_test.h"
   6
   7 #include "base/path_service.h"
   8 #include "base/run_loop.h"
   9 #include "cc/output/compositor_frame_metadata.h"
  10 #include "cc/output/copy_output_request.h"
  11 #include "cc/output/copy_output_result.h"
  12 #include "cc/output/gl_renderer.h"
  13 #include "cc/output/output_surface_client.h"
  14 #include "cc/output/software_renderer.h"
  15 #include "cc/resources/resource_provider.h"
  16 #include "cc/test/paths.h"
  17 #include "cc/test/pixel_test_output_surface.h"
  18 #include "cc/test/pixel_test_software_output_device.h"
  19 #include "cc/test/pixel_test_utils.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21 #include "ui/gl/gl_implementation.h"
  22 #include "webkit/common/gpu/context_provider_in_process.h"
  23 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
  24
  25 namespace cc {
  26
  27 class PixelTest::PixelTestRendererClient
  28     : public RendererClient, public OutputSurfaceClient {
  29  public:
  30   explicit PixelTestRendererClient(gfx::Rect device_viewport)
  31       : device_viewport_(device_viewport) {}
  32
  33   // RendererClient implementation.
  34   virtual gfx::Rect DeviceViewport() const OVERRIDE {
  35     return device_viewport_;
  36   }
  37   virtual float DeviceScaleFactor() const OVERRIDE {
  38     return 1.f;
  39   }
  40   virtual const LayerTreeSettings& Settings() const OVERRIDE {
  41     return settings_;
  42   }
  43   virtual void SetFullRootLayerDamage() OVERRIDE {}
  44   virtual bool HasImplThread() const OVERRIDE { return false; }
  45   virtual bool ShouldClearRootRenderPass() const OVERRIDE { return true; }
  46   virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const
  47       OVERRIDE {
  48     return CompositorFrameMetadata();
  49   }
  50   virtual bool AllowPartialSwap() const OVERRIDE {
  51     return true;
  52   }
  53
  54   // OutputSurfaceClient implementation.
  55   virtual bool DeferredInitialize(
  56       scoped_refptr<ContextProvider> offscreen_context_provider) OVERRIDE {
  57     return false;
  58   }
  59   virtual void SetNeedsRedrawRect(gfx::Rect damage_rect) OVERRIDE {}
  60   virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE {}
  61   virtual void OnSwapBuffersComplete(const CompositorFrameAck* ack) OVERRIDE {}
  62   virtual void DidLoseOutputSurface() OVERRIDE {}
  63   virtual void SetExternalDrawConstraints(const gfx::Transform& transform,
  64                                           gfx::Rect viewport) OVERRIDE {
  65     device_viewport_ = viewport;
  66   }
  67   virtual void SetMemoryPolicy(
  68       const ManagedMemoryPolicy& policy, bool discard) OVERRIDE {}
  69
  70  private:
  71   gfx::Rect device_viewport_;
  72   LayerTreeSettings settings_;
  73 };
  74
  75 PixelTest::PixelTest()
  76     : device_viewport_size_(gfx::Size(200, 200)),
  77       fake_client_(
  78           new PixelTestRendererClient(gfx::Rect(device_viewport_size_))) {}
  79
  80 PixelTest::~PixelTest() {}
  81
  82 bool PixelTest::RunPixelTest(RenderPassList* pass_list,
  83                              const base::FilePath& ref_file,
  84                              const PixelComparator& comparator) {
  85   return RunPixelTestWithReadbackTarget(pass_list,
  86                                         pass_list->back(),
  87                                         ref_file,
  88                                         comparator);
  89 }
  90
  91 bool PixelTest::RunPixelTestWithReadbackTarget(
  92     RenderPassList* pass_list,
  93     RenderPass* target,
  94     const base::FilePath& ref_file,
  95     const PixelComparator& comparator) {
  96   base::RunLoop run_loop;
  97
  98   target->copy_requests.push_back(CopyOutputRequest::CreateBitmapRequest(
  99       base::Bind(&PixelTest::ReadbackResult,
 100                  base::Unretained(this),
 101                  run_loop.QuitClosure())));
 102
 103   renderer_->DecideRenderPassAllocationsForFrame(*pass_list);
 104   renderer_->DrawFrame(pass_list);
 105
 106   // Wait for the readback to complete.
 107   resource_provider_->Finish();
 108   run_loop.Run();
 109
 110   return PixelsMatchReference(ref_file, comparator);
 111 }
 112
 113 void PixelTest::ReadbackResult(base::Closure quit_run_loop,
 114                                scoped_ptr<CopyOutputResult> result) {
 115   ASSERT_TRUE(result->HasBitmap());
 116   result_bitmap_ = result->TakeBitmap().Pass();
 117   quit_run_loop.Run();
 118 }
 119
 120 bool PixelTest::PixelsMatchReference(const base::FilePath& ref_file,
 121                                      const PixelComparator& comparator) {
 122   base::FilePath test_data_dir;
 123   if (!PathService::Get(cc::DIR_TEST_DATA, &test_data_dir))
 124     return false;
 125
 126   // If this is false, we didn't set up a readback on a render pass.
 127   if (!result_bitmap_)
 128     return false;
 129
 130   // To rebaseline:
 131   // return WritePNGFile(*result_bitmap_, test_data_dir.Append(ref_file), true);
 132
 133   return MatchesPNGFile(*result_bitmap_,
 134                         test_data_dir.Append(ref_file),
 135                         comparator);
 136 }
 137
 138 void PixelTest::SetUpGLRenderer(bool use_skia_gpu_backend) {
 139   CHECK(fake_client_);
 140   CHECK(gfx::InitializeGLBindings(gfx::kGLImplementationOSMesaGL));
 141
 142   using webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl;
 143   scoped_ptr<WebKit::WebGraphicsContext3D> context3d(
 144       WebGraphicsContext3DInProcessCommandBufferImpl::CreateOffscreenContext(
 145           WebKit::WebGraphicsContext3D::Attributes()));
 146   output_surface_.reset(new PixelTestOutputSurface(
 147       context3d.PassAs<WebKit::WebGraphicsContext3D>()));
 148   output_surface_->BindToClient(fake_client_.get());
 149
 150   resource_provider_ = ResourceProvider::Create(output_surface_.get(), 0);
 151   renderer_ = GLRenderer::Create(fake_client_.get(),
 152                                  output_surface_.get(),
 153                                  resource_provider_.get(),
 154                                  0,
 155                                  use_skia_gpu_backend).PassAs<DirectRenderer>();
 156
 157   scoped_refptr<webkit::gpu::ContextProviderInProcess> offscreen_contexts =
 158       webkit::gpu::ContextProviderInProcess::Create();
 159   ASSERT_TRUE(offscreen_contexts->BindToCurrentThread());
 160   resource_provider_->set_offscreen_context_provider(offscreen_contexts);
 161 }
 162
 163 void PixelTest::ForceExpandedViewport(gfx::Size surface_expansion,
 164                                       gfx::Vector2d viewport_offset) {
 165   static_cast<PixelTestOutputSurface*>(output_surface_.get())
 166       ->set_surface_expansion_size(surface_expansion);
 167   static_cast<PixelTestOutputSurface*>(output_surface_.get())
 168       ->set_viewport_offset(viewport_offset);
 169   SoftwareOutputDevice* device = output_surface_->software_device();
 170   if (device) {
 171     static_cast<PixelTestSoftwareOutputDevice*>(device)
 172         ->set_surface_expansion_size(surface_expansion);
 173   }
 174 }
 175
 176 void PixelTest::SetUpSoftwareRenderer() {
 177   CHECK(fake_client_);
 178
 179   scoped_ptr<SoftwareOutputDevice> device(new PixelTestSoftwareOutputDevice());
 180   output_surface_.reset(new PixelTestOutputSurface(device.Pass()));
 181   output_surface_->BindToClient(fake_client_.get());
 182   resource_provider_ = ResourceProvider::Create(output_surface_.get(), 0);
 183   renderer_ = SoftwareRenderer::Create(
 184       fake_client_.get(),
 185       output_surface_.get(),
 186       resource_provider_.get()).PassAs<DirectRenderer>();
 187 }
 188
 189 }  // namespace cc