Removed obsolete headless C++ tests that where replaced with JS equivalents.

Change-Id: I56bb2d9930203b0a1668b6f00b9fdcd89fcf1e3e
Reviewed-on: https://chromium-review.googlesource.com/1155745Reviewed-by: Pavel Feldman <pfeldman@chromium.org>
Commit-Queue: Peter Kvitek <kvitekp@chromium.org>
Cr-Commit-Position: refs/heads/master@{#579197}

headless/BUILD.gn

@@ -346,14 +346,10 @@ component("headless") {
     "public/internal/headless_devtools_client_impl.h",
     "public/internal/message_dispatcher.h",
     "public/internal/value_conversions.h",
-    "public/util/compositor_controller.cc",
-    "public/util/compositor_controller.h",
     "public/util/error_reporter.cc",
     "public/util/error_reporter.h",
     "public/util/user_agent.cc",
     "public/util/user_agent.h",
-    "public/util/virtual_time_controller.cc",
-    "public/util/virtual_time_controller.h",
   ]
 
   if (!is_fuchsia) {
@@ -557,9 +553,7 @@ group("headless_tests") {
 test("headless_unittests") {
   sources = [
     "public/domains/types_unittest.cc",
-    "public/util/compositor_controller_unittest.cc",
     "public/util/error_reporter_unittest.cc",
-    "public/util/virtual_time_controller_test.cc",
   ]
 
   if (!is_component_build) {
@@ -686,7 +680,6 @@ test("headless_browsertests") {
     "lib/headless_browser_context_browsertest.cc",
     "lib/headless_devtools_client_browsertest.cc",
     "lib/headless_web_contents_browsertest.cc",
-    "public/util/compositor_controller_browsertest.cc",
     "test/headless_browser_test.cc",
     "test/headless_browser_test.h",
     "test/headless_client_browsertest.cc",
@@ -745,12 +738,7 @@ test("headless_browsertests") {
   if (is_linux) {
     # Only include this if we built the js_binary
     data += [ "$root_out_dir/headless_browser_tests.pak" ]
-    sources += [
-      "test/headless_js_bindings_browsertest.cc",
-      "test/headless_render_browsertest.cc",
-      "test/headless_render_test.cc",
-      "test/headless_render_test.h",
-    ]
+    sources += [ "test/headless_js_bindings_browsertest.cc" ]
     deps += [
       ":headless_browser_tests_pak",
       "//ui/gfx:geometry_skia",

headless/public/util/DEPS

 specific_include_rules = {
-  "compositor_controller_browsertest.cc": [
-    "+cc/base/switches.h",
-    "+components/viz/common/features.h",
-    "+components/viz/common/switches.h",
-    "+third_party/skia/include",
-  ]
 }
 

headless/public/util/compositor_controller.h

-// Copyright 2017 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.
-
-#ifndef HEADLESS_PUBLIC_UTIL_COMPOSITOR_CONTROLLER_H_
-#define HEADLESS_PUBLIC_UTIL_COMPOSITOR_CONTROLLER_H_
-
-#include "base/callback.h"
-#include "base/cancelable_callback.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "base/sequenced_task_runner.h"
-#include "base/time/time.h"
-#include "headless/public/devtools/domains/headless_experimental.h"
-#include "headless/public/headless_devtools_client.h"
-
-namespace headless {
-
-class VirtualTimeController;
-
-// Issues BeginFrames (Chromium's vsync signal) while virtual time advances and
-// and takes screenshots.
-class HEADLESS_EXPORT CompositorController
-    : public headless_experimental::ExperimentalObserver {
- public:
-  using BeginFrameResult = headless_experimental::BeginFrameResult;
-  using NeedsBeginFramesChangedParams =
-      headless_experimental::NeedsBeginFramesChangedParams;
-  using ScreenshotParams = headless_experimental::ScreenshotParams;
-  using ScreenshotParamsFormat = headless_experimental::ScreenshotParamsFormat;
-
-  // |animation_begin_frame_interval| specifies the virtual time between
-  // individual BeginFrames while virtual time advances.
-  // If |update_display_for_animations| is false, animation BeginFrames will not
-  // commit or draw visual updates to the display. This can be used to reduce
-  // the overhead of such BeginFrames in the common case that screenshots will
-  // be taken from separate BeginFrames.
-  CompositorController(
-      scoped_refptr<base::SequencedTaskRunner> task_runner,
-      HeadlessDevToolsClient* devtools_client,
-      VirtualTimeController* virtual_time_controller,
-      base::TimeDelta animation_begin_frame_interval,
-      bool update_display_for_animations = true);
-  ~CompositorController() override;
-
-  // Executes |idle_callback| when no BeginFrames are in flight.
-  void WaitUntilIdle(base::OnceClosure idle_callback);
-
-  // Captures a screenshot by issuing a BeginFrame. |quality| is only valid for
-  // jpeg format screenshots, in range 0..100. Should not be called again until
-  // |screenshot_captured_callback| was run. Should only be called while no
-  // other BeginFrame is in flight and after the compositor is ready.
-  void CaptureScreenshot(ScreenshotParamsFormat format,
-                         int quality,
-                         base::OnceCallback<void(const std::string&)>
-                             screenshot_captured_callback);
-
- private:
-  class AnimationBeginFrameTask;
-
-  // headless_experimental_::Observer implementation:
-  void OnNeedsBeginFramesChanged(
-      const NeedsBeginFramesChangedParams& params) override;
-
-  // Posts a BeginFrame as a new task to avoid nesting it inside the current
-  // callstack, which can upset the compositor.
-  void PostBeginFrame(
-      base::OnceCallback<void(std::unique_ptr<BeginFrameResult>)>
-          begin_frame_complete_callback,
-      bool no_display_updates = false,
-      std::unique_ptr<ScreenshotParams> screenshot = nullptr);
-  // Issues a BeginFrame synchronously and runs |begin_frame_complete_callback|
-  // when done. Should not be called again until |begin_frame_complete_callback|
-  // was run.
-  void BeginFrame(base::OnceCallback<void(std::unique_ptr<BeginFrameResult>)>
-                      begin_frame_complete_callback,
-                  bool no_display_updates = false,
-                  std::unique_ptr<ScreenshotParams> screenshot = nullptr);
-  // Runs the |begin_frame_complete_callback_| and the |idle_callback_| if set.
-  void BeginFrameComplete(std::unique_ptr<BeginFrameResult>);
-
-  void CaptureScreenshotBeginFrameComplete(
-      std::unique_ptr<BeginFrameResult> result);
-
-  scoped_refptr<base::SequencedTaskRunner> task_runner_;
-  HeadlessDevToolsClient* devtools_client_;         // NOT OWNED
-  VirtualTimeController* virtual_time_controller_;  // NOT OWNED
-  std::unique_ptr<AnimationBeginFrameTask> animation_task_;
-  base::OnceClosure idle_callback_;
-  base::OnceCallback<void(const std::string&)> screenshot_captured_callback_;
-  base::OnceCallback<void(std::unique_ptr<BeginFrameResult>)>
-      begin_frame_complete_callback_;
-  base::TimeDelta animation_begin_frame_interval_;
-  bool update_display_for_animations_;
-  bool needs_begin_frames_ = false;
-  base::TimeTicks last_begin_frame_time_;
-  base::WeakPtrFactory<CompositorController> weak_ptr_factory_;
-};
-
-}  // namespace headless
-
-#endif  // HEADLESS_PUBLIC_UTIL_COMPOSITOR_CONTROLLER_H_

headless/public/util/virtual_time_controller.cc

-// Copyright 2017 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 "headless/public/util/virtual_time_controller.h"
-
-#include "base/auto_reset.h"
-#include "base/bind.h"
-#include "base/logging.h"
-
-namespace headless {
-
-using base::TimeDelta;
-
-VirtualTimeController::VirtualTimeController(
-    HeadlessDevToolsClient* devtools_client,
-    int max_task_starvation_count)
-    : devtools_client_(devtools_client),
-      max_task_starvation_count_(max_task_starvation_count),
-      weak_ptr_factory_(this) {
-  devtools_client_->GetEmulation()->GetExperimental()->AddObserver(this);
-}
-
-VirtualTimeController::~VirtualTimeController() {
-  devtools_client_->GetEmulation()->GetExperimental()->RemoveObserver(this);
-}
-
-void VirtualTimeController::StartVirtualTime() {
-  if (virtual_time_started_)
-    return;
-
-  TimeDelta next_budget;
-  bool wait_for_navigation = false;
-  for (auto& entry_pair : tasks_) {
-    entry_pair.second.ready_to_advance = true;
-    if (entry_pair.first->start_policy() ==
-        RepeatingTask::StartPolicy::WAIT_FOR_NAVIGATION) {
-      wait_for_navigation = true;
-    }
-    if (next_budget.is_zero()) {
-      next_budget =
-          entry_pair.second.next_execution_time - total_elapsed_time_offset_;
-    } else {
-      next_budget =
-          std::min(next_budget, entry_pair.second.next_execution_time -
-                                    total_elapsed_time_offset_);
-    }
-  }
-
-  // If there's no budget, then don't do anything!
-  if (next_budget.is_zero())
-    return;
-
-  virtual_time_started_ = true;
-  should_send_start_notification_ = true;
-
-  if (resume_deferrer_) {
-    resume_deferrer_->DeferResume(base::BindOnce(
-        &VirtualTimeController::SetVirtualTimePolicy,
-        weak_ptr_factory_.GetWeakPtr(), next_budget, wait_for_navigation));
-  } else {
-    SetVirtualTimePolicy(next_budget, wait_for_navigation);
-  }
-}
-
-void VirtualTimeController::NotifyTasksAndAdvance() {
-  // The task may call its continue callback synchronously. Prevent re-entrance.
-  if (in_notify_tasks_and_advance_)
-    return;
-
-  base::AutoReset<bool> reset(&in_notify_tasks_and_advance_, true);
-
-  for (auto iter = tasks_.begin(); iter != tasks_.end();) {
-    auto entry_pair = iter++;
-    if (entry_pair->second.next_execution_time <= total_elapsed_time_offset_) {
-      entry_pair->second.ready_to_advance = false;
-      entry_pair->second.next_execution_time =
-          total_elapsed_time_offset_ + entry_pair->second.interval;
-
-      // This may delete itself.
-      entry_pair->first->IntervalElapsed(
-          total_elapsed_time_offset_,
-          base::BindOnce(&VirtualTimeController::TaskReadyToAdvance,
-                         weak_ptr_factory_.GetWeakPtr(),
-                         base::Unretained(&entry_pair->second)));
-    }
-  }
-
-  // Give at most as much virtual time as available until the next callback.
-  bool advance_virtual_time = false;
-  bool stop_virtual_time = false;
-  bool ready_to_advance = true;
-  TimeDelta next_budget;
-  for (const auto& entry_pair : tasks_) {
-    ready_to_advance &= entry_pair.second.ready_to_advance;
-    if (next_budget.is_zero()) {
-      next_budget =
-          entry_pair.second.next_execution_time - total_elapsed_time_offset_;
-    } else {
-      next_budget =
-          std::min(next_budget, entry_pair.second.next_execution_time -
-                                    total_elapsed_time_offset_);
-    }
-    if (entry_pair.second.continue_policy ==
-        RepeatingTask::ContinuePolicy::CONTINUE_MORE_TIME_NEEDED) {
-      advance_virtual_time = true;
-    } else if (entry_pair.second.continue_policy ==
-               RepeatingTask::ContinuePolicy::STOP) {
-      stop_virtual_time = true;
-    }
-  }
-
-  if (!ready_to_advance)
-    return;
-
-  if (!advance_virtual_time || stop_virtual_time) {
-    for (auto& entry_pair : tasks_) {
-      entry_pair.second.ready_to_advance = false;
-    }
-
-    for (auto iter = observers_.begin(); iter != observers_.end();) {
-      Observer* observer = *iter++;
-      // |observer| may delete itself.
-      observer->VirtualTimeStopped(total_elapsed_time_offset_);
-    }
-    virtual_time_started_ = false;
-    return;
-  }
-
-  DCHECK(!next_budget.is_zero());
-  if (resume_deferrer_) {
-    resume_deferrer_->DeferResume(
-        base::BindOnce(&VirtualTimeController::SetVirtualTimePolicy,
-                       weak_ptr_factory_.GetWeakPtr(), next_budget,
-                       false /* wait_for_navigation */));
-  } else {
-    SetVirtualTimePolicy(next_budget, false /* wait_for_navigation */);
-  }
-}
-
-void VirtualTimeController::TaskReadyToAdvance(
-    TaskEntry* entry,
-    RepeatingTask::ContinuePolicy continue_policy) {
-  entry->ready_to_advance = true;
-  entry->continue_policy = continue_policy;
-  NotifyTasksAndAdvance();
-}
-
-void VirtualTimeController::SetVirtualTimePolicy(base::TimeDelta next_budget,
-                                                 bool wait_for_navigation) {
-  last_budget_ = next_budget;
-  devtools_client_->GetEmulation()->GetExperimental()->SetVirtualTimePolicy(
-      emulation::SetVirtualTimePolicyParams::Builder()
-          .SetPolicy(
-              emulation::VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING)
-          .SetBudget(next_budget.InMillisecondsF())
-          .SetMaxVirtualTimeTaskStarvationCount(max_task_starvation_count_)
-          .SetWaitForNavigation(wait_for_navigation)
-          .Build(),
-      base::BindOnce(&VirtualTimeController::SetVirtualTimePolicyDone,
-                     weak_ptr_factory_.GetWeakPtr()));
-}
-
-void VirtualTimeController::SetVirtualTimePolicyDone(
-    std::unique_ptr<emulation::SetVirtualTimePolicyResult> result) {
-  if (result) {
-    virtual_time_base_ =
-        base::TimeTicks() +
-        base::TimeDelta::FromMillisecondsD(result->GetVirtualTimeTicksBase());
-  } else {
-    LOG(WARNING) << "SetVirtualTimePolicy did not succeed";
-  }
-
-  if (should_send_start_notification_) {
-    should_send_start_notification_ = false;
-    for (auto iter = observers_.begin(); iter != observers_.end();) {
-      Observer* observer = *iter++;
-      // |observer| may delete itself.
-      observer->VirtualTimeStarted(total_elapsed_time_offset_);
-    }
-  }
-}
-
-void VirtualTimeController::OnVirtualTimeBudgetExpired(
-    const emulation::VirtualTimeBudgetExpiredParams& params) {
-  total_elapsed_time_offset_ += last_budget_;
-  virtual_time_paused_ = true;
-  NotifyTasksAndAdvance();
-}
-
-void VirtualTimeController::ScheduleRepeatingTask(RepeatingTask* task,
-                                                  base::TimeDelta interval) {
-  if (!virtual_time_paused_) {
-    // We cannot accurately modify any previously granted virtual time budget.
-    LOG(WARNING) << "VirtualTimeController tasks should be added while "
-                    "virtual time is paused.";
-  }
-
-  TaskEntry entry;
-  entry.interval = interval;
-  entry.next_execution_time = total_elapsed_time_offset_ + entry.interval;
-  tasks_.insert(std::make_pair(task, entry));
-}
-
-void VirtualTimeController::CancelRepeatingTask(RepeatingTask* task) {
-  tasks_.erase(task);
-}
-
-void VirtualTimeController::AddObserver(Observer* observer) {
-  observers_.insert(observer);
-}
-
-void VirtualTimeController::RemoveObserver(Observer* observer) {
-  observers_.erase(observer);
-}
-
-base::TimeTicks VirtualTimeController::GetVirtualTimeBase() const {
-  return virtual_time_base_;
-}
-
-base::TimeDelta VirtualTimeController::GetCurrentVirtualTimeOffset() const {
-  return total_elapsed_time_offset_;
-}
-
-void VirtualTimeController::SetResumeDeferrer(ResumeDeferrer* resume_deferrer) {
-  resume_deferrer_ = resume_deferrer;
-}
-
-}  // namespace headless

headless/public/util/virtual_time_controller.h

-// Copyright 2017 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.
-
-#ifndef HEADLESS_PUBLIC_UTIL_VIRTUAL_TIME_CONTROLLER_H_
-#define HEADLESS_PUBLIC_UTIL_VIRTUAL_TIME_CONTROLLER_H_
-
-#include "base/callback.h"
-#include "base/time/time.h"
-#include "headless/public/devtools/domains/emulation.h"
-#include "headless/public/headless_devtools_client.h"
-#include "headless/public/headless_export.h"
-
-namespace headless {
-
-// Controls how virtual time progresses. RepeatingTasks can register their
-// interest to be periodically notified about changes to the current virtual
-// time.
-class HEADLESS_EXPORT VirtualTimeController
-    : public emulation::ExperimentalObserver {
- public:
-  VirtualTimeController(HeadlessDevToolsClient* devtools_client,
-                        int max_task_starvation_count = 0);
-  ~VirtualTimeController() override;
-
-  // Signals that virtual time should start advancing. If virtual time is
-  // already running, this does nothing.  When virtual time is ready to start
-  // the observers will be notified.
-  virtual void StartVirtualTime();
-
-  class RepeatingTask {
-   public:
-    // This policy controls whether or not StartVirtualTime() should wait for a
-    // navigation first.
-    enum StartPolicy {
-      WAIT_FOR_NAVIGATION,
-      START_IMMEDIATELY,
-    };
-
-    explicit RepeatingTask(StartPolicy start_policy, int priority)
-        : start_policy_(start_policy), priority_(priority) {}
-
-    virtual ~RepeatingTask() {}
-
-    enum class ContinuePolicy {
-      CONTINUE_MORE_TIME_NEEDED,
-      NOT_REQUIRED,
-      STOP,  // Note STOP trumps CONTINUE_MORE_TIME_NEEDED.
-    };
-
-    // Called when the tasks's requested virtual time interval has elapsed.
-    // |virtual_time_offset| is the virtual time duration that has advanced
-    // since the page started loading (millisecond granularity). When the task
-    // has completed it's perioodic work it should call |continue_callback|
-    // with CONTINUE_MORE_TIME_NEEDED if it wants virtual time to continue
-    // advancing, or NOT_REQUIRED otherwise.  Virtual time will continue to
-    // advance until all RepeatingTasks want it to stop.
-    virtual void IntervalElapsed(
-        base::TimeDelta virtual_time_offset,
-        base::OnceCallback<void(ContinuePolicy policy)> continue_callback) = 0;
-
-    StartPolicy start_policy() const { return start_policy_; }
-
-    int priority() const { return priority_; }
-
-   private:
-    const StartPolicy start_policy_;
-
-    // If more than one RepeatingTask is scheduled to run at any instant they
-    // are run in order of ascending |priority_|.
-    const int priority_;
-  };
-
-  // An API used by the CompositorController to defer the start and resumption
-  // of virtual time until it's ready.
-  class ResumeDeferrer {
-   public:
-    virtual ~ResumeDeferrer() {}
-
-    // Called before virtual time progression resumes after it was stopped or
-    // paused to execute repeating tasks.
-    virtual void DeferResume(base::OnceClosure ready_callback) = 0;
-  };
-
-  class Observer {
-   public:
-    virtual ~Observer() {}
-
-    // Called when StartVirtualTime was called. May be delayed by a
-    // StartDeferrer.
-    virtual void VirtualTimeStarted(base::TimeDelta virtual_time_offset) = 0;
-
-    // Called when all RepeatingTasks have either voted for virtual time to stop
-    // advancing, or all have been removed.
-    virtual void VirtualTimeStopped(base::TimeDelta virtual_time_offset) = 0;
-  };
-
-  // Interleaves execution of the provided |task| with progression of virtual
-  // time. The task will be notified whenever another |interval| of virtual time
-  // have elapsed, as well as when the last granted budget has been used up.
-  //
-  // To ensure that the task is notified of elapsed intervals accurately, it
-  // should be added while virtual time is paused.
-  virtual void ScheduleRepeatingTask(RepeatingTask* task,
-                                     base::TimeDelta interval);
-  virtual void CancelRepeatingTask(RepeatingTask* task);
-
-  // Adds an observer which is notified when virtual time starts and stops.
-  virtual void AddObserver(Observer* observer);
-  virtual void RemoveObserver(Observer* observer);
-
-  // Returns the time that virtual time offsets are relative to.
-  virtual base::TimeTicks GetVirtualTimeBase() const;
-
-  // Returns the current virtual time offset. Only accurate while virtual time
-  // is paused.
-  virtual base::TimeDelta GetCurrentVirtualTimeOffset() const;
-
-  // Returns the current virtual time stamp. Only accurate while virtual time
-  // is paused.
-  base::TimeTicks GetCurrentVirtualTime() const {
-    return GetVirtualTimeBase() + GetCurrentVirtualTimeOffset();
-  }
-
-  virtual void SetResumeDeferrer(ResumeDeferrer* resume_deferrer);
-
- private:
-  struct TaskEntry {
-    base::TimeDelta interval;
-    base::TimeDelta next_execution_time;
-    bool ready_to_advance = true;
-    RepeatingTask::ContinuePolicy continue_policy =
-        RepeatingTask::ContinuePolicy::CONTINUE_MORE_TIME_NEEDED;
-  };
-
-  void ObserverReadyToStart();
-
-  // emulation::Observer implementation:
-  void OnVirtualTimeBudgetExpired(
-      const emulation::VirtualTimeBudgetExpiredParams& params) override;
-
-  void NotifyTasksAndAdvance();
-  void NotifyTaskIntervalElapsed(TaskEntry* entry);
-  void NotifyTaskVirtualTimeStarted(TaskEntry* entry);
-  void TaskReadyToAdvance(TaskEntry* entry,
-                          RepeatingTask::ContinuePolicy continue_policy);
-
-  void SetVirtualTimePolicy(base::TimeDelta next_budget,
-                            bool wait_for_navigation);
-  void SetVirtualTimePolicyDone(
-      std::unique_ptr<emulation::SetVirtualTimePolicyResult>);
-
-  HeadlessDevToolsClient* const devtools_client_;  // NOT OWNED
-  ResumeDeferrer* resume_deferrer_ = nullptr;      // NOT OWNED
-  const int max_task_starvation_count_;
-
-  base::TimeDelta total_elapsed_time_offset_;
-  base::TimeDelta last_budget_;
-  // Initial virtual time that virtual time offsets are relative to.
-  base::TimeTicks virtual_time_base_;
-
-  struct RepeatingTaskOrdering {
-    bool operator()(RepeatingTask* a, RepeatingTask* b) const {
-      if (a->priority() == b->priority())
-        return a < b;
-      return a->priority() < b->priority();
-    };
-  };
-
-  std::map<RepeatingTask*, TaskEntry, RepeatingTaskOrdering> tasks_;
-  std::set<Observer*> observers_;
-  bool in_notify_tasks_and_advance_ = false;
-  bool virtual_time_started_ = false;
-  bool virtual_time_paused_ = true;
-  bool should_send_start_notification_ = false;
-
-  base::WeakPtrFactory<VirtualTimeController> weak_ptr_factory_;
-};
-
-}  // namespace headless
-
-#endif  // HEADLESS_PUBLIC_UTIL_VIRTUAL_TIME_CONTROLLER_H_

headless/test/DEPS

 specific_include_rules = {
-  "headless_render_test.cc": [
-    "+cc/base/switches.h",
-    "+components/viz/common/features.h",
-    "+components/viz/common/switches.h",
-    "+third_party/skia/include",
-  ],
   "headless_protocol_browsertest.cc": [
     "+cc/base/switches.h",
     "+components/viz/common/features.h",