scheduler: Move the Blink scheduler into Blink

content/renderer/scheduler/resource_dispatch_throttler_unittest.cc

 // 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 "content/renderer/scheduler/resource_dispatch_throttler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_request.h"
-#include "content/test/fake_renderer_scheduler.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/scheduler/test/fake_renderer_scheduler.h"
 
 namespace content {
 namespace {
 
 const uint32_t kRequestsPerFlush = 4;
 const double kFlushPeriodSeconds = 1.f / 60;
 const int kRoutingId = 1;
 
 typedef ScopedVector<IPC::Message> ScopedMessages;
 
@@ skipping 14 matching lines @@
         NOTREACHED() << "Invalid id for resource message.";
       break;
 
     default:
       NOTREACHED() << "Invalid message for resource throttling.";
       break;
   }
   return request_id;
 }
 
-class RendererSchedulerForTest : public FakeRendererScheduler {
+class RendererSchedulerForTest
+    : public blink::scheduler::FakeRendererScheduler {
  public:
   RendererSchedulerForTest() : high_priority_work_anticipated_(false) {}
   ~RendererSchedulerForTest() override {}
 
   // RendererScheduler implementation:
   bool IsHighPriorityWorkAnticipated() override {
     return high_priority_work_anticipated_;
   }
 
   void set_high_priority_work_anticipated(bool anticipated) {
     high_priority_work_anticipated_ = anticipated;
   }
 
  private:
   bool high_priority_work_anticipated_;
 };
 
 }  // namespace
 
 class ResourceDispatchThrottlerForTest : public ResourceDispatchThrottler {
  public:
-  ResourceDispatchThrottlerForTest(IPC::Sender* sender,
-                                   scheduler::RendererScheduler* scheduler)
+  ResourceDispatchThrottlerForTest(
+      IPC::Sender* sender,
+      blink::scheduler::RendererScheduler* scheduler)
       : ResourceDispatchThrottler(
             sender,
             scheduler,
             base::TimeDelta::FromSecondsD(kFlushPeriodSeconds),
             kRequestsPerFlush),
         now_(base::TimeTicks() + base::TimeDelta::FromDays(1)),
         flush_scheduled_(false) {}
   ~ResourceDispatchThrottlerForTest() override {}
 
   void Advance(base::TimeDelta delta) { now_ += delta; }
@@ skipping 321 matching lines @@
     EXPECT_EQ(priority_msg.type(), ResourceHostMsg_DidChangePriority::ID);
     EXPECT_EQ(cancel_msg.type(), ResourceHostMsg_CancelRequest::ID);
 
     EXPECT_EQ(GetRequestId(request_msg), GetRequestId(priority_msg));
     EXPECT_EQ(GetRequestId(request_msg) - 1, GetRequestId(cancel_msg));
   }
   EXPECT_FALSE(FlushScheduled());
 }
 
 }  // namespace content