content/browser/compositor/software_browser_compositor_output_surface_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/message_loop/message_loop.h"
   6 #include "cc/output/compositor_frame.h"
   7 #include "content/browser/compositor/browser_compositor_output_surface_proxy.h"
   8 #include "content/browser/compositor/software_browser_compositor_output_surface.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "ui/compositor/compositor.h"
  11 #include "ui/compositor/test/context_factories_for_test.h"
  12 #include "ui/gfx/vsync_provider.h"
  13
  14 namespace {
  15
  16 class FakeVSyncProvider : public gfx::VSyncProvider {
  17  public:
  18   FakeVSyncProvider() : call_count_(0) {}
  19   virtual ~FakeVSyncProvider() {}
  20
  21   virtual void GetVSyncParameters(const UpdateVSyncCallback& callback)
  22       OVERRIDE {
  23     callback.Run(timebase_, interval_);
  24     call_count_++;
  25   }
  26
  27   int call_count() const { return call_count_; }
  28
  29   void set_timebase(base::TimeTicks timebase) { timebase_ = timebase; }
  30   void set_interval(base::TimeDelta interval) { interval_ = interval; }
  31
  32  private:
  33   base::TimeTicks timebase_;
  34   base::TimeDelta interval_;
  35
  36   int call_count_;
  37
  38   DISALLOW_COPY_AND_ASSIGN(FakeVSyncProvider);
  39 };
  40
  41 class FakeSoftwareOutputDevice : public cc::SoftwareOutputDevice {
  42  public:
  43   FakeSoftwareOutputDevice() : vsync_provider_(new FakeVSyncProvider()) {}
  44   virtual ~FakeSoftwareOutputDevice() {}
  45
  46   virtual gfx::VSyncProvider* GetVSyncProvider() OVERRIDE {
  47     return vsync_provider_.get();
  48   }
  49
  50  private:
  51   scoped_ptr<gfx::VSyncProvider> vsync_provider_;
  52
  53   DISALLOW_COPY_AND_ASSIGN(FakeSoftwareOutputDevice);
  54 };
  55
  56 }  // namespace
  57
  58 class SoftwareBrowserCompositorOutputSurfaceTest : public testing::Test {
  59  public:
  60   SoftwareBrowserCompositorOutputSurfaceTest();
  61   virtual ~SoftwareBrowserCompositorOutputSurfaceTest();
  62
  63   virtual void SetUp() OVERRIDE;
  64   virtual void TearDown() OVERRIDE;
  65
  66   scoped_ptr<content::BrowserCompositorOutputSurface> CreateSurface(
  67       scoped_ptr<cc::SoftwareOutputDevice> device);
  68
  69  protected:
  70   scoped_ptr<content::BrowserCompositorOutputSurface> output_surface_;
  71
  72   scoped_ptr<base::MessageLoop> message_loop_;
  73   scoped_ptr<ui::Compositor> compositor_;
  74
  75   IDMap<content::BrowserCompositorOutputSurface> surface_map_;
  76   scoped_refptr<content::BrowserCompositorOutputSurfaceProxy> surface_proxy_;
  77
  78   DISALLOW_COPY_AND_ASSIGN(SoftwareBrowserCompositorOutputSurfaceTest);
  79 };
  80
  81 SoftwareBrowserCompositorOutputSurfaceTest::
  82     SoftwareBrowserCompositorOutputSurfaceTest() {
  83   // |message_loop_| is not used, but the main thread still has to exist for the
  84   // compositor to use.
  85   message_loop_.reset(new base::MessageLoopForUI);
  86 }
  87
  88 SoftwareBrowserCompositorOutputSurfaceTest::
  89     ~SoftwareBrowserCompositorOutputSurfaceTest() {}
  90
  91 void SoftwareBrowserCompositorOutputSurfaceTest::SetUp() {
  92   bool enable_pixel_output = false;
  93   ui::ContextFactory* context_factory =
  94       ui::InitializeContextFactoryForTests(enable_pixel_output);
  95
  96   compositor_.reset(new ui::Compositor(gfx::kNullAcceleratedWidget,
  97                                        context_factory));
  98   surface_proxy_ =
  99       new content::BrowserCompositorOutputSurfaceProxy(&surface_map_);
 100 }
 101
 102 void SoftwareBrowserCompositorOutputSurfaceTest::TearDown() {
 103   output_surface_.reset();
 104   compositor_.reset();
 105
 106   EXPECT_TRUE(surface_map_.IsEmpty());
 107
 108   surface_map_.Clear();
 109   ui::TerminateContextFactoryForTests();
 110 }
 111
 112 scoped_ptr<content::BrowserCompositorOutputSurface>
 113 SoftwareBrowserCompositorOutputSurfaceTest::CreateSurface(
 114     scoped_ptr<cc::SoftwareOutputDevice> device) {
 115   return scoped_ptr<content::BrowserCompositorOutputSurface>(
 116       new content::SoftwareBrowserCompositorOutputSurface(
 117           surface_proxy_,
 118           device.Pass(),
 119           1,
 120           &surface_map_,
 121           compositor_->vsync_manager()));
 122 }
 123
 124 TEST_F(SoftwareBrowserCompositorOutputSurfaceTest, NoVSyncProvider) {
 125   scoped_ptr<cc::SoftwareOutputDevice> software_device(
 126       new cc::SoftwareOutputDevice());
 127   output_surface_ = CreateSurface(software_device.Pass());
 128
 129   cc::CompositorFrame frame;
 130   output_surface_->SwapBuffers(&frame);
 131
 132   EXPECT_EQ(NULL, output_surface_->software_device()->GetVSyncProvider());
 133 }
 134
 135 TEST_F(SoftwareBrowserCompositorOutputSurfaceTest, VSyncProviderUpdates) {
 136   scoped_ptr<cc::SoftwareOutputDevice> software_device(
 137       new FakeSoftwareOutputDevice());
 138   output_surface_ = CreateSurface(software_device.Pass());
 139
 140   FakeVSyncProvider* vsync_provider = static_cast<FakeVSyncProvider*>(
 141       output_surface_->software_device()->GetVSyncProvider());
 142   EXPECT_EQ(0, vsync_provider->call_count());
 143
 144   cc::CompositorFrame frame;
 145   output_surface_->SwapBuffers(&frame);
 146
 147   EXPECT_EQ(1, vsync_provider->call_count());
 148 }