cc: Remove ResourceUpdateQueue and ResourceUpdateController.

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 42 matching lines @@
         scheduler_(nullptr) {
     Reset();
   }
 
   void Reset() {
     actions_.clear();
     states_.clear();
     draw_will_happen_ = true;
     swap_will_happen_if_draw_happens_ = true;
     num_draws_ = 0;
-    log_anticipated_draw_time_change_ = false;
     begin_frame_args_sent_to_children_ = BeginFrameArgs();
   }
 
   void set_scheduler(TestScheduler* scheduler) { scheduler_ = scheduler; }
 
-  // Most tests don't care about DidAnticipatedDrawTimeChange, so only record it
-  // for tests that do.
-  void set_log_anticipated_draw_time_change(bool log) {
-    log_anticipated_draw_time_change_ = log;
-  }
   bool needs_begin_frames() {
     return scheduler_->frame_source().NeedsBeginFrames();
   }
   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]; }
   std::string StateForAction(int i) const { return states_[i]->ToString(); }
   base::TimeTicks posted_begin_impl_frame_deadline() const {
     return posted_begin_impl_frame_deadline_;
   }
@@ skipping 56 matching lines @@
   void ScheduledActionBeginOutputSurfaceCreation() override {
     PushAction("ScheduledActionBeginOutputSurfaceCreation");
   }
   void ScheduledActionPrepareTiles() override {
     PushAction("ScheduledActionPrepareTiles");
   }
   void ScheduledActionInvalidateOutputSurface() override {
     actions_.push_back("ScheduledActionInvalidateOutputSurface");
     states_.push_back(scheduler_->AsValue());
   }
-  void DidAnticipatedDrawTimeChange(base::TimeTicks) override {
-    if (log_anticipated_draw_time_change_)
-      PushAction("DidAnticipatedDrawTimeChange");
-  }
   base::TimeDelta DrawDurationEstimate() override { return base::TimeDelta(); }
   base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
     return base::TimeDelta();
   }
   base::TimeDelta CommitToActivateDurationEstimate() override {
     return base::TimeDelta();
   }
 
   void SendBeginFramesToChildren(const BeginFrameArgs& args) override {
     begin_frame_args_sent_to_children_ = args;
@@ skipping 24 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_;
   BeginFrameArgs begin_frame_args_sent_to_children_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   std::vector<scoped_refptr<base::trace_event::ConvertableToTraceFormat>>
       states_;
   TestScheduler* scheduler_;
 };
 
 class SchedulerClientWithFixedEstimates : public FakeSchedulerClient {
  public:
@@ skipping 549 matching lines @@
     }
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
   DrawResult ScheduledActionDrawAndSwapForced() override {
     NOTREACHED();
     return DRAW_SUCCESS;
   }
 
   void ScheduledActionCommit() override {}
-  void DidAnticipatedDrawTimeChange(base::TimeTicks) override {}
 
  private:
   bool request_redraws_;
 };
 
 // Tests for two different situations:
 // 1. the scheduler dropping SetNeedsRedraw requests that happen inside
 //    a ScheduledActionDrawAndSwap
 // 2. the scheduler drawing twice inside a single tick
 TEST_F(SchedulerTest, RequestRedrawInsideDraw) {
@@ skipping 91 matching lines @@
     }
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
   DrawResult ScheduledActionDrawAndSwapForced() override {
     NOTREACHED();
     return DRAW_SUCCESS;
   }
 
   void ScheduledActionCommit() override {}
-  void DidAnticipatedDrawTimeChange(base::TimeTicks) override {}
 
   void SetNeedsCommitOnNextDraw() { set_needs_commit_on_next_draw_ = true; }
 
  private:
   bool set_needs_commit_on_next_draw_;
 };
 
 // Tests for the scheduler infinite-looping on SetNeedsCommit requests that
 // happen inside a ScheduledActionDrawAndSwap
 TEST_F(SchedulerTest, RequestCommitInsideDraw) {
@@ skipping 499 matching lines @@
   EXPECT_SCOPED(MainFrameInHighLatencyMode(1, 10, false, true));
 }
 
 TEST_F(SchedulerTest, NotSkipMainFrameInPreferImplLatencyMode) {
   // Set up client so that estimates indicate that we can commit and activate
   // before the deadline (~8ms by default), but also enable impl latency takes
   // priority mode.
   EXPECT_SCOPED(MainFrameInHighLatencyMode(1, 1, true, true));
 }
 
-TEST_F(SchedulerTest,
-       Deadlock_NotifyReadyToCommitMakesProgressWhileSwapTrottled) {
-  // NPAPI plugins on Windows block the Browser UI thread on the Renderer main
-  // thread. This prevents the scheduler from receiving any pending swap acks.
-  // This test makes sure that we keep updating the TextureUploader with
-  // DidAnticipatedDrawTimeChange's so that it can make forward progress and
-  // upload all the textures needed for the commit to complete.
-
-  // Since we are simulating a long commit, set up a client with draw duration
-  // estimates that prevent skipping main frames to get to low latency mode.
-  SchedulerClientWithFixedEstimates* client =
-      new SchedulerClientWithFixedEstimates(
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMilliseconds(32),
-          base::TimeDelta::FromMilliseconds(32));
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client).Pass(), true);
-
-  client->set_log_anticipated_draw_time_change(true);
-
-  BeginFrameArgs frame_args =
-      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
-  frame_args.interval = base::TimeDelta::FromMilliseconds(1000);
-
-  // At this point, we've drawn a frame. Start another commit, but hold off on
-  // the NotifyReadyToCommit for now.
-  EXPECT_FALSE(scheduler_->CommitPending());
-  scheduler_->SetNeedsCommit();
-  fake_external_begin_frame_source()->TestOnBeginFrame(frame_args);
-  EXPECT_TRUE(scheduler_->CommitPending());
-
-  // Draw and swap the frame, but don't ack the swap to simulate the Browser
-  // blocking on the renderer.
-  EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
-  task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
-  scheduler_->DidSwapBuffers();
-
-  // Spin the event loop a few times and make sure we get more
-  // DidAnticipateDrawTimeChange calls every time.
-  int actions_so_far = client->num_actions_();
-
-  // Does three iterations to make sure that the timer is properly repeating.
-  for (int i = 0; i < 3; ++i) {
-    EXPECT_EQ((frame_args.interval * 2).InMicroseconds(),
-              task_runner().DelayToNextTaskTime().InMicroseconds())
-        << scheduler_->AsValue()->ToString();
-    task_runner().RunPendingTasks();
-    EXPECT_GT(client->num_actions_(), actions_so_far);
-    EXPECT_STREQ(client->Action(client->num_actions_() - 1),
-                 "DidAnticipatedDrawTimeChange");
-    actions_so_far = client->num_actions_();
-  }
-
-  // Do the same thing after BeginMainFrame starts but still before activation.
-  scheduler_->NotifyBeginMainFrameStarted();
-  for (int i = 0; i < 3; ++i) {
-    EXPECT_EQ((frame_args.interval * 2).InMicroseconds(),
-              task_runner().DelayToNextTaskTime().InMicroseconds())
-        << scheduler_->AsValue()->ToString();
-    task_runner().RunPendingTasks();
-    EXPECT_GT(client->num_actions_(), actions_so_far);
-    EXPECT_STREQ(client->Action(client->num_actions_() - 1),
-                 "DidAnticipatedDrawTimeChange");
-    actions_so_far = client->num_actions_();
-  }
-}
-
 TEST_F(
     SchedulerTest,
     Deadlock_CommitMakesProgressWhileSwapTrottledAndActiveTreeNeedsFirstDraw) {
   // NPAPI plugins on Windows block the Browser UI thread on the Renderer main
   // thread. This prevents the scheduler from receiving any pending swap acks.
 
   // Since we are simulating a long commit, set up a client with draw duration
   // estimates that prevent skipping main frames to get to low latency mode.
   SchedulerClientWithFixedEstimates* client =
       new SchedulerClientWithFixedEstimates(
@@ skipping 1583 matching lines @@
   scheduler_->SetImplLatencyTakesPriority(true);
   scheduler_->SetChildrenNeedBeginFrames(true);
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->begin_frame_is_sent_to_children());
   EXPECT_FALSE(client_->begin_frame_args_sent_to_children().on_critical_path);
 }
 
 }  // namespace
 }  // namespace cc