Ignore should-scroll-on-main-thread if main frame is not scrollable

cc/trees/layer_tree_host.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.h"
 
 #include <algorithm>
 #include <stack>
 
 #include "base/bind.h"
@@ skipping 672 matching lines @@
   DCHECK(!root_layer()->parent());
 
   if (contents_texture_manager_ && memory_allocation_limit_bytes) {
     contents_texture_manager_->SetMaxMemoryLimitBytes(
         memory_allocation_limit_bytes);
   }
 
   return UpdateLayers(root_layer(), queue);
 }
 
-static Layer* FindFirstScrollableLayer(Layer* layer) {
-  if (!layer)
-    return NULL;
-
-  if (layer->scrollable())
-    return layer;
-
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    Layer* found = FindFirstScrollableLayer(layer->children()[i].get());
-    if (found)
-      return found;
-  }
-
-  return NULL;
-}
-
 void LayerTreeHost::CalculateLCDTextMetricsCallback(Layer* layer) {
   if (!layer->SupportsLCDText())
     return;
 
   lcd_text_metrics_.total_num_cc_layers++;
   if (layer->draw_properties().can_use_lcd_text) {
     lcd_text_metrics_.total_num_cc_layers_can_use_lcd_text++;
     if (layer->contents_opaque())
       lcd_text_metrics_.total_num_cc_layers_will_use_lcd_text++;
   }
 }
 
 bool LayerTreeHost::UsingSharedMemoryResources() {
   return GetRendererCapabilities().using_shared_memory_resources;
 }
 
 bool LayerTreeHost::UpdateLayers(Layer* root_layer,
                                  ResourceUpdateQueue* queue) {
   TRACE_EVENT1(benchmark_instrumentation::kCategory,
                benchmark_instrumentation::kLayerTreeHostUpdateLayers,
                benchmark_instrumentation::kSourceFrameNumber,
                source_frame_number());
 
   RenderSurfaceLayerList update_list;
   {
     UpdateHudLayer();
 
-    Layer* root_scroll = FindFirstScrollableLayer(root_layer);
+    Layer* root_scroll =
+        LayerTreeHostCommon::FindFirstScrollableLayer(root_layer);
 
     if (hud_layer_) {
       hud_layer_->PrepareForCalculateDrawProperties(
           device_viewport_size(), device_scale_factor_);
     }
 
     TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::CalcDrawProps");
     LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(
         root_layer,
         device_viewport_size(),
@@ skipping 254 matching lines @@
   if (has_scrolls) {
     // We use async events here because we want to conditionally trace. This
     // is too spammy otherwise.
     TRACE_EVENT_ASYNC_BEGIN0(
         "impl-scroll",
         "LayerTreeHost::ApplyScrollAndScale",
         this);
   }
 
   gfx::Vector2d root_scroll_delta;
-  Layer* root_scroll_layer = FindFirstScrollableLayer(root_layer_.get());
+  Layer* root_scroll_layer =
+      LayerTreeHostCommon::FindFirstScrollableLayer(root_layer_.get());
 
   for (size_t i = 0; i < info.scrolls.size(); ++i) {
     Layer* layer =
         LayerTreeHostCommon::FindLayerInSubtree(root_layer_.get(),
                                                 info.scrolls[i].layer_id);
     if (!layer)
       continue;
     if (layer == root_scroll_layer) {
       root_scroll_delta += info.scrolls[i].scroll_delta;
     } else {
       layer->SetScrollOffsetFromImplSide(layer->scroll_offset() +
                                          info.scrolls[i].scroll_delta);
     }
   }
 
   if (!root_scroll_delta.IsZero() || info.page_scale_delta != 1.f) {
     // SetScrollOffsetFromImplSide above could have destroyed the tree,
     // so re-get this layer before doing anything to it.
-    root_scroll_layer = FindFirstScrollableLayer(root_layer_.get());
+    root_scroll_layer =
+        LayerTreeHostCommon::FindFirstScrollableLayer(root_layer_.get());
 
     // Preemptively apply the scroll offset and scale delta here before sending
     // it to the client.  If the client comes back and sets it to the same
     // value, then the layer can early out without needing a full commit.
     if (root_scroll_layer) {
       root_scroll_layer->SetScrollOffsetFromImplSide(
           root_scroll_layer->scroll_offset() + root_scroll_delta);
     }
     ApplyPageScaleDeltaFromImplSide(info.page_scale_delta);
     client_->ApplyScrollAndScale(root_scroll_delta, info.page_scale_delta);
@@ skipping 150 matching lines @@
 void LayerTreeHost::DidLoseUIResources() {
   // When output surface is lost, we need to recreate the resource.
   for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
        iter != ui_resource_client_map_.end();
        ++iter) {
     UIResourceLost(iter->first);
   }
 }
 
 }  // namespace cc