Revert of Implement scroll handler latency tracking

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 954 matching lines @@
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     ExpectContains(*scroll_info.get(),
                    scroll_layer->id(),
                    scroll_delta);
   }
 }
 
-TEST_F(LayerTreeHostImplTest, ScrollWithSwapPromises) {
-  ui::LatencyInfo latency_info;
-  latency_info.trace_id = 1234;
-  scoped_ptr<SwapPromise> swap_promise(
-      new LatencyInfoSwapPromise(latency_info));
-
-  SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  EXPECT_EQ(InputHandler::ScrollStarted,
-            host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
-  host_impl_->QueueSwapPromiseForMainThreadScrollUpdate(swap_promise.Pass());
-  host_impl_->ScrollEnd();
-
-  scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
-  EXPECT_EQ(1u, scroll_info->swap_promises.size());
-  EXPECT_EQ(latency_info.trace_id, scroll_info->swap_promises[0]->TraceId());
-}
-
 TEST_F(LayerTreeHostImplTest, MasksToBoundsDoesntClobberInnerContainerSize) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
   LayerImpl* scroll_layer = host_impl_->InnerViewportScrollLayer();
   LayerImpl* container_layer = scroll_layer->scroll_clip_layer();
   DCHECK(scroll_layer);
 
   float min_page_scale = 1.f;
@@ skipping 5375 matching lines @@
   EXPECT_EQ(selection_rect, selection_start_after.viewport_rect);
   EXPECT_TRUE(selection_start_after.visible);
   EXPECT_TRUE(selection_start_after.visible);
 }
 
 class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
  public:
   SimpleSwapPromiseMonitor(LayerTreeHost* layer_tree_host,
                            LayerTreeHostImpl* layer_tree_host_impl,
                            int* set_needs_commit_count,
-                           int* set_needs_redraw_count,
-                           int* forward_to_main_count)
+                           int* set_needs_redraw_count)
       : SwapPromiseMonitor(layer_tree_host, layer_tree_host_impl),
         set_needs_commit_count_(set_needs_commit_count),
-        set_needs_redraw_count_(set_needs_redraw_count),
-        forward_to_main_count_(forward_to_main_count) {}
+        set_needs_redraw_count_(set_needs_redraw_count) {}
 
   virtual ~SimpleSwapPromiseMonitor() {}
 
   virtual void OnSetNeedsCommitOnMain() OVERRIDE {
     (*set_needs_commit_count_)++;
   }
 
   virtual void OnSetNeedsRedrawOnImpl() OVERRIDE {
     (*set_needs_redraw_count_)++;
   }
 
-  virtual void OnForwardScrollUpdateToMainThreadOnImpl() OVERRIDE {
-    (*forward_to_main_count_)++;
-  }
-
  private:
   int* set_needs_commit_count_;
   int* set_needs_redraw_count_;
-  int* forward_to_main_count_;
 };
 
 TEST_F(LayerTreeHostImplTest, SimpleSwapPromiseMonitor) {
   int set_needs_commit_count = 0;
   int set_needs_redraw_count = 0;
-  int forward_to_main_count = 0;
 
   {
     scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
         new SimpleSwapPromiseMonitor(NULL,
                                      host_impl_.get(),
                                      &set_needs_commit_count,
-                                     &set_needs_redraw_count,
-                                     &forward_to_main_count));
+                                     &set_needs_redraw_count));
     host_impl_->SetNeedsRedraw();
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(1, set_needs_redraw_count);
-    EXPECT_EQ(0, forward_to_main_count);
   }
 
   // Now the monitor is destroyed, SetNeedsRedraw() is no longer being
   // monitored.
   host_impl_->SetNeedsRedraw();
   EXPECT_EQ(0, set_needs_commit_count);
   EXPECT_EQ(1, set_needs_redraw_count);
-  EXPECT_EQ(0, forward_to_main_count);
 
   {
     scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
         new SimpleSwapPromiseMonitor(NULL,
                                      host_impl_.get(),
                                      &set_needs_commit_count,
-                                     &set_needs_redraw_count,
-                                     &forward_to_main_count));
+                                     &set_needs_redraw_count));
     host_impl_->SetNeedsRedrawRect(gfx::Rect(10, 10));
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(2, set_needs_redraw_count);
-    EXPECT_EQ(0, forward_to_main_count);
   }
 
   {
     scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
         new SimpleSwapPromiseMonitor(NULL,
                                      host_impl_.get(),
                                      &set_needs_commit_count,
-                                     &set_needs_redraw_count,
-                                     &forward_to_main_count));
+                                     &set_needs_redraw_count));
     // Empty damage rect won't signal the monitor.
     host_impl_->SetNeedsRedrawRect(gfx::Rect());
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(2, set_needs_redraw_count);
-    EXPECT_EQ(0, forward_to_main_count);
-  }
-
-  {
-    set_needs_commit_count = 0;
-    set_needs_redraw_count = 0;
-    forward_to_main_count = 0;
-    scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
-        new SimpleSwapPromiseMonitor(NULL,
-                                     host_impl_.get(),
-                                     &set_needs_commit_count,
-                                     &set_needs_redraw_count,
-                                     &forward_to_main_count));
-    LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
-
-    // Scrolling normally should not trigger any forwarding.
-    EXPECT_EQ(InputHandler::ScrollStarted,
-              host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
-    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10)));
-    host_impl_->ScrollEnd();
-
-    EXPECT_EQ(0, set_needs_commit_count);
-    EXPECT_EQ(1, set_needs_redraw_count);
-    EXPECT_EQ(0, forward_to_main_count);
-
-    // Scrolling with a scroll handler should defer the swap to the main
-    // thread.
-    scroll_layer->SetHaveScrollEventHandlers(true);
-    EXPECT_EQ(InputHandler::ScrollStarted,
-              host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
-    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10)));
-    host_impl_->ScrollEnd();
-
-    EXPECT_EQ(0, set_needs_commit_count);
-    EXPECT_EQ(2, set_needs_redraw_count);
-    EXPECT_EQ(1, forward_to_main_count);
   }
 }
 
 class LayerTreeHostImplWithTopControlsTest : public LayerTreeHostImplTest {
  public:
   virtual void SetUp() OVERRIDE {
     LayerTreeSettings settings = DefaultSettings();
     settings.calculate_top_controls_position = true;
     settings.top_controls_height = top_controls_height_;
     CreateHostImpl(settings, CreateOutputSurface());
@@ skipping 317 matching lines @@
   layer_pairs.clear();
   host_impl_->GetPictureLayerImplPairs(&layer_pairs);
   EXPECT_EQ(1u, layer_pairs.size());
 
   EXPECT_EQ(active_layer.get(), layer_pairs[0].active);
   EXPECT_EQ(pending_layer.get(), layer_pairs[0].pending);
 }
 
 }  // namespace
 }  // namespace cc