Rename FakeRendererScheduler to WebFakeThreadScheduler.

FakeRendererScheduler is a fake for WebThreadScheduler (formerly
known as RendererScheduler), which is public to //content and other
files outside Blink. This CL renames its now-obsolete class name.

Bug: 826203
Tbr: sky@chromium.org
Change-Id: I371bdccd22dc57536193486d72da1cced0d752c0
Reviewed-on: https://chromium-review.googlesource.com/c/1319228
Commit-Queue: Yuta Kitamura <yutak@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#606752}

content/renderer/dom_storage/dom_storage_cached_area_unittest.cc

@@ -13,7 +13,7 @@
 #include "base/test/scoped_task_environment.h"
 #include "content/renderer/dom_storage/dom_storage_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/blink/public/platform/scheduler/test/fake_renderer_scheduler.h"
+#include "third_party/blink/public/platform/scheduler/test/web_fake_thread_scheduler.h"
 
 namespace content {
 
@@ -131,7 +131,7 @@ class DOMStorageCachedAreaTest : public testing::Test {
 
   void SetUp() override {
     main_thread_scheduler_ =
-        std::make_unique<blink::scheduler::FakeRendererScheduler>();
+        std::make_unique<blink::scheduler::WebFakeThreadScheduler>();
     mock_proxy_ = new MockProxy();
   }
 

content/renderer/dom_storage/local_storage_cached_area_unittest.cc

@@ -14,7 +14,7 @@
 #include "content/renderer/dom_storage/local_storage_cached_areas.h"
 #include "content/renderer/dom_storage/mock_leveldb_wrapper.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/blink/public/platform/scheduler/test/fake_renderer_scheduler.h"
+#include "third_party/blink/public/platform/scheduler/test/web_fake_thread_scheduler.h"
 
 namespace content {
 
@@ -27,8 +27,8 @@ class LocalStorageCachedAreaTest : public testing::Test {
         kPageUrl("http://dom_storage/page"),
         kStorageAreaId("7"),
         kSource(kPageUrl.spec() + "\n" + kStorageAreaId),
-        renderer_scheduler_(new blink::scheduler::FakeRendererScheduler()),
-        cached_areas_(&mock_leveldb_wrapper_, renderer_scheduler_.get()) {}
+        main_thread_scheduler_(new blink::scheduler::WebFakeThreadScheduler()),
+        cached_areas_(&mock_leveldb_wrapper_, main_thread_scheduler_.get()) {}
 
   const url::Origin kOrigin;
   const base::string16 kKey;
@@ -76,7 +76,7 @@ class LocalStorageCachedAreaTest : public testing::Test {
  protected:
   TestBrowserThreadBundle test_browser_thread_bundle_;
   MockLevelDBWrapper mock_leveldb_wrapper_;
-  std::unique_ptr<blink::scheduler::WebThreadScheduler> renderer_scheduler_;
+  std::unique_ptr<blink::scheduler::WebThreadScheduler> main_thread_scheduler_;
   LocalStorageCachedAreas cached_areas_;
 };
 

content/renderer/dom_storage/local_storage_cached_areas_unittest.cc

@@ -12,7 +12,7 @@
 #include "content/renderer/dom_storage/mock_leveldb_wrapper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/common/features.h"
-#include "third_party/blink/public/platform/scheduler/test/fake_renderer_scheduler.h"
+#include "third_party/blink/public/platform/scheduler/test/web_fake_thread_scheduler.h"
 
 namespace content {
 
@@ -41,11 +41,11 @@ TEST_F(LocalStorageCachedAreasTest, CacheLimit) {
   const std::string kStorageAreaId("7");
   const size_t kCacheLimit = 100;
 
-  blink::scheduler::FakeRendererScheduler renderer_scheduler;
+  blink::scheduler::WebFakeThreadScheduler thread_scheduler;
 
   MockLevelDBWrapper mock_leveldb_wrapper;
   LocalStorageCachedAreas cached_areas(&mock_leveldb_wrapper,
-                                       &renderer_scheduler);
+                                       &thread_scheduler);
   cached_areas.set_cache_limit_for_testing(kCacheLimit);
 
   scoped_refptr<LocalStorageCachedArea> cached_area1 =
@@ -79,11 +79,11 @@ TEST_F(LocalStorageCachedAreasTest, CloneBeforeGetArea) {
   const std::string kNamespace2 = base::GenerateGUID();
   const url::Origin kOrigin = url::Origin::Create(GURL("http://dom_storage1/"));
 
-  blink::scheduler::FakeRendererScheduler renderer_scheduler;
+  blink::scheduler::WebFakeThreadScheduler thread_scheduler;
 
   MockLevelDBWrapper mock_leveldb_wrapper;
   LocalStorageCachedAreas cached_areas(&mock_leveldb_wrapper,
-                                       &renderer_scheduler);
+                                       &thread_scheduler);
 
   cached_areas.CloneNamespace(kNamespace1, kNamespace2);
 

content/renderer/gpu/layer_tree_view_unittest.cc

@@ -26,8 +26,8 @@
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/blink/public/platform/scheduler/test/fake_renderer_scheduler.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
+#include "third_party/blink/public/platform/scheduler/test/web_fake_thread_scheduler.h"
 
 using testing::AllOf;
 using testing::Field;
@@ -214,7 +214,7 @@ class LayerTreeViewWithFrameSinkTrackingTest : public testing::Test {
             blink::scheduler::GetSingleThreadTaskRunnerForTesting(),
             /*compositor_thread=*/nullptr,
             &test_task_graph_runner_,
-            &fake_renderer_scheduler_) {
+            &fake_thread_scheduler_) {
     cc::LayerTreeSettings settings;
     settings.single_thread_proxy_scheduler = false;
     layer_tree_view_.Initialize(settings,
@@ -258,7 +258,7 @@ class LayerTreeViewWithFrameSinkTrackingTest : public testing::Test {
  protected:
   base::test::ScopedTaskEnvironment task_environment_;
   cc::TestTaskGraphRunner test_task_graph_runner_;
-  blink::scheduler::FakeRendererScheduler fake_renderer_scheduler_;
+  blink::scheduler::WebFakeThreadScheduler fake_thread_scheduler_;
   FakeLayerTreeViewDelegate layer_tree_view_delegate_;
   LayerTreeViewWithFrameSinkTracking layer_tree_view_;
 
@@ -334,14 +334,14 @@ TEST(LayerTreeViewTest, VisibilityTest) {
   base::test::ScopedTaskEnvironment task_environment;
 
   cc::TestTaskGraphRunner test_task_graph_runner;
-  blink::scheduler::FakeRendererScheduler fake_renderer_scheduler;
+  blink::scheduler::WebFakeThreadScheduler fake_thread_scheduler;
   // Synchronously callback with null FrameSink.
   StubLayerTreeViewDelegate layer_tree_view_delegate;
   VisibilityTestLayerTreeView layer_tree_view(
       &layer_tree_view_delegate,
       blink::scheduler::GetSingleThreadTaskRunnerForTesting(),
       /*compositor_thread=*/nullptr, &test_task_graph_runner,
-      &fake_renderer_scheduler);
+      &fake_thread_scheduler);
 
   layer_tree_view.Initialize(cc::LayerTreeSettings(),
                              std::make_unique<cc::TestUkmRecorderFactory>());
@@ -383,7 +383,7 @@ class NotifySwapTimesLayerTreeViewTest : public ::testing::Test {
             blink::scheduler::GetSingleThreadTaskRunnerForTesting(),
             nullptr /* compositor_thread */,
             &test_task_graph_runner_,
-            &fake_renderer_scheduler_) {
+            &fake_thread_scheduler_) {
     layer_tree_view_delegate_.add_request();
   }
 
@@ -433,7 +433,7 @@ class NotifySwapTimesLayerTreeViewTest : public ::testing::Test {
  protected:
   base::test::ScopedTaskEnvironment task_environment_;
   cc::TestTaskGraphRunner test_task_graph_runner_;
-  blink::scheduler::FakeRendererScheduler fake_renderer_scheduler_;
+  blink::scheduler::WebFakeThreadScheduler fake_thread_scheduler_;
   FakeLayerTreeViewDelegate layer_tree_view_delegate_;
   LayerTreeView layer_tree_view_;
 };

content/test/fake_compositor_dependencies.cc

@@ -64,7 +64,7 @@ FakeCompositorDependencies::GetCompositorImplThreadTaskRunner() {
 
 blink::scheduler::WebThreadScheduler*
 FakeCompositorDependencies::GetWebMainThreadScheduler() {
-  return &renderer_scheduler_;
+  return &main_thread_scheduler_;
 }
 
 cc::TaskGraphRunner* FakeCompositorDependencies::GetTaskGraphRunner() {

content/test/fake_compositor_dependencies.h

@@ -9,7 +9,7 @@
 #include "base/single_thread_task_runner.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "content/renderer/gpu/compositor_dependencies.h"
-#include "third_party/blink/public/platform/scheduler/test/fake_renderer_scheduler.h"
+#include "third_party/blink/public/platform/scheduler/test/web_fake_thread_scheduler.h"
 
 namespace content {
 
@@ -45,7 +45,7 @@ class FakeCompositorDependencies : public CompositorDependencies {
 
  private:
   cc::TestTaskGraphRunner task_graph_runner_;
-  blink::scheduler::FakeRendererScheduler renderer_scheduler_;
+  blink::scheduler::WebFakeThreadScheduler main_thread_scheduler_;
   bool use_zoom_for_dsf_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(FakeCompositorDependencies);

third_party/blink/public/BUILD.gn

@@ -99,9 +99,9 @@ if (is_android) {
 source_set("test_headers") {
   testonly = true
   sources = [
-    "platform/scheduler/test/fake_renderer_scheduler.h",
     "platform/scheduler/test/mock_renderer_scheduler.h",
     "platform/scheduler/test/renderer_scheduler_test_support.h",
+    "platform/scheduler/test/web_fake_thread_scheduler.h",
   ]
   deps = [
     ":blink_headers",

third_party/blink/public/platform/scheduler/test/fake_renderer_scheduler.h → third_party/blink/public/platform/scheduler/test/web_fake_thread_scheduler.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCHEDULER_TEST_FAKE_RENDERER_SCHEDULER_H_
-#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCHEDULER_TEST_FAKE_RENDERER_SCHEDULER_H_
+#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCHEDULER_TEST_WEB_FAKE_THREAD_SCHEDULER_H_
+#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCHEDULER_TEST_WEB_FAKE_THREAD_SCHEDULER_H_
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ -14,10 +14,10 @@
 namespace blink {
 namespace scheduler {
 
-class FakeRendererScheduler : public WebThreadScheduler {
+class WebFakeThreadScheduler : public WebThreadScheduler {
  public:
-  FakeRendererScheduler();
-  ~FakeRendererScheduler() override;
+  WebFakeThreadScheduler();
+  ~WebFakeThreadScheduler() override;
 
   // RendererScheduler implementation.
   std::unique_ptr<Thread> CreateMainThread() override;
@@ -57,10 +57,10 @@ class FakeRendererScheduler : public WebThreadScheduler {
   void OnMainFrameRequestedForInput() override;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(FakeRendererScheduler);
+  DISALLOW_COPY_AND_ASSIGN(WebFakeThreadScheduler);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
-#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCHEDULER_TEST_FAKE_RENDERER_SCHEDULER_H_
+#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCHEDULER_TEST_WEB_FAKE_THREAD_SCHEDULER_H_

third_party/blink/renderer/core/frame/frame_test_helpers.cc

@@ -516,7 +516,7 @@ content::LayerTreeView* LayerTreeViewFactory::Initialize(
       specified_delegate ? specified_delegate : &delegate_,
       Thread::Current()->GetTaskRunner(),
       /*compositor_thread=*/nullptr, &test_task_graph_runner_,
-      &fake_renderer_scheduler_);
+      &fake_thread_scheduler_);
   layer_tree_view_->Initialize(settings,
                                std::make_unique<cc::TestUkmRecorderFactory>());
   return layer_tree_view_.get();

third_party/blink/renderer/core/frame/frame_test_helpers.h

@@ -44,7 +44,7 @@
 #include "third_party/blink/public/common/frame/frame_owner_element_type.h"
 #include "third_party/blink/public/platform/modules/fetch/fetch_api_request.mojom-shared.h"
 #include "third_party/blink/public/platform/platform.h"
-#include "third_party/blink/public/platform/scheduler/test/fake_renderer_scheduler.h"
+#include "third_party/blink/public/platform/scheduler/test/web_fake_thread_scheduler.h"
 #include "third_party/blink/public/platform/web_mouse_event.h"
 #include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/platform/web_url_request.h"
@@ -175,7 +175,7 @@ class LayerTreeViewFactory {
  private:
   content::StubLayerTreeViewDelegate delegate_;
   cc::TestTaskGraphRunner test_task_graph_runner_;
-  blink::scheduler::FakeRendererScheduler fake_renderer_scheduler_;
+  blink::scheduler::WebFakeThreadScheduler fake_thread_scheduler_;
   std::unique_ptr<content::LayerTreeView> layer_tree_view_;
 };
 

third_party/blink/renderer/platform/scheduler/BUILD.gn

@@ -152,12 +152,12 @@ jumbo_source_set("test_support") {
   sources = [
     "test/fake_frame_scheduler.h",
     "test/fake_page_scheduler.h",
-    "test/fake_renderer_scheduler.cc",
     "test/fake_task_runner.cc",
     "test/fake_task_runner.h",
     "test/renderer_scheduler_test_support.cc",
     "test/test_queueing_time_estimator_client.cc",
     "test/test_queueing_time_estimator_client.h",
+    "test/web_fake_thread_scheduler.cc",
   ]
 
   deps = [

third_party/blink/renderer/platform/scheduler/test/fake_renderer_scheduler.cc → third_party/blink/renderer/platform/scheduler/test/web_fake_thread_scheduler.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/blink/public/platform/scheduler/test/fake_renderer_scheduler.h"
+#include "third_party/blink/public/platform/scheduler/test/web_fake_thread_scheduler.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
@@ -13,93 +13,93 @@
 namespace blink {
 namespace scheduler {
 
-FakeRendererScheduler::FakeRendererScheduler() = default;
+WebFakeThreadScheduler::WebFakeThreadScheduler() = default;
 
-FakeRendererScheduler::~FakeRendererScheduler() = default;
+WebFakeThreadScheduler::~WebFakeThreadScheduler() = default;
 
-std::unique_ptr<Thread> FakeRendererScheduler::CreateMainThread() {
+std::unique_ptr<Thread> WebFakeThreadScheduler::CreateMainThread() {
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
-FakeRendererScheduler::DefaultTaskRunner() {
+WebFakeThreadScheduler::DefaultTaskRunner() {
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
-FakeRendererScheduler::CompositorTaskRunner() {
+WebFakeThreadScheduler::CompositorTaskRunner() {
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
-FakeRendererScheduler::InputTaskRunner() {
+WebFakeThreadScheduler::InputTaskRunner() {
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
-FakeRendererScheduler::IPCTaskRunner() {
+WebFakeThreadScheduler::IPCTaskRunner() {
   return nullptr;
 }
 
 std::unique_ptr<WebRenderWidgetSchedulingState>
-FakeRendererScheduler::NewRenderWidgetSchedulingState() {
+WebFakeThreadScheduler::NewRenderWidgetSchedulingState() {
   return nullptr;
 }
 
-void FakeRendererScheduler::WillBeginFrame(const viz::BeginFrameArgs& args) {}
+void WebFakeThreadScheduler::WillBeginFrame(const viz::BeginFrameArgs& args) {}
 
-void FakeRendererScheduler::BeginFrameNotExpectedSoon() {}
+void WebFakeThreadScheduler::BeginFrameNotExpectedSoon() {}
 
-void FakeRendererScheduler::BeginMainFrameNotExpectedUntil(
+void WebFakeThreadScheduler::BeginMainFrameNotExpectedUntil(
     base::TimeTicks time) {}
 
-void FakeRendererScheduler::DidCommitFrameToCompositor() {}
+void WebFakeThreadScheduler::DidCommitFrameToCompositor() {}
 
-void FakeRendererScheduler::DidHandleInputEventOnCompositorThread(
+void WebFakeThreadScheduler::DidHandleInputEventOnCompositorThread(
     const blink::WebInputEvent& web_input_event,
     InputEventState event_state) {}
 
-void FakeRendererScheduler::DidHandleInputEventOnMainThread(
+void WebFakeThreadScheduler::DidHandleInputEventOnMainThread(
     const blink::WebInputEvent& web_input_event,
     WebInputEventResult result) {}
 
-void FakeRendererScheduler::DidAnimateForInputOnCompositorThread() {}
+void WebFakeThreadScheduler::DidAnimateForInputOnCompositorThread() {}
 
-bool FakeRendererScheduler::IsHighPriorityWorkAnticipated() {
+bool WebFakeThreadScheduler::IsHighPriorityWorkAnticipated() {
   return false;
 }
 
-void FakeRendererScheduler::SetRendererHidden(bool hidden) {}
+void WebFakeThreadScheduler::SetRendererHidden(bool hidden) {}
 
-void FakeRendererScheduler::SetRendererBackgrounded(bool backgrounded) {}
+void WebFakeThreadScheduler::SetRendererBackgrounded(bool backgrounded) {}
 
-void FakeRendererScheduler::SetSchedulerKeepActive(bool keep_active) {}
+void WebFakeThreadScheduler::SetSchedulerKeepActive(bool keep_active) {}
 
-std::unique_ptr<FakeRendererScheduler::RendererPauseHandle>
-FakeRendererScheduler::PauseRenderer() {
+std::unique_ptr<WebFakeThreadScheduler::RendererPauseHandle>
+WebFakeThreadScheduler::PauseRenderer() {
   return nullptr;
 }
 
 #if defined(OS_ANDROID)
-void FakeRendererScheduler::PauseTimersForAndroidWebView() {}
+void WebFakeThreadScheduler::PauseTimersForAndroidWebView() {}
 
-void FakeRendererScheduler::ResumeTimersForAndroidWebView() {}
+void WebFakeThreadScheduler::ResumeTimersForAndroidWebView() {}
 #endif
 
-void FakeRendererScheduler::Shutdown() {}
+void WebFakeThreadScheduler::Shutdown() {}
 
-void FakeRendererScheduler::SetTopLevelBlameContext(
+void WebFakeThreadScheduler::SetTopLevelBlameContext(
     base::trace_event::BlameContext* blame_context) {}
 
-void FakeRendererScheduler::AddRAILModeObserver(WebRAILModeObserver* observer) {
-}
+void WebFakeThreadScheduler::AddRAILModeObserver(
+    WebRAILModeObserver* observer) {}
 
-void FakeRendererScheduler::SetRendererProcessType(RendererProcessType type) {}
+void WebFakeThreadScheduler::SetRendererProcessType(RendererProcessType type) {}
 
-void FakeRendererScheduler::OnMainFrameRequestedForInput() {}
+void WebFakeThreadScheduler::OnMainFrameRequestedForInput() {}
 
 WebScopedVirtualTimePauser
-FakeRendererScheduler::CreateWebScopedVirtualTimePauser(
+WebFakeThreadScheduler::CreateWebScopedVirtualTimePauser(
     const char* name,
     WebScopedVirtualTimePauser::VirtualTaskDuration duration) {
   return WebScopedVirtualTimePauser(nullptr, duration,