Clean LayerImpl's scroll offset callers in unit tests.

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 1469 matching lines @@
 // TODO(sunxd): Make this function private once scroll offset access is fully
 // directed to scroll tree.
 SyncedScrollOffset* ScrollTree::synced_scroll_offset(int layer_id) {
   if (layer_id_to_scroll_offset_map_.find(layer_id) ==
       layer_id_to_scroll_offset_map_.end()) {
     layer_id_to_scroll_offset_map_[layer_id] = new SyncedScrollOffset;
   }
   return layer_id_to_scroll_offset_map_[layer_id].get();
 }
 
+const SyncedScrollOffset* ScrollTree::synced_scroll_offset(int layer_id) const {
+  if (layer_id_to_scroll_offset_map_.find(layer_id) ==
+      layer_id_to_scroll_offset_map_.end()) {
+    return nullptr;
+  }
+  return layer_id_to_scroll_offset_map_.at(layer_id).get();
+}
+
 gfx::ScrollOffset ScrollTree::PullDeltaForMainThread(
     SyncedScrollOffset* scroll_offset) {
   // TODO(miletus): Remove all this temporary flooring machinery when
   // Blink fully supports fractional scrolls.
   gfx::ScrollOffset current_offset =
       scroll_offset->Current(property_trees()->is_active);
   gfx::ScrollOffset current_delta = property_trees()->is_active
                                         ? scroll_offset->Delta()
                                         : scroll_offset->PendingDelta().get();
   gfx::ScrollOffset floored_delta(floor(current_delta.x()),
@@ skipping 86 matching lines @@
 
 bool ScrollTree::SetScrollOffset(int layer_id,
                                  const gfx::ScrollOffset& scroll_offset) {
   if (property_trees()->is_main_thread)
     return synced_scroll_offset(layer_id)->PushFromMainThread(scroll_offset);
   else if (property_trees()->is_active)
     return synced_scroll_offset(layer_id)->SetCurrent(scroll_offset);
   return false;
 }
 
+bool ScrollTree::UpdateScrollOffsetBaseForTesting(
+    int layer_id,
+    const gfx::ScrollOffset& offset) {
+  DCHECK(!property_trees()->is_main_thread);
+  bool changed = synced_scroll_offset(layer_id)->PushFromMainThread(offset);
+  if (property_trees()->is_active)
+    changed |= synced_scroll_offset(layer_id)->PushPendingToActive();
+  return changed;
+}
+
+const gfx::ScrollOffset ScrollTree::GetScrollOffsetBaseForTesting(
+    int layer_id) const {
+  DCHECK(!property_trees()->is_main_thread);
+  if (synced_scroll_offset(layer_id))
+    return property_trees()->is_active
+               ? synced_scroll_offset(layer_id)->ActiveBase()
+               : synced_scroll_offset(layer_id)->PendingBase();
+  else
+    return gfx::ScrollOffset();
+}
+
 PropertyTrees::PropertyTrees()
     : needs_rebuild(true),
       non_root_surfaces_enabled(true),
       changed(false),
       full_tree_damaged(false),
       sequence_number(0),
       is_main_thread(true),
       is_active(false) {
   transform_tree.SetPropertyTrees(this);
   effect_tree.SetPropertyTrees(this);
@@ skipping 131 matching lines @@
       break;
     case ALL_TREES:
       transform_tree.ResetChangeTracking();
       effect_tree.ResetChangeTracking();
   }
   changed = false;
   full_tree_damaged = false;
 }
 
 }  // namespace cc