cc: Split Proxy to eliminate unnecessary dependencies on the impl side

cc/debug/frame_timing_tracker_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 <set>
 #include <string>
 
 #include "base/time/time.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/debug/frame_timing_tracker.h"
-#include "cc/test/fake_impl_proxy.h"
+#include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 std::string CompositeToString(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> timingset) {
@@ skipping 44 matching lines @@
       value->EndDictionary();
     }
     value->EndArray();
     value->EndDictionary();
   }
   value->EndArray();
   return value->ToString();
 }
 
 TEST(FrameTimingTrackerTest, DefaultTrackerIsEmpty) {
-  FakeImplProxy proxy;
+  FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager,
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   scoped_ptr<FrameTimingTracker> tracker(
       FrameTimingTracker::Create(&host_impl));
   EXPECT_EQ("{\"values\":[]}",
             CompositeToString(tracker->GroupCompositeCountsByRectId()));
   EXPECT_EQ("{\"values\":[]}",
             MainFrameToString(tracker->GroupMainFrameCountsByRectId()));
 }
 
 TEST(FrameTimingTrackerTest, NoFrameIdsIsEmpty) {
-  FakeImplProxy proxy;
+  FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager,
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   scoped_ptr<FrameTimingTracker> tracker(
       FrameTimingTracker::Create(&host_impl));
   std::vector<std::pair<int, int64_t>> ids;
   tracker->SaveTimeStamps(base::TimeTicks::FromInternalValue(100), ids);
   EXPECT_EQ("{\"values\":[]}",
             CompositeToString(tracker->GroupCompositeCountsByRectId()));
 }
 
 TEST(FrameTimingTrackerTest, NoRectIdsYieldsNoMainFrameEvents) {
-  FakeImplProxy proxy;
+  FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager,
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   scoped_ptr<FrameTimingTracker> tracker(
       FrameTimingTracker::Create(&host_impl));
   tracker->SaveMainFrameTimeStamps(std::vector<int64_t>(),
                                    base::TimeTicks::FromInternalValue(100),
                                    base::TimeTicks::FromInternalValue(110), 1);
   EXPECT_EQ("{\"values\":[]}",
             MainFrameToString(tracker->GroupMainFrameCountsByRectId()));
 }
 
 TEST(FrameTimingTrackerTest, OneFrameId) {
-  FakeImplProxy proxy;
+  FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager,
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   scoped_ptr<FrameTimingTracker> tracker(
       FrameTimingTracker::Create(&host_impl));
   std::vector<std::pair<int, int64_t>> ids;
   ids.push_back(std::make_pair(1, 2));
   tracker->SaveTimeStamps(base::TimeTicks::FromInternalValue(100), ids);
   EXPECT_EQ(
       "{\"values\":[{\"events\":["
       "{\"frame_id\":1,\"timestamp\":100}],\"rect_id\":2}]}",
       CompositeToString(tracker->GroupCompositeCountsByRectId()));
 }
 
 TEST(FrameTimingTrackerTest, OneMainFrameRect) {
-  FakeImplProxy proxy;
+  FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager,
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   scoped_ptr<FrameTimingTracker> tracker(
       FrameTimingTracker::Create(&host_impl));
   std::vector<int64_t> rect_ids;
   rect_ids.push_back(1);
   tracker->SaveMainFrameTimeStamps(rect_ids,
                                    base::TimeTicks::FromInternalValue(100),
                                    base::TimeTicks::FromInternalValue(110), 2);
   EXPECT_EQ(
       "{\"values\":[{\"events\":["
       "{\"end_time\":110,\"frame_id\":2,\"timestamp\":100}],\"rect_id\":1}]}",
       MainFrameToString(tracker->GroupMainFrameCountsByRectId()));
 }
 
 TEST(FrameTimingTrackerTest, UnsortedTimestampsIds) {
-  FakeImplProxy proxy;
+  FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager,
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   scoped_ptr<FrameTimingTracker> tracker(
       FrameTimingTracker::Create(&host_impl));
   std::vector<std::pair<int, int64_t>> ids;
   ids.push_back(std::make_pair(1, 2));
   tracker->SaveTimeStamps(base::TimeTicks::FromInternalValue(200), ids);
   tracker->SaveTimeStamps(base::TimeTicks::FromInternalValue(400), ids);
   tracker->SaveTimeStamps(base::TimeTicks::FromInternalValue(100), ids);
   EXPECT_EQ(
       "{\"values\":[{\"events\":["
       "{\"frame_id\":1,\"timestamp\":100},"
       "{\"frame_id\":1,\"timestamp\":200},"
       "{\"frame_id\":1,\"timestamp\":400}],\"rect_id\":2}]}",
       CompositeToString(tracker->GroupCompositeCountsByRectId()));
 }
 
 TEST(FrameTimingTrackerTest, MainFrameUnsortedTimestamps) {
-  FakeImplProxy proxy;
+  FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager,
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   scoped_ptr<FrameTimingTracker> tracker(
       FrameTimingTracker::Create(&host_impl));
   std::vector<int64_t> rect_ids;
   rect_ids.push_back(2);
   tracker->SaveMainFrameTimeStamps(rect_ids,
                                    base::TimeTicks::FromInternalValue(200),
                                    base::TimeTicks::FromInternalValue(280), 1);
   tracker->SaveMainFrameTimeStamps(rect_ids,
                                    base::TimeTicks::FromInternalValue(400),
                                    base::TimeTicks::FromInternalValue(470), 1);
   tracker->SaveMainFrameTimeStamps(rect_ids,
                                    base::TimeTicks::FromInternalValue(100),
                                    base::TimeTicks::FromInternalValue(160), 1);
   EXPECT_EQ(
       "{\"values\":[{\"events\":["
       "{\"end_time\":160,\"frame_id\":1,\"timestamp\":100},"
       "{\"end_time\":280,\"frame_id\":1,\"timestamp\":200},"
       "{\"end_time\":470,\"frame_id\":1,\"timestamp\":400}],\"rect_id\":2}]}",
       MainFrameToString(tracker->GroupMainFrameCountsByRectId()));
 }
 
 TEST(FrameTimingTrackerTest, MultipleFrameIds) {
-  FakeImplProxy proxy;
+  FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager,
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   scoped_ptr<FrameTimingTracker> tracker(
       FrameTimingTracker::Create(&host_impl));
 
   std::vector<std::pair<int, int64_t>> ids200;
   ids200.push_back(std::make_pair(1, 2));
   ids200.push_back(std::make_pair(1, 3));
   tracker->SaveTimeStamps(base::TimeTicks::FromInternalValue(200), ids200);
 
@@ skipping 15 matching lines @@
       "{\"events\":["
       "{\"frame_id\":2,\"timestamp\":100},"
       "{\"frame_id\":1,\"timestamp\":200}],\"rect_id\":3},"
       "{\"events\":["
       "{\"frame_id\":3,\"timestamp\":100}],\"rect_id\":4}"
       "]}",
       CompositeToString(tracker->GroupCompositeCountsByRectId()));
 }
 
 TEST(FrameTimingTrackerTest, MultipleMainFrameEvents) {
-  FakeImplProxy proxy;
+  FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager,
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   scoped_ptr<FrameTimingTracker> tracker(
       FrameTimingTracker::Create(&host_impl));
 
   std::vector<int64_t> rect_ids200;
   rect_ids200.push_back(2);
   rect_ids200.push_back(3);
   tracker->SaveMainFrameTimeStamps(rect_ids200,
                                    base::TimeTicks::FromInternalValue(200),
@@ skipping 22 matching lines @@
       "{\"end_time\":110,\"frame_id\":3,\"timestamp\":100},"
       "{\"end_time\":220,\"frame_id\":1,\"timestamp\":200}],\"rect_id\":3},"
       "{\"events\":["
       "{\"end_time\":110,\"frame_id\":3,\"timestamp\":100}],\"rect_id\":4}"
       "]}",
       MainFrameToString(tracker->GroupMainFrameCountsByRectId()));
 }
 
 }  // namespace
 }  // namespace cc