cc/output/output_surface_unittest.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/output/output_surface.h"
   6
   7 #include "base/test/test_simple_task_runner.h"
   8 #include "cc/output/managed_memory_policy.h"
   9 #include "cc/output/output_surface_client.h"
  10 #include "cc/output/software_output_device.h"
  11 #include "cc/test/begin_frame_args_test.h"
  12 #include "cc/test/fake_output_surface.h"
  13 #include "cc/test/fake_output_surface_client.h"
  14 #include "cc/test/test_context_provider.h"
  15 #include "cc/test/test_web_graphics_context_3d.h"
  16 #include "gpu/GLES2/gl2extchromium.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "ui/gfx/frame_time.h"
  19
  20 namespace cc {
  21 namespace {
  22
  23 class TestOutputSurface : public OutputSurface {
  24  public:
  25   explicit TestOutputSurface(scoped_refptr<ContextProvider> context_provider)
  26       : OutputSurface(context_provider) {}
  27
  28   TestOutputSurface(scoped_refptr<ContextProvider> context_provider,
  29                     scoped_refptr<ContextProvider> worker_context_provider)
  30       : OutputSurface(worker_context_provider) {}
  31
  32   explicit TestOutputSurface(scoped_ptr<SoftwareOutputDevice> software_device)
  33       : OutputSurface(software_device.Pass()) {}
  34
  35   TestOutputSurface(scoped_refptr<ContextProvider> context_provider,
  36                     scoped_ptr<SoftwareOutputDevice> software_device)
  37       : OutputSurface(context_provider, software_device.Pass()) {}
  38
  39   void SwapBuffers(CompositorFrame* frame) override {
  40     client_->DidSwapBuffers();
  41     client_->DidSwapBuffersComplete();
  42   }
  43
  44   bool InitializeNewContext3d(scoped_refptr<ContextProvider> context_provider) {
  45     return InitializeAndSetContext3d(context_provider, nullptr);
  46   }
  47
  48   using OutputSurface::ReleaseGL;
  49
  50   void CommitVSyncParametersForTesting(base::TimeTicks timebase,
  51                                        base::TimeDelta interval) {
  52     CommitVSyncParameters(timebase, interval);
  53   }
  54
  55   void DidSwapBuffersForTesting() { client_->DidSwapBuffers(); }
  56
  57   void OnSwapBuffersCompleteForTesting() { client_->DidSwapBuffersComplete(); }
  58
  59  protected:
  60 };
  61
  62 class TestSoftwareOutputDevice : public SoftwareOutputDevice {
  63  public:
  64   TestSoftwareOutputDevice();
  65   ~TestSoftwareOutputDevice() override;
  66
  67   // Overriden from cc:SoftwareOutputDevice
  68   void DiscardBackbuffer() override;
  69   void EnsureBackbuffer() override;
  70
  71   int discard_backbuffer_count() { return discard_backbuffer_count_; }
  72   int ensure_backbuffer_count() { return ensure_backbuffer_count_; }
  73
  74  private:
  75   int discard_backbuffer_count_;
  76   int ensure_backbuffer_count_;
  77 };
  78
  79 TestSoftwareOutputDevice::TestSoftwareOutputDevice()
  80     : discard_backbuffer_count_(0), ensure_backbuffer_count_(0) {}
  81
  82 TestSoftwareOutputDevice::~TestSoftwareOutputDevice() {}
  83
  84 void TestSoftwareOutputDevice::DiscardBackbuffer() {
  85   SoftwareOutputDevice::DiscardBackbuffer();
  86   discard_backbuffer_count_++;
  87 }
  88
  89 void TestSoftwareOutputDevice::EnsureBackbuffer() {
  90   SoftwareOutputDevice::EnsureBackbuffer();
  91   ensure_backbuffer_count_++;
  92 }
  93
  94 TEST(OutputSurfaceTest, ClientPointerIndicatesBindToClientSuccess) {
  95   scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
  96   TestOutputSurface output_surface(provider);
  97   EXPECT_FALSE(output_surface.HasClient());
  98
  99   FakeOutputSurfaceClient client;
 100   EXPECT_TRUE(output_surface.BindToClient(&client));
 101   EXPECT_TRUE(output_surface.HasClient());
 102   EXPECT_FALSE(client.deferred_initialize_called());
 103
 104   // Verify DidLoseOutputSurface callback is hooked up correctly.
 105   EXPECT_FALSE(client.did_lose_output_surface_called());
 106   output_surface.context_provider()->ContextGL()->LoseContextCHROMIUM(
 107       GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
 108   output_surface.context_provider()->ContextGL()->Flush();
 109   EXPECT_TRUE(client.did_lose_output_surface_called());
 110 }
 111
 112 TEST(OutputSurfaceTest, ClientPointerIndicatesWorkerBindToClientSuccess) {
 113   scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
 114   scoped_refptr<TestContextProvider> worker_provider =
 115       TestContextProvider::Create();
 116   TestOutputSurface output_surface(provider, worker_provider);
 117   EXPECT_FALSE(output_surface.HasClient());
 118
 119   FakeOutputSurfaceClient client;
 120   EXPECT_TRUE(output_surface.BindToClient(&client));
 121   EXPECT_TRUE(output_surface.HasClient());
 122   EXPECT_FALSE(client.deferred_initialize_called());
 123
 124   // Verify DidLoseOutputSurface callback is hooked up correctly.
 125   EXPECT_FALSE(client.did_lose_output_surface_called());
 126   output_surface.context_provider()->ContextGL()->LoseContextCHROMIUM(
 127       GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
 128   output_surface.context_provider()->ContextGL()->Flush();
 129   EXPECT_TRUE(client.did_lose_output_surface_called());
 130 }
 131
 132 TEST(OutputSurfaceTest, ClientPointerIndicatesBindToClientFailure) {
 133   scoped_refptr<TestContextProvider> context_provider =
 134       TestContextProvider::Create();
 135
 136   // Lose the context so BindToClient fails.
 137   context_provider->UnboundTestContext3d()->set_context_lost(true);
 138
 139   TestOutputSurface output_surface(context_provider);
 140   EXPECT_FALSE(output_surface.HasClient());
 141
 142   FakeOutputSurfaceClient client;
 143   EXPECT_FALSE(output_surface.BindToClient(&client));
 144   EXPECT_FALSE(output_surface.HasClient());
 145 }
 146
 147 TEST(OutputSurfaceTest, ClientPointerIndicatesWorkerBindToClientFailure) {
 148   scoped_refptr<TestContextProvider> context_provider =
 149       TestContextProvider::Create();
 150   scoped_refptr<TestContextProvider> worker_context_provider =
 151       TestContextProvider::Create();
 152
 153   // Lose the context so BindToClient fails.
 154   worker_context_provider->UnboundTestContext3d()->set_context_lost(true);
 155
 156   TestOutputSurface output_surface(context_provider, worker_context_provider);
 157   EXPECT_FALSE(output_surface.HasClient());
 158
 159   FakeOutputSurfaceClient client;
 160   EXPECT_FALSE(output_surface.BindToClient(&client));
 161   EXPECT_FALSE(output_surface.HasClient());
 162 }
 163
 164 class OutputSurfaceTestInitializeNewContext3d : public ::testing::Test {
 165  public:
 166   OutputSurfaceTestInitializeNewContext3d()
 167       : context_provider_(TestContextProvider::Create()),
 168         output_surface_(
 169             scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice)),
 170         client_(&output_surface_) {}
 171
 172  protected:
 173   void BindOutputSurface() {
 174     EXPECT_TRUE(output_surface_.BindToClient(&client_));
 175     EXPECT_TRUE(output_surface_.HasClient());
 176   }
 177
 178   void InitializeNewContextExpectFail() {
 179     EXPECT_FALSE(output_surface_.InitializeNewContext3d(context_provider_));
 180     EXPECT_TRUE(output_surface_.HasClient());
 181
 182     EXPECT_FALSE(output_surface_.context_provider());
 183     EXPECT_TRUE(output_surface_.software_device());
 184   }
 185
 186   scoped_refptr<TestContextProvider> context_provider_;
 187   TestOutputSurface output_surface_;
 188   FakeOutputSurfaceClient client_;
 189 };
 190
 191 TEST_F(OutputSurfaceTestInitializeNewContext3d, Success) {
 192   BindOutputSurface();
 193   EXPECT_FALSE(client_.deferred_initialize_called());
 194
 195   EXPECT_TRUE(output_surface_.InitializeNewContext3d(context_provider_));
 196   EXPECT_TRUE(client_.deferred_initialize_called());
 197   EXPECT_EQ(context_provider_.get(), output_surface_.context_provider());
 198
 199   EXPECT_FALSE(client_.did_lose_output_surface_called());
 200   context_provider_->ContextGL()->LoseContextCHROMIUM(
 201       GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
 202   context_provider_->ContextGL()->Flush();
 203   EXPECT_TRUE(client_.did_lose_output_surface_called());
 204
 205   output_surface_.ReleaseGL();
 206   EXPECT_FALSE(output_surface_.context_provider());
 207 }
 208
 209 TEST_F(OutputSurfaceTestInitializeNewContext3d, Context3dMakeCurrentFails) {
 210   BindOutputSurface();
 211
 212   context_provider_->UnboundTestContext3d()->set_context_lost(true);
 213   InitializeNewContextExpectFail();
 214 }
 215
 216 TEST(OutputSurfaceTest, MemoryAllocation) {
 217   scoped_refptr<TestContextProvider> context_provider =
 218       TestContextProvider::Create();
 219
 220   TestOutputSurface output_surface(context_provider);
 221
 222   FakeOutputSurfaceClient client;
 223   EXPECT_TRUE(output_surface.BindToClient(&client));
 224
 225   ManagedMemoryPolicy policy(0);
 226   policy.bytes_limit_when_visible = 1234;
 227   policy.priority_cutoff_when_visible =
 228       gpu::MemoryAllocation::CUTOFF_ALLOW_REQUIRED_ONLY;
 229
 230   context_provider->SetMemoryAllocation(policy);
 231   EXPECT_EQ(1234u, client.memory_policy().bytes_limit_when_visible);
 232   EXPECT_EQ(gpu::MemoryAllocation::CUTOFF_ALLOW_REQUIRED_ONLY,
 233             client.memory_policy().priority_cutoff_when_visible);
 234
 235   policy.priority_cutoff_when_visible =
 236       gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
 237   context_provider->SetMemoryAllocation(policy);
 238   EXPECT_EQ(gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
 239             client.memory_policy().priority_cutoff_when_visible);
 240
 241   // 0 bytes limit should be ignored.
 242   policy.bytes_limit_when_visible = 0;
 243   context_provider->SetMemoryAllocation(policy);
 244   EXPECT_EQ(1234u, client.memory_policy().bytes_limit_when_visible);
 245 }
 246
 247 TEST(OutputSurfaceTest, SoftwareOutputDeviceBackbufferManagement) {
 248   TestSoftwareOutputDevice* software_output_device =
 249       new TestSoftwareOutputDevice();
 250
 251   // TestOutputSurface now owns software_output_device and has responsibility to
 252   // free it.
 253   TestOutputSurface output_surface(make_scoped_ptr(software_output_device));
 254
 255   EXPECT_EQ(0, software_output_device->ensure_backbuffer_count());
 256   EXPECT_EQ(0, software_output_device->discard_backbuffer_count());
 257
 258   output_surface.EnsureBackbuffer();
 259   EXPECT_EQ(1, software_output_device->ensure_backbuffer_count());
 260   EXPECT_EQ(0, software_output_device->discard_backbuffer_count());
 261   output_surface.DiscardBackbuffer();
 262
 263   EXPECT_EQ(1, software_output_device->ensure_backbuffer_count());
 264   EXPECT_EQ(1, software_output_device->discard_backbuffer_count());
 265 }
 266
 267 }  // namespace
 268 }  // namespace cc