Respect main thread scrolling reasons for fallback to root layer scrolling.

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 <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 6252 matching lines @@
     scroll_result = host_impl_->ScrollBy(
         UpdateState(gfx::Point(), gfx::Vector2dF(-0.12f, 0.1f)).get());
     EXPECT_FALSE(scroll_result.did_scroll);
     EXPECT_FALSE(scroll_result.did_overscroll_root);
     EXPECT_EQ(gfx::Vector2dF().ToString(),
               host_impl_->accumulated_root_overscroll().ToString());
     host_impl_->ScrollEnd(EndState().get());
   }
 }
 
+TEST_F(LayerTreeHostImplTest, OverscrollOnMainThread) {
+  InputHandlerScrollResult scroll_result;
+  LayerTreeSettings settings = DefaultSettings();
+  CreateHostImpl(settings, CreateOutputSurface());
+
+  LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(50, 50));

[bokan, 2016/07/01 19:02:28]

Use CreateBasicVirtualViewportLayers to build the layer tree instead. That
creates a setup that reflects our reality better. Note that it returns the
content layer, not the inner scroll layer so you'll have to set scroll_layer
using host_impl_->active_tree()->InnerViewportScrollLayer()

[Eric Seckler, 2016/07/04 08:33:26]

Done.

+  scroll_layer->set_main_thread_scrolling_reasons(
+      MainThreadScrollingReason::kThreadedScrollingDisabled);
+
+  LayerImpl* clip_layer =
+      scroll_layer->test_properties()->parent->test_properties()->parent;

[bokan, 2016/07/01 19:02:28]

Use active_tree()->InnerViewportContainerLayer()

[Eric Seckler, 2016/07/04 08:33:26]

Removed this part, should now be handled by CreateBasicVirtualViewportLayers().

+  clip_layer->SetBounds(gfx::Size(50, 50));
+  host_impl_->active_tree()->BuildPropertyTreesForTesting();
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
+  host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 4.f);
+  DrawFrame();
+
+  // Overscroll initiated outside layers will be handled by the main thread.
+  EXPECT_EQ(nullptr, host_impl_->active_tree()->FindLayerThatIsHitByPoint(
+                         gfx::PointF(0, 60)));
+  EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD,
+            host_impl_
+                ->ScrollBegin(BeginState(gfx::Point(0, 60)).get(),
+                              InputHandler::WHEEL)
+                .thread);
+
+  // Overscroll initiated inside layers will be handled by the main thread.

[bokan, 2016/07/01 19:02:28]

Could you add a similar test that doesn't set the main thread scrolling reason
and makes sure that overscroll is still handled on the impl thread in that case?

[Eric Seckler, 2016/07/04 08:33:26]

Done.

+  EXPECT_NE(nullptr, host_impl_->active_tree()->FindLayerThatIsHitByPoint(
+                         gfx::PointF(0, 0)));
+  EXPECT_EQ(
+      InputHandler::SCROLL_ON_MAIN_THREAD,
+      host_impl_
+          ->ScrollBegin(BeginState(gfx::Point(0, 0)).get(), InputHandler::WHEEL)
+          .thread);
+}
+
 class BlendStateCheckLayer : public LayerImpl {
  public:
   static std::unique_ptr<LayerImpl> Create(
       LayerTreeImpl* tree_impl,
       int id,
       ResourceProvider* resource_provider) {
     return base::WrapUnique(
         new BlendStateCheckLayer(tree_impl, id, resource_provider));
   }
 
@@ skipping 4669 matching lines @@
 
   // Re-initialize with a software output surface.
   output_surface_ = FakeOutputSurface::CreateSoftware(
       base::WrapUnique(new SoftwareOutputDevice));
   host_impl_->InitializeRenderer(output_surface_.get());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 }
 
 }  // namespace
 }  // namespace cc