SetNeedsRedraw directly when updating a visible tile.

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/debug/trace_event.h"
@@ skipping 70 matching lines @@
       base::MessageLoop::current()->RunUntilIdle();
     }
     bool IsOnBatteryPowerImpl() override { return on_battery_power_impl_; }
 
    private:
     bool on_battery_power_impl_;
   };
 
   FakeSchedulerClient()
       : automatic_swap_ack_(true),
-        swap_contains_incomplete_tile_(false),
-        redraw_will_happen_if_update_visible_tiles_happens_(false),
         now_src_(TestNowSource::Create()),
         task_runner_(new OrderedSimpleTaskRunner(now_src_, true)),
         fake_external_begin_frame_source_(nullptr),
         fake_power_monitor_source_(new FakePowerMonitorSource),
         power_monitor_(make_scoped_ptr<base::PowerMonitorSource>(
             fake_power_monitor_source_)),
         scheduler_(nullptr) {
     // A bunch of tests require Now() to be > BeginFrameArgs::DefaultInterval()
     now_src_->AdvanceNow(base::TimeDelta::FromMilliseconds(100));
     // Fail if we need to run 100 tasks in a row.
@@ skipping 81 matching lines @@
   OrderedSimpleTaskRunner& task_runner() { return *task_runner_; }
   TestNowSource* now_src() { return now_src_.get(); }
 
   int ActionIndex(const char* action) const {
     for (size_t i = 0; i < actions_.size(); i++)
       if (!strcmp(actions_[i], action))
         return i;
     return -1;
   }
 
-  void SetSwapContainsIncompleteTile(bool contain) {
-    swap_contains_incomplete_tile_ = contain;
-  }
-
   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;
   }
   void SetAutomaticSwapAck(bool automatic_swap_ack) {
     automatic_swap_ack_ = automatic_swap_ack;
   }
-  void SetRedrawWillHappenIfUpdateVisibleTilesHappens(bool redraw) {
-    redraw_will_happen_if_update_visible_tiles_happens_ = redraw;
-  }
   // SchedulerClient implementation.
   void WillBeginImplFrame(const BeginFrameArgs& args) override {
     actions_.push_back("WillBeginImplFrame");
     states_.push_back(scheduler_->AsValue());
   }
   void ScheduledActionSendBeginMainFrame() override {
     actions_.push_back("ScheduledActionSendBeginMainFrame");
     states_.push_back(scheduler_->AsValue());
   }
   void ScheduledActionAnimate() override {
     actions_.push_back("ScheduledActionAnimate");
     states_.push_back(scheduler_->AsValue());
   }
   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     actions_.push_back("ScheduledActionDrawAndSwapIfPossible");
     states_.push_back(scheduler_->AsValue());
     num_draws_++;
     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 (swap_contains_incomplete_tile_) {
-        scheduler_->SetSwapUsedIncompleteTile(true);
-        swap_contains_incomplete_tile_ = false;
-      } else {
-        scheduler_->SetSwapUsedIncompleteTile(false);
-      }
 
       if (automatic_swap_ack_)
         scheduler_->DidSwapBuffersComplete();
     }
     return result;
   }
   DrawResult ScheduledActionDrawAndSwapForced() override {
     actions_.push_back("ScheduledActionDrawAndSwapForced");
     states_.push_back(scheduler_->AsValue());
     return DRAW_SUCCESS;
   }
   void ScheduledActionCommit() override {
     actions_.push_back("ScheduledActionCommit");
     states_.push_back(scheduler_->AsValue());
   }
-  void ScheduledActionUpdateVisibleTiles() override {
-    actions_.push_back("ScheduledActionUpdateVisibleTiles");
-    states_.push_back(scheduler_->AsValue());
-    if (redraw_will_happen_if_update_visible_tiles_happens_)
-      scheduler_->SetNeedsRedraw();
-  }
   void ScheduledActionActivateSyncTree() override {
     actions_.push_back("ScheduledActionActivateSyncTree");
     states_.push_back(scheduler_->AsValue());
   }
   void ScheduledActionBeginOutputSurfaceCreation() override {
     actions_.push_back("ScheduledActionBeginOutputSurfaceCreation");
     states_.push_back(scheduler_->AsValue());
   }
   void ScheduledActionManageTiles() override {
     actions_.push_back("ScheduledActionManageTiles");
@@ skipping 22 matching lines @@
  protected:
   bool ImplFrameDeadlinePendingCallback(bool state) {
     return scheduler_->BeginImplFrameDeadlinePending() == state;
   }
 
   bool draw_will_happen_;
   bool swap_will_happen_if_draw_happens_;
   bool automatic_swap_ack_;
   int num_draws_;
   bool log_anticipated_draw_time_change_;
-  bool swap_contains_incomplete_tile_;
-  bool redraw_will_happen_if_update_visible_tiles_happens_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   std::vector<scoped_refptr<base::debug::ConvertableToTraceFormat>> states_;
   scoped_refptr<TestNowSource> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   FakeExternalBeginFrameSource* fake_external_begin_frame_source_;
   FakePowerMonitorSource* fake_power_monitor_source_;
   base::PowerMonitor power_monitor_;
   scoped_ptr<TestScheduler> scheduler_;
 };
@@ skipping 687 matching lines @@
   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());
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   scheduler->DidManageTiles();  // Corresponds to ScheduledActionManageTiles
 }
 
-TEST(SchedulerTest, ShouldUpdateVisibleTiles) {
-  FakeSchedulerClient client;
-  SchedulerSettings scheduler_settings;
-  scheduler_settings.impl_side_painting = true;
-  scheduler_settings.use_external_begin_frame_source = true;
-  TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
-  scheduler->SetCanStart();
-  scheduler->SetVisible(true);
-  scheduler->SetCanDraw(true);
-  InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
-
-  client.SetRedrawWillHappenIfUpdateVisibleTilesHappens(true);
-
-  // SetNeedsCommit should begin the frame.
-  client.Reset();
-  scheduler->SetNeedsCommit();
-  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client);
-
-  client.Reset();
-  client.AdvanceFrame();
-  EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
-  EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
-  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
-
-  client.Reset();
-  scheduler->NotifyBeginMainFrameStarted();
-  scheduler->NotifyReadyToCommit();
-  EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
-
-  client.Reset();
-  scheduler->NotifyReadyToActivate();
-  EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client);
-
-  client.Reset();
-  client.SetSwapContainsIncompleteTile(true);
-  client.task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
-  EXPECT_FALSE(scheduler->RedrawPending());
-
-  client.Reset();
-  client.AdvanceFrame();
-  EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
-  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
-
-  client.Reset();
-  client.task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_ACTION("ScheduledActionUpdateVisibleTiles", client, 0, 3);
-  EXPECT_ACTION("ScheduledActionAnimate", client, 1, 3);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 2, 3);
-
-  client.Reset();
-  client.AdvanceFrame();
-  EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
-  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
-
-  // No more UpdateVisibleTiles().
-  client.Reset();
-  client.task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(false)", client);
-}
-
 TEST(SchedulerTest, TriggerBeginFrameDeadlineEarly) {
   SchedulerClientNeedsManageTilesInDraw client;
   SchedulerSettings scheduler_settings;
   scheduler_settings.use_external_begin_frame_source = true;
   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
@@ skipping 1085 matching lines @@
 
   // Deadline task is pending
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.task_runner().RunPendingTasks();
   // Deadline task runs immediately
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 }
 
 }  // namespace
 }  // namespace cc