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