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/SkDevice.h"
  11 #include "third_party/skia/include/core/SkSurface.h"
  12 #include "ui/compositor/compositor.h"
  13 #include "ui/compositor/test/context_factories_for_test.h"
  14 #include "ui/gfx/geometry/size.h"
  15 #include "ui/gfx/skia_util.h"
  16 #include "ui/gfx/vsync_provider.h"
  17 #include "ui/gl/gl_implementation.h"
  18 #include "ui/ozone/public/ozone_platform.h"
  19 #include "ui/ozone/public/surface_ozone_canvas.h"
  20 #include "ui/platform_window/platform_window.h"
  21 #include "ui/platform_window/platform_window_delegate.h"
  22
  23 namespace {
  24
  25 class TestPlatformWindowDelegate : public ui::PlatformWindowDelegate {
  26  public:
  27   TestPlatformWindowDelegate() : widget_(gfx::kNullAcceleratedWidget) {}
  28   ~TestPlatformWindowDelegate() override {}
  29
  30   gfx::AcceleratedWidget GetAcceleratedWidget() const { return widget_; }
  31
  32   // ui::PlatformWindowDelegate:
  33   void OnBoundsChanged(const gfx::Rect& new_bounds) override {}
  34   void OnDamageRect(const gfx::Rect& damaged_region) override {}
  35   void DispatchEvent(ui::Event* event) override {}
  36   void OnCloseRequest() override {}
  37   void OnClosed() override {}
  38   void OnWindowStateChanged(ui::PlatformWindowState new_state) override {}
  39   void OnLostCapture() override {}
  40   void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget) override {
  41     widget_ = widget;
  42   }
  43   void OnActivationChanged(bool active) override {}
  44
  45  private:
  46   gfx::AcceleratedWidget widget_;
  47
  48   DISALLOW_COPY_AND_ASSIGN(TestPlatformWindowDelegate);
  49 };
  50
  51 }  // namespace
  52
  53 class SoftwareOutputDeviceOzoneTest : public testing::Test {
  54  public:
  55   SoftwareOutputDeviceOzoneTest();
  56   ~SoftwareOutputDeviceOzoneTest() override;
  57
  58   void SetUp() override;
  59   void TearDown() override;
  60
  61  protected:
  62   scoped_ptr<content::SoftwareOutputDeviceOzone> output_device_;
  63   bool enable_pixel_output_;
  64
  65  private:
  66   scoped_ptr<ui::Compositor> compositor_;
  67   scoped_ptr<base::MessageLoop> message_loop_;
  68   TestPlatformWindowDelegate window_delegate_;
  69   scoped_ptr<ui::PlatformWindow> window_;
  70
  71   DISALLOW_COPY_AND_ASSIGN(SoftwareOutputDeviceOzoneTest);
  72 };
  73
  74 SoftwareOutputDeviceOzoneTest::SoftwareOutputDeviceOzoneTest()
  75     : enable_pixel_output_(false) {
  76   message_loop_.reset(new base::MessageLoopForUI);
  77 }
  78
  79 SoftwareOutputDeviceOzoneTest::~SoftwareOutputDeviceOzoneTest() {
  80 }
  81
  82 void SoftwareOutputDeviceOzoneTest::SetUp() {
  83   ui::ContextFactory* context_factory =
  84       ui::InitializeContextFactoryForTests(enable_pixel_output_);
  85
  86   const gfx::Size size(500, 400);
  87   window_ = ui::OzonePlatform::GetInstance()->CreatePlatformWindow(
  88       &window_delegate_, gfx::Rect(size));
  89   compositor_.reset(new ui::Compositor(window_delegate_.GetAcceleratedWidget(),
  90                                        context_factory,
  91                                        base::MessageLoopProxy::current()));
  92   compositor_->SetScaleAndSize(1.0f, size);
  93
  94   output_device_.reset(new content::SoftwareOutputDeviceOzone(
  95       compositor_.get()));
  96   output_device_->Resize(size, 1.f);
  97 }
  98
  99 void SoftwareOutputDeviceOzoneTest::TearDown() {
 100   output_device_.reset();
 101   compositor_.reset();
 102   window_.reset();
 103   ui::TerminateContextFactoryForTests();
 104 }
 105
 106 class SoftwareOutputDeviceOzonePixelTest
 107     : public SoftwareOutputDeviceOzoneTest {
 108  protected:
 109   void SetUp() override;
 110 };
 111
 112 void SoftwareOutputDeviceOzonePixelTest::SetUp() {
 113   enable_pixel_output_ = true;
 114   SoftwareOutputDeviceOzoneTest::SetUp();
 115 }
 116
 117 TEST_F(SoftwareOutputDeviceOzoneTest, CheckCorrectResizeBehavior) {
 118   gfx::Rect damage(0, 0, 100, 100);
 119   gfx::Size size(200, 100);
 120   // Reduce size.
 121   output_device_->Resize(size, 1.f);
 122
 123   SkCanvas* canvas = output_device_->BeginPaint(damage);
 124   gfx::Size canvas_size(canvas->getDeviceSize().width(),
 125                         canvas->getDeviceSize().height());
 126   EXPECT_EQ(size.ToString(), canvas_size.ToString());
 127
 128   size.SetSize(1000, 500);
 129   // Increase size.
 130   output_device_->Resize(size, 1.f);
 131
 132   canvas = output_device_->BeginPaint(damage);
 133   canvas_size.SetSize(canvas->getDeviceSize().width(),
 134                       canvas->getDeviceSize().height());
 135   EXPECT_EQ(size.ToString(), canvas_size.ToString());
 136
 137 }
 138