Revert 206020 "cc: Emulate BeginFrame in OutputSurfaces that don..."

trunk/src/cc/output/output_surface_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/software_output_device.h"
-#include "cc/test/scheduler_test_common.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 class TestOutputSurface : public OutputSurface {
  public:
   explicit TestOutputSurface(scoped_ptr<WebKit::WebGraphicsContext3D> context3d)
       : OutputSurface(context3d.Pass()) {}
 
   explicit TestOutputSurface(
       scoped_ptr<cc::SoftwareOutputDevice> software_device)
       : OutputSurface(software_device.Pass()) {}
 
   TestOutputSurface(scoped_ptr<WebKit::WebGraphicsContext3D> context3d,
                     scoped_ptr<cc::SoftwareOutputDevice> software_device)
       : OutputSurface(context3d.Pass(), software_device.Pass()) {}
 
+  OutputSurfaceClient* client() { return client_; }
+
   bool InitializeNewContext3D(
       scoped_ptr<WebKit::WebGraphicsContext3D> new_context3d) {
     return InitializeAndSetContext3D(new_context3d.Pass(),
                                      scoped_refptr<ContextProvider>());
   }
-
-  bool HasClientForTesting() {
-    return HasClient();
-  }
-
-  void OnVSyncParametersChangedForTesting(base::TimeTicks timebase,
-                                          base::TimeDelta interval) {
-    OnVSyncParametersChanged(timebase, interval);
-  }
-
-  void BeginFrameForTesting(base::TimeTicks frame_time) {
-    BeginFrame(frame_time);
-  }
-
-  void DidSwapBuffersForTesting() {
-    DidSwapBuffers();
-  }
-
-  int pending_swap_buffers() {
-    return pending_swap_buffers_;
-  }
-
-  void OnSwapBuffersCompleteForTesting() {
-    OnSwapBuffersComplete(NULL);
-  }
 };
 
 class FakeOutputSurfaceClient : public OutputSurfaceClient {
  public:
   FakeOutputSurfaceClient()
-      : begin_frame_count_(0),
-        deferred_initialize_result_(true),
+      : deferred_initialize_result_(true),
         deferred_initialize_called_(false),
         did_lose_output_surface_called_(false) {}
 
   virtual bool DeferredInitialize(
       scoped_refptr<ContextProvider> offscreen_context_provider) OVERRIDE {
     deferred_initialize_called_ = true;
     return deferred_initialize_result_;
   }
   virtual void SetNeedsRedrawRect(gfx::Rect damage_rect) OVERRIDE {}
-  virtual void BeginFrame(base::TimeTicks frame_time) OVERRIDE {
-    begin_frame_count_++;
-  }
+  virtual void OnVSyncParametersChanged(base::TimeTicks timebase,
+                                        base::TimeDelta interval) OVERRIDE {}
+  virtual void BeginFrame(base::TimeTicks frame_time) OVERRIDE {}
   virtual void OnSwapBuffersComplete(const CompositorFrameAck* ack) OVERRIDE {}
   virtual void DidLoseOutputSurface() OVERRIDE {
     did_lose_output_surface_called_ = true;
   }
   virtual void SetExternalDrawConstraints(const gfx::Transform& transform,
                                           gfx::Rect viewport) OVERRIDE {}
 
-  int begin_frame_count() {
-    return begin_frame_count_;
-  }
-
   void set_deferred_initialize_result(bool result) {
     deferred_initialize_result_ = result;
   }
 
   bool deferred_initialize_called() {
     return deferred_initialize_called_;
   }
 
   bool did_lose_output_surface_called() {
     return did_lose_output_surface_called_;
   }
 
  private:
-  int begin_frame_count_;
   bool deferred_initialize_result_;
   bool deferred_initialize_called_;
   bool did_lose_output_surface_called_;
 };
 
 TEST(OutputSurfaceTest, ClientPointerIndicatesBindToClientSuccess) {
   scoped_ptr<TestWebGraphicsContext3D> context3d =
       TestWebGraphicsContext3D::Create();
 
   TestOutputSurface output_surface(
       context3d.PassAs<WebKit::WebGraphicsContext3D>());
-  EXPECT_FALSE(output_surface.HasClientForTesting());
+  EXPECT_EQ(NULL, output_surface.client());
 
   FakeOutputSurfaceClient client;
   EXPECT_TRUE(output_surface.BindToClient(&client));
-  EXPECT_TRUE(output_surface.HasClientForTesting());
+  EXPECT_EQ(&client, output_surface.client());
   EXPECT_FALSE(client.deferred_initialize_called());
 
   // Verify DidLoseOutputSurface callback is hooked up correctly.
   EXPECT_FALSE(client.did_lose_output_surface_called());
   output_surface.context3d()->loseContextCHROMIUM(
       GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
   EXPECT_TRUE(client.did_lose_output_surface_called());
 }
 
 TEST(OutputSurfaceTest, ClientPointerIndicatesBindToClientFailure) {
   scoped_ptr<TestWebGraphicsContext3D> context3d =
       TestWebGraphicsContext3D::Create();
 
   // Lose the context so BindToClient fails.
   context3d->set_times_make_current_succeeds(0);
 
   TestOutputSurface output_surface(
       context3d.PassAs<WebKit::WebGraphicsContext3D>());
-  EXPECT_FALSE(output_surface.HasClientForTesting());
+  EXPECT_EQ(NULL, output_surface.client());
 
   FakeOutputSurfaceClient client;
   EXPECT_FALSE(output_surface.BindToClient(&client));
-  EXPECT_FALSE(output_surface.HasClientForTesting());
+  EXPECT_EQ(NULL, output_surface.client());
 }
 
 class InitializeNewContext3D : public ::testing::Test {
  public:
   InitializeNewContext3D()
       : context3d_(TestWebGraphicsContext3D::Create()),
         output_surface_(
             scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice)) {}
 
  protected:
   void BindOutputSurface() {
     EXPECT_TRUE(output_surface_.BindToClient(&client_));
-    EXPECT_TRUE(output_surface_.HasClientForTesting());
+    EXPECT_EQ(&client_, output_surface_.client());
   }
 
   void InitializeNewContextExpectFail() {
     EXPECT_FALSE(output_surface_.InitializeNewContext3D(
         context3d_.PassAs<WebKit::WebGraphicsContext3D>()));
-    EXPECT_TRUE(output_surface_.HasClientForTesting());
+    EXPECT_EQ(&client_, output_surface_.client());
 
     EXPECT_FALSE(output_surface_.context3d());
     EXPECT_TRUE(output_surface_.software_device());
   }
 
   scoped_ptr<TestWebGraphicsContext3D> context3d_;
   TestOutputSurface output_surface_;
   FakeOutputSurfaceClient client_;
 };
 
@@ skipping 16 matching lines @@
   context3d_->set_times_make_current_succeeds(0);
   InitializeNewContextExpectFail();
 }
 
 TEST_F(InitializeNewContext3D, ClientDeferredInitializeFails) {
   BindOutputSurface();
   client_.set_deferred_initialize_result(false);
   InitializeNewContextExpectFail();
 }
 
-TEST(OutputSurfaceTest, BeginFrameEmulation) {
-  scoped_ptr<TestWebGraphicsContext3D> context3d =
-      TestWebGraphicsContext3D::Create();
-
-  TestOutputSurface output_surface(
-      context3d.PassAs<WebKit::WebGraphicsContext3D>());
-  EXPECT_FALSE(output_surface.HasClientForTesting());
-
-  FakeOutputSurfaceClient client;
-  EXPECT_TRUE(output_surface.BindToClient(&client));
-  EXPECT_TRUE(output_surface.HasClientForTesting());
-  EXPECT_FALSE(client.deferred_initialize_called());
-
-  // Initialize BeginFrame emulation
-  FakeThread impl_thread;
-  bool throttle_frame_production = true;
-  const base::TimeDelta display_refresh_interval =
-      base::TimeDelta::FromMicroseconds(16666);
-
-  output_surface.InitializeBeginFrameEmulation(
-      &impl_thread,
-      throttle_frame_production,
-      display_refresh_interval);
-
-  output_surface.SetMaxFramesPending(2);
-
-  // We should start off with 0 BeginFrames
-  EXPECT_EQ(client.begin_frame_count(), 0);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 0);
-
-  // We should not have a pending task until a BeginFrame has been requested.
-  EXPECT_FALSE(impl_thread.HasPendingTask());
-  output_surface.SetNeedsBeginFrame(true);
-  EXPECT_TRUE(impl_thread.HasPendingTask());
-
-  // BeginFrame should be called on the first tick.
-  impl_thread.RunPendingTask();
-  EXPECT_EQ(client.begin_frame_count(), 1);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 0);
-
-  // BeginFrame should not be called when there is a pending BeginFrame.
-  impl_thread.RunPendingTask();
-  EXPECT_EQ(client.begin_frame_count(), 1);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 0);
-
-  // DidSwapBuffers should clear the pending BeginFrame.
-  output_surface.DidSwapBuffersForTesting();
-  EXPECT_EQ(client.begin_frame_count(), 1);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-  impl_thread.RunPendingTask();
-  EXPECT_EQ(client.begin_frame_count(), 2);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-
-  // BeginFrame should be throttled by pending swap buffers.
-  output_surface.DidSwapBuffersForTesting();
-  EXPECT_EQ(client.begin_frame_count(), 2);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
-  impl_thread.RunPendingTask();
-  EXPECT_EQ(client.begin_frame_count(), 2);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
-
-  // SwapAck should decrement pending swap buffers and unblock BeginFrame again.
-  output_surface.OnSwapBuffersCompleteForTesting();
-  EXPECT_EQ(client.begin_frame_count(), 2);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-  impl_thread.RunPendingTask();
-  EXPECT_EQ(client.begin_frame_count(), 3);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-
-  // Calling SetNeedsBeginFrame again indicates a swap did not occur but
-  // the client still wants another BeginFrame.
-  output_surface.SetNeedsBeginFrame(true);
-  impl_thread.RunPendingTask();
-  EXPECT_EQ(client.begin_frame_count(), 4);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-
-  // Disabling SetNeedsBeginFrame should prevent further BeginFrames.
-  output_surface.SetNeedsBeginFrame(false);
-  impl_thread.RunPendingTask();
-  EXPECT_FALSE(impl_thread.HasPendingTask());
-  EXPECT_EQ(client.begin_frame_count(), 4);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-
-  // Optimistically injected BeginFrames without a SetNeedsBeginFrame should be
-  // allowed.
-  output_surface.BeginFrameForTesting(base::TimeTicks::Now());
-  EXPECT_EQ(client.begin_frame_count(), 5);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-
-  // Optimistically injected BeginFrames without a SetNeedsBeginFrame should
-  // still be throttled by pending begin frames however.
-  output_surface.BeginFrameForTesting(base::TimeTicks::Now());
-  EXPECT_EQ(client.begin_frame_count(), 5);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-
-  // Optimistically injected BeginFrames without a SetNeedsBeginFrame should
-  // also be throttled by pending swap buffers.
-  output_surface.DidSwapBuffersForTesting();
-  EXPECT_EQ(client.begin_frame_count(), 5);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
-  output_surface.BeginFrameForTesting(base::TimeTicks::Now());
-  EXPECT_EQ(client.begin_frame_count(), 5);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
-}
-
 }  // namespace
 }  // namespace cc