content/browser/compositor/software_output_device_ozone_unittest.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 "base/memory/scoped_ptr.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "cc/output/software_frame_data.h"
   8 #include "content/browser/compositor/software_output_device_ozone.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "third_party/skia/include/core/SkSurface.h"
  11 #include "ui/compositor/compositor.h"
  12 #include "ui/compositor/test/context_factories_for_test.h"
  13 #include "ui/gfx/size.h"
  14 #include "ui/gfx/skia_util.h"
  15 #include "ui/gfx/vsync_provider.h"
  16 #include "ui/gl/gl_implementation.h"
  17 #include "ui/ozone/public/surface_factory_ozone.h"
  18 #include "ui/ozone/public/surface_ozone_canvas.h"
  19
  20 namespace {
  21
  22 class MockSurfaceOzone : public ui::SurfaceOzoneCanvas {
  23  public:
  24   MockSurfaceOzone() {}
  25   virtual ~MockSurfaceOzone() {}
  26
  27   // ui::SurfaceOzoneCanvas overrides:
  28   virtual void ResizeCanvas(const gfx::Size& size) OVERRIDE {
  29     surface_ = skia::AdoptRef(SkSurface::NewRaster(
  30         SkImageInfo::MakeN32Premul(size.width(), size.height())));
  31   }
  32   virtual skia::RefPtr<SkCanvas> GetCanvas() OVERRIDE {
  33     return skia::SharePtr(surface_->getCanvas());
  34   }
  35   virtual void PresentCanvas(const gfx::Rect& damage) OVERRIDE {}
  36   virtual scoped_ptr<gfx::VSyncProvider> CreateVSyncProvider() OVERRIDE {
  37     return scoped_ptr<gfx::VSyncProvider>();
  38   }
  39
  40  private:
  41   skia::RefPtr<SkSurface> surface_;
  42
  43   DISALLOW_COPY_AND_ASSIGN(MockSurfaceOzone);
  44 };
  45
  46 class MockSurfaceFactoryOzone : public ui::SurfaceFactoryOzone {
  47  public:
  48   MockSurfaceFactoryOzone() {}
  49   virtual ~MockSurfaceFactoryOzone() {}
  50
  51   virtual HardwareState InitializeHardware() OVERRIDE {
  52     return SurfaceFactoryOzone::INITIALIZED;
  53   }
  54
  55   virtual void ShutdownHardware() OVERRIDE {}
  56   virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE { return 1; }
  57   virtual bool LoadEGLGLES2Bindings(
  58       AddGLLibraryCallback add_gl_library,
  59       SetGLGetProcAddressProcCallback set_gl_get_proc_address) OVERRIDE {
  60     return false;
  61   }
  62   virtual scoped_ptr<ui::SurfaceOzoneCanvas> CreateCanvasForWidget(
  63       gfx::AcceleratedWidget widget) OVERRIDE {
  64     return make_scoped_ptr<ui::SurfaceOzoneCanvas>(new MockSurfaceOzone());
  65   }
  66
  67  private:
  68   DISALLOW_COPY_AND_ASSIGN(MockSurfaceFactoryOzone);
  69 };
  70
  71 }  // namespace
  72
  73 class SoftwareOutputDeviceOzoneTest : public testing::Test {
  74  public:
  75   SoftwareOutputDeviceOzoneTest();
  76   virtual ~SoftwareOutputDeviceOzoneTest();
  77
  78   virtual void SetUp() OVERRIDE;
  79   virtual void TearDown() OVERRIDE;
  80
  81  protected:
  82   scoped_ptr<content::SoftwareOutputDeviceOzone> output_device_;
  83   bool enable_pixel_output_;
  84
  85  private:
  86   scoped_ptr<ui::Compositor> compositor_;
  87   scoped_ptr<base::MessageLoop> message_loop_;
  88   scoped_ptr<ui::SurfaceFactoryOzone> surface_factory_;
  89
  90   DISALLOW_COPY_AND_ASSIGN(SoftwareOutputDeviceOzoneTest);
  91 };
  92
  93 SoftwareOutputDeviceOzoneTest::SoftwareOutputDeviceOzoneTest()
  94     : enable_pixel_output_(false) {
  95   message_loop_.reset(new base::MessageLoopForUI);
  96 }
  97
  98 SoftwareOutputDeviceOzoneTest::~SoftwareOutputDeviceOzoneTest() {
  99 }
 100
 101 void SoftwareOutputDeviceOzoneTest::SetUp() {
 102   ui::ContextFactory* context_factory =
 103       ui::InitializeContextFactoryForTests(enable_pixel_output_);
 104
 105   surface_factory_.reset(new MockSurfaceFactoryOzone());
 106
 107   const gfx::Size size(500, 400);
 108   compositor_.reset(new ui::Compositor(
 109       ui::SurfaceFactoryOzone::GetInstance()->GetAcceleratedWidget(),
 110       context_factory));
 111   compositor_->SetScaleAndSize(1.0f, size);
 112
 113   output_device_.reset(new content::SoftwareOutputDeviceOzone(
 114       compositor_.get()));
 115   output_device_->Resize(size, 1.f);
 116 }
 117
 118 void SoftwareOutputDeviceOzoneTest::TearDown() {
 119   output_device_.reset();
 120   compositor_.reset();
 121   surface_factory_.reset();
 122   ui::TerminateContextFactoryForTests();
 123 }
 124
 125 class SoftwareOutputDeviceOzonePixelTest
 126     : public SoftwareOutputDeviceOzoneTest {
 127  protected:
 128   virtual void SetUp() OVERRIDE;
 129 };
 130
 131 void SoftwareOutputDeviceOzonePixelTest::SetUp() {
 132   enable_pixel_output_ = true;
 133   SoftwareOutputDeviceOzoneTest::SetUp();
 134 }
 135
 136 TEST_F(SoftwareOutputDeviceOzoneTest, CheckCorrectResizeBehavior) {
 137   gfx::Rect damage(0, 0, 100, 100);
 138   gfx::Size size(200, 100);
 139   // Reduce size.
 140   output_device_->Resize(size, 1.f);
 141
 142   SkCanvas* canvas = output_device_->BeginPaint(damage);
 143   gfx::Size canvas_size(canvas->getDeviceSize().width(),
 144                         canvas->getDeviceSize().height());
 145   EXPECT_EQ(size.ToString(), canvas_size.ToString());
 146
 147   size.SetSize(1000, 500);
 148   // Increase size.
 149   output_device_->Resize(size, 1.f);
 150
 151   canvas = output_device_->BeginPaint(damage);
 152   canvas_size.SetSize(canvas->getDeviceSize().width(),
 153                       canvas->getDeviceSize().height());
 154   EXPECT_EQ(size.ToString(), canvas_size.ToString());
 155
 156 }
 157
 158 TEST_F(SoftwareOutputDeviceOzonePixelTest, CheckCopyToBitmap) {
 159   const int width = 6;
 160   const int height = 4;
 161   const gfx::Rect area(width, height);
 162   output_device_->Resize(area.size(), 1.f);
 163   SkCanvas* canvas = output_device_->BeginPaint(area);
 164
 165   // Clear the background to black.
 166   canvas->drawColor(SK_ColorBLACK);
 167
 168   cc::SoftwareFrameData frame;
 169   output_device_->EndPaint(&frame);
 170
 171   // Draw a white rectangle.
 172   gfx::Rect damage(area.width() / 2, area.height() / 2);
 173   canvas = output_device_->BeginPaint(damage);
 174   canvas->clipRect(gfx::RectToSkRect(damage), SkRegion::kReplace_Op);
 175
 176   canvas->drawColor(SK_ColorWHITE);
 177
 178   output_device_->EndPaint(&frame);
 179
 180   SkPMColor pixels[width * height];
 181   output_device_->CopyToPixels(area, pixels);
 182
 183   // Check that the copied bitmap contains the same pixel values as what we
 184   // painted.
 185   const SkPMColor white = SkPreMultiplyColor(SK_ColorWHITE);
 186   const SkPMColor black = SkPreMultiplyColor(SK_ColorBLACK);
 187   for (int i = 0; i < area.height(); ++i) {
 188     for (int j = 0; j < area.width(); ++j) {
 189       if (j < damage.width() && i < damage.height())
 190         EXPECT_EQ(white, pixels[i * area.width() + j]);
 191       else
 192         EXPECT_EQ(black, pixels[i * area.width() + j]);
 193     }
 194   }
 195 }