Delete scrollCompensationAdjustment.

cc/layers/layer.cc

 // Copyright 2010 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/layers/layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 817 matching lines @@
       transform_node->data.needs_local_transform_update = true;
       layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
       SetNeedsCommitNoRebuild();
       return;
     }
   }
 
   SetNeedsCommit();
 }
 
-void Layer::SetScrollCompensationAdjustment(
-    const gfx::Vector2dF& scroll_compensation_adjustment) {
-  if (scroll_compensation_adjustment_ == scroll_compensation_adjustment)
-    return;
-  scroll_compensation_adjustment_ = scroll_compensation_adjustment;
-  SetNeedsCommit();
-}
-
-gfx::Vector2dF Layer::ScrollCompensationAdjustment() const {
-  return scroll_compensation_adjustment_;
-}
-
 void Layer::SetScrollOffsetFromImplSide(
     const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsPropertyChangeAllowed());
   // This function only gets called during a BeginMainFrame, so there
   // is no need to call SetNeedsUpdate here.
   DCHECK(layer_tree_host_ && layer_tree_host_->CommitRequested());
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = scroll_offset;
   SetNeedsPushProperties();
@@ skipping 416 matching lines @@
 
   // When a scroll offset animation is interrupted the new scroll position on
   // the pending tree will clobber any impl-side scrolling occuring on the
   // active tree. To do so, avoid scrolling the pending tree along with it
   // instead of trying to undo that scrolling later.
   if (ScrollOffsetAnimationWasInterrupted())
     layer_tree_host()
         ->property_trees()
         ->scroll_tree.synced_scroll_offset(layer->id())
         ->set_clobber_active_value();
-  layer->SetScrollCompensationAdjustment(ScrollCompensationAdjustment());
 
   {
     TRACE_EVENT0("cc", "Layer::PushPropertiesTo::CopyOutputRequests");
     // Wrap the copy_requests_ in a PostTask to the main thread.
     std::vector<scoped_ptr<CopyOutputRequest>> main_thread_copy_requests;
     for (auto it = copy_requests_.begin(); it != copy_requests_.end(); ++it) {
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
           layer_tree_host()->task_runner_provider()->MainThreadTaskRunner();
       scoped_ptr<CopyOutputRequest> original_request = std::move(*it);
       const CopyOutputRequest& original_request_ref = *original_request;
@@ skipping 225 matching lines @@
 
   int clip_parent_id = clip_parent_ ? clip_parent_->id() : INVALID_ID;
   base->set_clip_parent_id(clip_parent_id);
 
   if (clip_children_) {
     for (auto* child : *clip_children_)
       base->add_clip_children_ids(child->id());
   }
 
   ScrollOffsetToProto(scroll_offset_, base->mutable_scroll_offset());
-  Vector2dFToProto(scroll_compensation_adjustment_,
-                   base->mutable_scroll_compensation_adjustment());
 
   // TODO(nyquist): Figure out what to do with CopyRequests.
   // See crbug.com/570374.
 
   RectToProto(update_rect_, base->mutable_update_rect());
 
   // TODO(nyquist): Figure out what to do with LayerAnimationController.
   // See crbug.com/570376.
   // TODO(nyquist): Figure out what to do with FrameTimingRequests. See
   // crbug.com/570377.
@@ skipping 83 matching lines @@
     clip_children_->clear();
   else if (base.clip_children_ids_size() > 0)
     clip_children_.reset(new std::set<Layer*>);
   for (int i = 0; i < base.clip_children_ids_size(); ++i) {
     int child_id = base.clip_children_ids(i);
     scoped_refptr<Layer> child = layer_tree_host_->LayerById(child_id);
     clip_children_->insert(child.get());
   }
 
   scroll_offset_ = ProtoToScrollOffset(base.scroll_offset());
-  scroll_compensation_adjustment_ =
-      ProtoToVector2dF(base.scroll_compensation_adjustment());
 
   update_rect_.Union(ProtoToRect(base.update_rect()));
 }
 
 scoped_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return LayerImpl::Create(tree_impl, layer_id_);
 }
 
 bool Layer::DrawsContent() const {
   return draws_content_;
@@ skipping 294 matching lines @@
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc