cc: Unify use of DidSwapBuffers() and did_request_swap

cc/scheduler/scheduler_unittest.cc

 // Copyright 2011 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/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 91 matching lines @@
     needs_begin_frame_ = enable;
   }
   virtual void WillBeginImplFrame(const BeginFrameArgs& args) OVERRIDE {
     actions_.push_back("WillBeginImplFrame");
     states_.push_back(scheduler_->StateAsValue().release());
   }
   virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {
     actions_.push_back("ScheduledActionSendBeginMainFrame");
     states_.push_back(scheduler_->StateAsValue().release());
   }
-  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
-      OVERRIDE {
+  virtual DrawResult ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapIfPossible");
     states_.push_back(scheduler_->StateAsValue().release());
     num_draws_++;
-    bool did_readback = false;
-    DrawSwapReadbackResult::DrawResult result =
-        draw_will_happen_
-            ? DrawSwapReadbackResult::DRAW_SUCCESS
-            : DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
+    DrawResult result =
+        draw_will_happen_ ? DRAW_SUCCESS : DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
     bool swap_will_happen =
         draw_will_happen_ && swap_will_happen_if_draw_happens_;
     if (swap_will_happen) {
       scheduler_->DidSwapBuffers();
       if (automatic_swap_ack_)
         scheduler_->DidSwapBuffersComplete();
     }
-    return DrawSwapReadbackResult(
-        result,
-        draw_will_happen_ && swap_will_happen_if_draw_happens_,
-        did_readback);
+    return result;
   }
-  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
+  virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapForced");
     states_.push_back(scheduler_->StateAsValue().release());
-    bool did_request_swap = swap_will_happen_if_draw_happens_;
-    bool did_readback = false;
-    return DrawSwapReadbackResult(
-        DrawSwapReadbackResult::DRAW_SUCCESS, did_request_swap, did_readback);
+    return DRAW_SUCCESS;
   }
-  virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback() OVERRIDE {
+  virtual DrawResult ScheduledActionDrawAndReadback() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndReadback");
     states_.push_back(scheduler_->StateAsValue().release());
-    bool did_request_swap = false;
-    bool did_readback = true;
-    return DrawSwapReadbackResult(
-        DrawSwapReadbackResult::DRAW_SUCCESS, did_request_swap, did_readback);
+    return DRAW_SUCCESS;
   }
   virtual void ScheduledActionCommit() OVERRIDE {
     actions_.push_back("ScheduledActionCommit");
     states_.push_back(scheduler_->StateAsValue().release());
   }
   virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE {
     actions_.push_back("ScheduledActionUpdateVisibleTiles");
     states_.push_back(scheduler_->StateAsValue().release());
   }
   virtual void ScheduledActionActivatePendingTree() OVERRIDE {
@@ skipping 221 matching lines @@
   // no longer request BeginImplFrames.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_FALSE(client.needs_begin_frame());
   client.Reset();
 }
 
 class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
  public:
   virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {}
-  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
+  virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
       OVERRIDE {
     // Only SetNeedsRedraw the first time this is called
     if (!num_draws_)
       scheduler_->SetNeedsRedraw();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
-  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
+  virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     NOTREACHED();
-    bool did_request_swap = true;
-    bool did_readback = false;
-    return DrawSwapReadbackResult(
-        DrawSwapReadbackResult::DRAW_SUCCESS, did_request_swap, did_readback);
+    return DRAW_SUCCESS;
   }
 
   virtual void ScheduledActionCommit() OVERRIDE {}
   virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {}
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {}
 };
 
 // Tests for two different situations:
 // 1. the scheduler dropping SetNeedsRedraw requests that happen inside
 //    a ScheduledActionDrawAndSwap
@@ skipping 80 matching lines @@
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 }
 
 class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
  public:
   SchedulerClientThatSetNeedsCommitInsideDraw()
       : set_needs_commit_on_next_draw_(false) {}
 
   virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {}
-  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
+  virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
       OVERRIDE {
     // Only SetNeedsCommit the first time this is called
     if (set_needs_commit_on_next_draw_) {
       scheduler_->SetNeedsCommit();
       set_needs_commit_on_next_draw_ = false;
     }
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
-  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
+  virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     NOTREACHED();
-    bool did_request_swap = false;
-    bool did_readback = false;
-    return DrawSwapReadbackResult(
-        DrawSwapReadbackResult::DRAW_SUCCESS, did_request_swap, did_readback);
+    return DRAW_SUCCESS;
   }
 
   virtual void ScheduledActionCommit() OVERRIDE {}
   virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {}
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {}
 
   void SetNeedsCommitOnNextDraw() { set_needs_commit_on_next_draw_ = true; }
 
  private:
   bool set_needs_commit_on_next_draw_;
@@ skipping 168 matching lines @@
 
   // The replacement commit comes in after 2 readbacks.
   client.Reset();
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
 }
 
 
 class SchedulerClientNeedsManageTilesInDraw : public FakeSchedulerClient {
  public:
-  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
+  virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
       OVERRIDE {
     scheduler_->SetNeedsManageTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 };
 
 // Test manage tiles is independant of draws.
 TEST(SchedulerTest, ManageTiles) {
   SchedulerClientNeedsManageTilesInDraw client;
   SchedulerSettings default_scheduler_settings;
@@ skipping 745 matching lines @@
 TEST(SchedulerTest,
      SyntheticBeginFrames_And_VSyncThrottlingDisabled_SwapThrottled) {
   bool begin_frame_scheduling_enabled = false;
   bool throttle_frame_production = false;
   BeginFramesNotFromClient_SwapThrottled(begin_frame_scheduling_enabled,
                                          throttle_frame_production);
 }
 
 }  // namespace
 }  // namespace cc