CC: Add a scheduled action for ManageTiles

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"
@@ skipping 48 matching lines @@
     scheduler_ = Scheduler::Create(this, settings);
     return scheduler_.get();
   }
 
   bool needs_begin_frame() { return needs_begin_frame_; }
   int num_draws() const { return num_draws_; }
   int num_actions_() const { return static_cast<int>(actions_.size()); }
   const char* Action(int i) const { return actions_[i]; }
   base::Value& StateForAction(int i) const { return *states_[i]; }
 
-  bool HasAction(const char* action) const {
+  int ActionIndex(const char* action) const {
     for (size_t i = 0; i < actions_.size(); i++)
       if (!strcmp(actions_[i], action))
-        return true;
-    return false;
+        return i;
+    return -1;
+  }
+
+  bool HasAction(const char* action) const {
+    return ActionIndex(action) >= 0;
   }
 
   void SetDrawWillHappen(bool draw_will_happen) {
     draw_will_happen_ = draw_will_happen;
   }
   void SetSwapWillHappenIfDrawHappens(bool swap_will_happen_if_draw_happens) {
     swap_will_happen_if_draw_happens_ = swap_will_happen_if_draw_happens;
   }
 
   // Scheduler Implementation.
@@ skipping 46 matching lines @@
     states_.push_back(scheduler_->StateAsValue().release());
   }
   virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {
     actions_.push_back("ScheduledActionBeginOutputSurfaceCreation");
     states_.push_back(scheduler_->StateAsValue().release());
   }
   virtual void ScheduledActionAcquireLayerTexturesForMainThread() OVERRIDE {
     actions_.push_back("ScheduledActionAcquireLayerTexturesForMainThread");
     states_.push_back(scheduler_->StateAsValue().release());
   }
+  virtual void ScheduledActionManageTiles() OVERRIDE {
+    actions_.push_back("ScheduledActionManageTiles");
+    states_.push_back(scheduler_->StateAsValue().release());
+  }
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {}
   virtual base::TimeDelta DrawDurationEstimate() OVERRIDE {
     return base::TimeDelta();
   }
   virtual base::TimeDelta BeginFrameToCommitDurationEstimate() OVERRIDE {
     return base::TimeDelta();
   }
   virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE {
     return base::TimeDelta();
   }
@@ skipping 530 matching lines @@
   client.Reset();
   scheduler->SetNeedsForcedCommitForReadback();
   scheduler->FinishCommit();
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndReadback"));
 
   // The replacement commit comes in after 2 readbacks.
   client.Reset();
   scheduler->FinishCommit();
 }
 
+
+class SchedulerClientNeedsManageTilesInDraw : public FakeSchedulerClient {
+ public:
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
+      OVERRIDE {
+    scheduler_->SetNeedsManageTiles();
+    return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
+  }
+};
+
+// Test manage tiles is independant of draws.
+TEST(SchedulerTest, ManageTiles) {
+  SchedulerClientNeedsManageTilesInDraw client;
+  SchedulerSettings default_scheduler_settings;
+  Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
+  scheduler->SetCanStart();
+  scheduler->SetVisible(true);
+  scheduler->SetCanDraw(true);
+  InitializeOutputSurfaceAndFirstCommit(scheduler);
+
+  // Request both draw and manage tiles. ManageTiles shouldn't
+  // be trigged until BeginFrame.
+  client.Reset();
+  scheduler->SetNeedsManageTiles();
+  scheduler->SetNeedsRedraw();
+  EXPECT_TRUE(scheduler->RedrawPending());
+  EXPECT_TRUE(scheduler->ManageTilesPending());
+  EXPECT_TRUE(client.needs_begin_frame());
+  EXPECT_EQ(0, client.num_draws());
+  EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
+  EXPECT_FALSE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  // The actions should have occured, in the right order.
+  EXPECT_EQ(1, client.num_draws());
+  EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
+  EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
+            client.ActionIndex("ScheduledActionManageTiles"));
+  EXPECT_FALSE(scheduler->RedrawPending());
+  EXPECT_FALSE(scheduler->ManageTilesPending());
+
+  // Request a draw. We don't need a ManageTiles yet.
+  client.Reset();
+  scheduler->SetNeedsRedraw();
+  EXPECT_TRUE(scheduler->RedrawPending());
+  EXPECT_FALSE(scheduler->ManageTilesPending());
+  EXPECT_TRUE(client.needs_begin_frame());
+  EXPECT_EQ(0, client.num_draws());
+
+  // Draw. The draw will trigger SetNeedsManageTiles, and

[enne (OOO), 2013/09/13 18:15:01]

Where does the draw trigger SetNeedsManageTiles?

[epenner, 2013/09/13 18:45:45]

The test does this via SchedulerClientNeedsManageTilesInDraw. In the real code
any call to DidModifyTilePriorities will trigger it, primarily
PictureLayerImpl::UpdateTilePriorities

+  // then the ManageTiles action will be triggered after the Draw.
+  // Afterwards, neither a draw nor ManageTiles are pending.
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  EXPECT_EQ(1, client.num_draws());
+  EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
+  EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
+            client.ActionIndex("ScheduledActionManageTiles"));
+  EXPECT_FALSE(scheduler->RedrawPending());
+  EXPECT_FALSE(scheduler->ManageTilesPending());
+
+  // Now trigger a ManageTiles outside of a draw. We will then need
+  // a begin-frame for the ManageTiles, but we don't need a draw.
+  client.Reset();
+  EXPECT_FALSE(client.needs_begin_frame());
+  scheduler->SetNeedsManageTiles();
+  EXPECT_TRUE(client.needs_begin_frame());
+  EXPECT_TRUE(scheduler->ManageTilesPending());
+  EXPECT_FALSE(scheduler->RedrawPending());
+
+  // BeginFrame. There will be no draw, only ManageTiles.
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  EXPECT_EQ(0, client.num_draws());
+  EXPECT_FALSE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
+}
+
 }  // namespace
 }  // namespace cc