[cc] Remove unused parameter to DidUpdateScrollOffset

cc/trees/property_tree.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 1304 matching lines @@
                                         const gfx::ScrollOffset& scroll_offset,
                                         LayerTreeImpl* layer_tree_impl) {
   // Only active tree needs to be updated, pending tree will find out about
   // these changes as a result of the shared SyncedProperty.
   if (!property_trees()->is_active)
     return;
 
   ScrollNode* scroll_node = Node(scroll_tree_index);
   if (SetScrollOffset(layer_id,
                       ClampScrollOffsetToLimits(scroll_offset, scroll_node)))
-    layer_tree_impl->DidUpdateScrollOffset(layer_id, transform_tree_index);
+    layer_tree_impl->DidUpdateScrollOffset(layer_id);
   layer_tree_impl->DidAnimateScrollOffset();
 }
 
 gfx::Size ScrollTree::scroll_clip_layer_bounds(int scroll_node_id) const {
   const ScrollNode* scroll_node = Node(scroll_node_id);
   gfx::Size scroll_clip_layer_bounds = scroll_node->scroll_clip_layer_bounds;
 
   gfx::Vector2dF scroll_clip_layer_bounds_delta;
   if (scroll_node->is_inner_viewport_scroll_layer) {
     scroll_clip_layer_bounds_delta.Add(
@@ skipping 127 matching lines @@
   // instance of synced scroll offset; if we are pushing from pending to active,
   // we reuse the pending tree's value in the map.
   if (!property_trees()->is_active) {
     changed = synced_scroll_offset(key)->PushFromMainThread(
         new_scroll_offset_map->at(key)->PendingBase());
 
     if (new_scroll_offset_map->at(key)->clobber_active_value()) {
       synced_scroll_offset(key)->set_clobber_active_value();
     }
     if (changed) {
-      layer_tree_impl->DidUpdateScrollOffset(key, kInvalidNodeId);
+      layer_tree_impl->DidUpdateScrollOffset(key);
     }
   } else {
     layer_id_to_scroll_offset_map_[key] = new_scroll_offset_map->at(key);
     changed |= synced_scroll_offset(key)->PushPendingToActive();
     if (changed) {
-      layer_tree_impl->DidUpdateScrollOffset(key, kInvalidNodeId);
+      layer_tree_impl->DidUpdateScrollOffset(key);
     }
   }
 }
 
 void ScrollTree::UpdateScrollOffsetMap(
     ScrollTree::ScrollOffsetMap* new_scroll_offset_map,
     LayerTreeImpl* layer_tree_impl) {
   if (layer_tree_impl && !layer_tree_impl->LayerListIsEmpty()) {
     DCHECK(!property_trees()->is_main_thread);
     for (auto map_entry = layer_id_to_scroll_offset_map_.begin();
@@ skipping 107 matching lines @@
   gfx::ScrollOffset adjusted_scroll(scroll);
   if (!scroll_node->user_scrollable_horizontal)
     adjusted_scroll.set_x(0);
   if (!scroll_node->user_scrollable_vertical)
     adjusted_scroll.set_y(0);
   DCHECK(scroll_node->scrollable);
   gfx::ScrollOffset old_offset = current_scroll_offset(scroll_node->owner_id);
   gfx::ScrollOffset new_offset =
       ClampScrollOffsetToLimits(old_offset + adjusted_scroll, scroll_node);
   if (SetScrollOffset(scroll_node->owner_id, new_offset))
-    layer_tree_impl->DidUpdateScrollOffset(scroll_node->owner_id,
-                                           scroll_node->transform_id);
+    layer_tree_impl->DidUpdateScrollOffset(scroll_node->owner_id);
 
   gfx::ScrollOffset unscrolled =
       old_offset + gfx::ScrollOffset(scroll) - new_offset;
   return gfx::Vector2dF(unscrolled.x(), unscrolled.y());
 }
 
 gfx::ScrollOffset ScrollTree::ClampScrollOffsetToLimits(
     gfx::ScrollOffset offset,
     ScrollNode* scroll_node) const {
   offset.SetToMin(MaxScrollOffset(scroll_node->id));
@@ skipping 629 matching lines @@
     from_target.ConcatTransform(draw_transforms.from_target);
     from_target.Scale(effect_node->surface_contents_scale.x(),
                       effect_node->surface_contents_scale.y());
     DCHECK(from_target.ApproximatelyEqual(*transform) ||
            !draw_transforms.invertible);
   }
   return success;
 }
 
 }  // namespace cc