Expose RunsTasksOnCurrentThread through WebTaskRunner

third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurfaceTest.cpp

 // Copyright 2014 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 "platform/graphics/RecordingImageBufferSurface.h"
 
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/ImageBufferClient.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
@@ skipping 31 matching lines @@
     void didFinalizeFrame() override
     {
         if (m_isDirty) {
             Platform::current()->currentThread()->removeTaskObserver(this);
             m_isDirty = false;
         }
         ++m_frameCount;
     }
 
     // TaskObserver implementation
-    void willProcessTask() override { ASSERT_NOT_REACHED(); }
+    void willProcessTask() override { NOTREACHED(); }
     void didProcessTask() override
     {
         ASSERT_TRUE(m_isDirty);
         FloatRect dirtyRect(0, 0, 1, 1);
         m_imageBuffer->finalizeFrame(dirtyRect);
         ASSERT_FALSE(m_isDirty);
     }
     void restoreCanvasMatrixClipStack(SkCanvas*) const override { }
 
     void fakeDraw()
@@ skipping 186 matching lines @@
     public:
         MockWebTaskRunner() : m_task(0) { }
         ~MockWebTaskRunner() override { }
 
         void postTask(const WebTraceLocation&, Task* task) override
         {
             EXPECT_EQ((Task*)0, m_task);
             m_task = task;
         }
 
-        void postDelayedTask(const WebTraceLocation&, Task*, double delayMs) override { ASSERT_NOT_REACHED(); };
+        void postDelayedTask(const WebTraceLocation&, Task*, double delayMs) override { NOTREACHED(); };
+
+        bool runsTasksOnCurrentThread() override
+        {
+            NOTREACHED();
+            return true;
+        }
 
         WebTaskRunner* clone() override
         {
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
             return nullptr;
         }
 
         double virtualTimeSeconds() const override
         {
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
             return 0.0;
         }
 
         double monotonicallyIncreasingVirtualTimeSeconds() const override
         {
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
             return 0.0;
         }
 
         Task* m_task;
     };
 
     class CurrentThreadMock : public WebThread {
     public:
         CurrentThreadMock() : m_taskObserver(0) { }
 
         ~CurrentThreadMock() override
         {
             EXPECT_EQ((WebTaskRunner::Task*)0, m_taskRunner.m_task);
         }
 
         WebTaskRunner* getWebTaskRunner() override
         {
             return &m_taskRunner;
         }
 
         bool isCurrentThread() const override { return true; }
 
         PlatformThreadId threadId() const override
         {
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
             return 0;
         }
 
         void addTaskObserver(TaskObserver* taskObserver) override
         {
             EXPECT_EQ(nullptr, m_taskObserver);
             m_taskObserver = taskObserver;
         }
 
         void removeTaskObserver(TaskObserver* taskObserver) override
         {
             EXPECT_EQ(m_taskObserver, taskObserver);
             m_taskObserver = 0;
         }
 
         WebScheduler* scheduler() const override
         {
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
             return nullptr;
         }
 
         void enterRunLoop()
         {
             if (m_taskObserver)
                 m_taskObserver->willProcessTask();
             if (m_taskRunner.m_task) {
                 m_taskRunner.m_task->run();
                 delete m_taskRunner.m_task;
@@ skipping 56 matching lines @@
     expectDisplayListEnabled(true);
 }
 
 TEST_F(RecordingImageBufferSurfaceTest, testClearRect)
 {
     CALL_TEST_TASK_WRAPPER(testClearRect);
     expectDisplayListEnabled(true);
 }
 
 } // namespace blink