Implement frame attribution (FrameBlamer)

components/scheduler/renderer/web_view_scheduler_impl_unittest.cc

 // Copyright 2015 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 "components/scheduler/renderer/web_view_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/test/ordered_simple_task_runner.h"
@@ skipping 18 matching lines @@
   void SetUp() override {
     clock_.reset(new base::SimpleTestTickClock());
     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
     mock_task_runner_ =
         make_scoped_refptr(new cc::OrderedSimpleTaskRunner(clock_.get(), true));
     delagate_ = SchedulerTqmDelegateForTest::Create(
         mock_task_runner_, make_scoped_ptr(new TestTimeSource(clock_.get())));
     scheduler_.reset(new RendererSchedulerImpl(delagate_));
     web_view_scheduler_.reset(new WebViewSchedulerImpl(
         nullptr, scheduler_.get(), DisableBackgroundTimerThrottling()));
-    web_frame_scheduler_ = web_view_scheduler_->createWebFrameSchedulerImpl();
+    web_frame_scheduler_ =
+        web_view_scheduler_->createWebFrameSchedulerImpl(nullptr);
   }
 
   void TearDown() override {
     web_frame_scheduler_.reset();
     web_view_scheduler_.reset();
     scheduler_->Shutdown();
     scheduler_.reset();
   }
 
   virtual bool DisableBackgroundTimerThrottling() const { return false; }
 
   scoped_ptr<base::SimpleTestTickClock> clock_;
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   scoped_refptr<SchedulerTqmDelegate> delagate_;
   scoped_ptr<RendererSchedulerImpl> scheduler_;
   scoped_ptr<WebViewSchedulerImpl> web_view_scheduler_;
   scoped_ptr<WebFrameSchedulerImpl> web_frame_scheduler_;
 };
 
 TEST_F(WebViewSchedulerImplTest, TestDestructionOfFrameSchedulersBefore) {
   blink::WebPassOwnPtr<blink::WebFrameScheduler> frame1(
-      web_view_scheduler_->createFrameScheduler());
+      web_view_scheduler_->createFrameScheduler(nullptr));
   blink::WebPassOwnPtr<blink::WebFrameScheduler> frame2(
-      web_view_scheduler_->createFrameScheduler());
+      web_view_scheduler_->createFrameScheduler(nullptr));
 }
 
 TEST_F(WebViewSchedulerImplTest, TestDestructionOfFrameSchedulersAfter) {
   blink::WebPassOwnPtr<blink::WebFrameScheduler> frame1(
-      web_view_scheduler_->createFrameScheduler());
+      web_view_scheduler_->createFrameScheduler(nullptr));
   blink::WebPassOwnPtr<blink::WebFrameScheduler> frame2(
-      web_view_scheduler_->createFrameScheduler());
+      web_view_scheduler_->createFrameScheduler(nullptr));
   web_view_scheduler_.reset();
 }
 
 namespace {
 class RepeatingTask : public blink::WebTaskRunner::Task {
  public:
   RepeatingTask(blink::WebTaskRunner* web_task_runner, int* run_count)
       : web_task_runner_(web_task_runner), run_count_(run_count) {}
 
   ~RepeatingTask() override {}
@@ skipping 46 matching lines @@
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
   EXPECT_EQ(1000, run_count);  // Loading tasks should not be throttled
 }
 
 TEST_F(WebViewSchedulerImplTest, RepeatingTimers_OneBackgroundOneForeground) {
   scoped_ptr<WebViewSchedulerImpl> web_view_scheduler2(
       new WebViewSchedulerImpl(nullptr, scheduler_.get(), false));
   scoped_ptr<WebFrameSchedulerImpl> web_frame_scheduler2 =
-      web_view_scheduler2->createWebFrameSchedulerImpl();
+      web_view_scheduler2->createWebFrameSchedulerImpl(nullptr);
 
   web_view_scheduler_->setPageVisible(true);
   web_view_scheduler2->setPageVisible(false);
 
   int run_count1 = 0;
   int run_count2 = 0;
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
       new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count1),
       1.0);
@@ skipping 257 matching lines @@
   EXPECT_EQ(1000, run_count);
 }
 
 TEST_F(WebViewSchedulerImplTest, VirtualTimeSettings_NewWebFrameScheduler) {
   std::vector<int> run_order;
 
   web_view_scheduler_->setAllowVirtualTimeToAdvance(false);
   web_view_scheduler_->enableVirtualTime();
 
   scoped_ptr<WebFrameSchedulerImpl> web_frame_scheduler =
-      web_view_scheduler_->createWebFrameSchedulerImpl();
+      web_view_scheduler_->createWebFrameSchedulerImpl(nullptr);
 
   web_frame_scheduler->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE, new RunOrderTask(1, &run_order), 0.1);
 
   mock_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   web_view_scheduler_->setAllowVirtualTimeToAdvance(true);
   mock_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 namespace {
 class DeleteWebFrameSchedulerTask : public blink::WebTaskRunner::Task {
  public:
   explicit DeleteWebFrameSchedulerTask(WebViewSchedulerImpl* web_view_scheduler)
       : web_frame_scheduler_(
-            web_view_scheduler->createWebFrameSchedulerImpl()) {}
+            web_view_scheduler->createWebFrameSchedulerImpl(nullptr)) {}
 
   ~DeleteWebFrameSchedulerTask() override {}
 
   void run() override { web_frame_scheduler_.reset(); }
 
   WebFrameSchedulerImpl* web_frame_scheduler() const {
     return web_frame_scheduler_.get();
   }
 
  private:
@@ skipping 47 matching lines @@
   // it will prevent further tasks from running (i.e. the RepeatingTask) by
   // deleting the WebFrameScheduler.
   timer_task_runner->postDelayedTask(BLINK_FROM_HERE, delete_frame_task,
                                      9990.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(100));
   EXPECT_EQ(10, run_count);
 }
 
 }  // namespace scheduler