Optimize posting of WTF::Closure and improve scheduler test mocks

third_party/WebKit/Source/platform/testing/TestingPlatformSupport.h

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 22 matching lines @@
 
 #include "platform/PlatformExport.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "wtf/Vector.h"
 #include <memory>
 
 namespace base {
+class SimpleTestTickClock;
 class TestDiscardableMemoryAllocator;
-} // namespace base
+}
+
+namespace cc {
+class OrderedSimpleTaskRunner;
+}
 
 namespace cc_blink {
 class WebCompositorSupportImpl;
 } // namespace cc_blink
 
 namespace blink {
-
+namespace scheduler {
+class RendererScheduler;
+class RendererSchedulerImpl;
+}
 class TestingPlatformMockWebTaskRunner;
 class TestingPlatformMockWebThread;
 class WebCompositorSupport;
 class WebThread;
 
 class TestingCompositorSupport : public WebCompositorSupport {
 };
 
-class TestingPlatformMockScheduler : public WebScheduler {
-    WTF_MAKE_NONCOPYABLE(TestingPlatformMockScheduler);
-public:
-    TestingPlatformMockScheduler();
-    ~TestingPlatformMockScheduler() override;
-
-    void runSingleTask();
-    void runAllTasks();
-
-    // WebScheduler implementation:
-    WebTaskRunner* loadingTaskRunner() override;
-    WebTaskRunner* timerTaskRunner() override;
-    void shutdown() override {}
-    bool shouldYieldForHighPriorityWork() override { return false; }
-    bool canExceedIdleDeadlineIfRequired() override { return false; }
-    void postIdleTask(const WebTraceLocation&, WebThread::IdleTask*) override { }
-    void postNonNestableIdleTask(const WebTraceLocation&, WebThread::IdleTask*) override { }
-    void postIdleTaskAfterWakeup(const WebTraceLocation&, WebThread::IdleTask*) override { }
-    std::unique_ptr<WebViewScheduler> createWebViewScheduler(InterventionReporter*) override { return nullptr; }
-    void suspendTimerQueue() override { }
-    void resumeTimerQueue() override { }
-    void addPendingNavigation(WebScheduler::NavigatingFrameType) override { }
-    void removePendingNavigation(WebScheduler::NavigatingFrameType) override { }
-    void onNavigationStarted() override { }
-
-private:
-    WTF::Deque<std::unique_ptr<WebTaskRunner::Task>> m_tasks;
-    std::unique_ptr<TestingPlatformMockWebTaskRunner> m_mockWebTaskRunner;
-};
-
 class TestingPlatformSupport : public Platform {
     WTF_MAKE_NONCOPYABLE(TestingPlatformSupport);
 public:
     struct Config {
         WebCompositorSupport* compositorSupport = nullptr;
     };
 
     TestingPlatformSupport();
     explicit TestingPlatformSupport(const Config&);
 
     ~TestingPlatformSupport() override;
 
     // Platform:
     WebString defaultLocale() override;
     WebCompositorSupport* compositorSupport() override;
     WebThread* currentThread() override;
+    WebBlobRegistry* blobRegistry() override;
+    WebClipboard* clipboard() override;
+    WebFileUtilities* fileUtilities() override;
+    WebIDBFactory* idbFactory() override;
+    WebMimeRegistry* mimeRegistry() override;
+    WebURLLoaderMockFactory* getURLLoaderMockFactory() override;
+    blink::WebURLLoader* createURLLoader() override;
+
+    WebData loadResource(const char* name) override;
+    WebURLError cancelledError(const WebURL&) const override;
 
 protected:
     const Config m_config;
     Platform* const m_oldPlatform;
 };
 
 class TestingPlatformSupportWithMockScheduler : public TestingPlatformSupport {
     WTF_MAKE_NONCOPYABLE(TestingPlatformSupportWithMockScheduler);
 public:
     TestingPlatformSupportWithMockScheduler();
     explicit TestingPlatformSupportWithMockScheduler(const Config&);
     ~TestingPlatformSupportWithMockScheduler() override;
 
     // Platform:
     WebThread* currentThread() override;
-    TestingPlatformMockScheduler* mockWebScheduler();
+
+    // Runs a single task.
+    void runSingleTask();
+
+    // Runs all currently queued immediate tasks and delayed tasks whose delay has expired
+    // plus any immediate tasks that are posted as a result of running those tasks.
+    //
+    // This function ignores future delayed tasks when deciding if the system, is idle.

[haraken, 2016/08/22 05:28:48]

system, => system

[alex clarke (OOO till 29th), 2016/08/22 17:43:01]

Done.

+    // If you need to ensure delayed tasks run, try runForPeriodSeconds() instead.
+    void runUntilIdle();
+
+    // Runs all currently queued immediate tasks and delayed tasks whose delay has expired.
+    // Tasks that get posted after calling this won't run.
+    void runPendingTasks();

[haraken, 2016/08/22 05:28:48]

I'm just curious but when do we need this functionality?

[alex clarke (OOO till 29th), 2016/08/22 17:43:01]

Looks like only one test in TimerTest.cpp was using it and runForPeriodSeconds()
worked there instead.  Lets drop it :)

+
+    // Runs for |seconds|. Note we use a testing clock rather than the wall clock here.
+    void runForPeriodSeconds(double seconds);
+
+    // Advances |m_clock| by |seconds|.
+    void advanceClockSeconds(double seconds);
+
+    scheduler::RendererScheduler* rendererScheduler() const;
+
+    // Controls the behavior of |m_mockTaskRunner| if true, then |m_clock| will
+    // be advanced to the next timer when there's no more immediate work to do.
+    void setAutoAdvanceNowToPendingTasks(bool);
 
 protected:
-    std::unique_ptr<TestingPlatformMockWebThread> m_mockWebThread;
+    static double getTestTime();
+
+    std::unique_ptr<base::SimpleTestTickClock> m_clock;
+    scoped_refptr<cc::OrderedSimpleTaskRunner> m_mockTaskRunner;
+    std::unique_ptr<scheduler::RendererSchedulerImpl> m_scheduler;
+    std::unique_ptr<WebThread> m_thread;
 };
 
 class ScopedUnittestsEnvironmentSetup {
     WTF_MAKE_NONCOPYABLE(ScopedUnittestsEnvironmentSetup);
 public:
     ScopedUnittestsEnvironmentSetup(int argc, char** argv);
     ~ScopedUnittestsEnvironmentSetup();
 
 private:
     class DummyPlatform;
     std::unique_ptr<base::TestDiscardableMemoryAllocator> m_discardableMemoryAllocator;
     std::unique_ptr<DummyPlatform> m_platform;
     std::unique_ptr<cc_blink::WebCompositorSupportImpl> m_compositorSupport;
     TestingPlatformSupport::Config m_testingPlatformConfig;
     std::unique_ptr<TestingPlatformSupport> m_testingPlatformSupport;
 };
 
 } // namespace blink
 
 #endif // TestingPlatformSupport_h