Update from https://crrev.com/312398

cc/layers/layer_impl.cc

 // Copyright 2012 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_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/json/json_reader.h"
 #include "base/strings/stringprintf.h"
@@ skipping 42 matching lines @@
       double_sided_(true),
       should_flatten_transform_(true),
       layer_property_changed_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       is_root_for_isolated_group_(false),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
       draws_content_(false),
       hide_layer_and_subtree_(false),
+      clear_scroll_delta_at_activation_(false),
       transform_is_invertible_(true),
       is_container_for_fixed_position_layers_(false),
       background_color_(0),
       opacity_(1.0),
       blend_mode_(SkXfermode::kSrcOver_Mode),
       num_descendants_that_draw_content_(0),
       draw_depth_(0.f),
       needs_push_properties_(false),
       num_dependents_need_push_properties_(0),
       sorting_context_id_(0),
@@ skipping 276 matching lines @@
 void LayerImpl::SetSentScrollDelta(const gfx::Vector2dF& sent_scroll_delta) {
   // Pending tree never has sent scroll deltas
   DCHECK(layer_tree_impl()->IsActiveTree());
 
   if (sent_scroll_delta_ == sent_scroll_delta)
     return;
 
   sent_scroll_delta_ = sent_scroll_delta;
 }
 
+void LayerImpl::ClearScrollDeltaAtActivation() {
+  clear_scroll_delta_at_activation_ = true;
+}
+
 gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) {
   gfx::Vector2dF adjusted_scroll = scroll;
   if (layer_tree_impl()->settings().use_pinch_virtual_viewport) {
     if (!user_scrollable_horizontal_)
       adjusted_scroll.set_x(0);
     if (!user_scrollable_vertical_)
       adjusted_scroll.set_y(0);
   }
   DCHECK(scrollable());
   gfx::Vector2dF min_delta = -ScrollOffsetToVector2dF(scroll_offset_);
@@ skipping 168 matching lines @@
   layer->SetTransformAndInvertibility(transform_, transform_is_invertible_);
 
   layer->SetScrollClipLayer(scroll_clip_layer_ ? scroll_clip_layer_->id()
                                                : Layer::INVALID_ID);
   layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
   layer->set_user_scrollable_vertical(user_scrollable_vertical_);
 
   // Save the difference but clear the sent delta so that we don't subtract
   // it again in SetScrollOffsetAndDelta's pending twin mirroring logic.
   gfx::Vector2dF remaining_delta =
-      layer->ScrollDelta() - layer->sent_scroll_delta();
+      clear_scroll_delta_at_activation_
+          ? gfx::Vector2dF()
+          : layer->ScrollDelta() - layer->sent_scroll_delta();
+  clear_scroll_delta_at_activation_ = false;
+
   layer->SetSentScrollDelta(gfx::Vector2dF());
   layer->SetScrollOffsetAndDelta(scroll_offset_, remaining_delta);
 
   layer->Set3dSortingContextId(sorting_context_id_);
   layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
 
   LayerImpl* scroll_parent = nullptr;
   if (scroll_parent_) {
     scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id());
     DCHECK(scroll_parent);
@@ skipping 217 matching lines @@
   if (!IsActive())
     return;
 
   SetScrollDelta(scroll_offset.DeltaFrom(scroll_offset_));
 
   layer_tree_impl_->DidAnimateScrollOffset();
 }
 
 void LayerImpl::OnAnimationWaitingForDeletion() {}
 
+void LayerImpl::OnScrollOffsetAnimationRemoved() {
+}
+
 bool LayerImpl::IsActive() const {
   return layer_tree_impl_->IsActiveTree();
 }
 
 gfx::Size LayerImpl::bounds() const {
   gfx::Vector2d delta = gfx::ToCeiledVector2d(bounds_delta_);
   return gfx::Size(bounds_.width() + delta.x(),
                    bounds_.height() + delta.y());
 }
 
@@ skipping 360 matching lines @@
 
 gfx::Vector2dF LayerImpl::ScrollDelta() const {
   if (scroll_offset_delegate_) {
     return scroll_offset_delegate_->GetTotalScrollOffset().DeltaFrom(
         scroll_offset_);
   }
   return scroll_delta_;
 }
 
 void LayerImpl::SetScrollDelta(const gfx::Vector2dF& scroll_delta) {
+  if (!IsActive() && clear_scroll_delta_at_activation_)
+    return;
   SetScrollOffsetAndDelta(scroll_offset_, scroll_delta);
 }
 
 gfx::ScrollOffset LayerImpl::TotalScrollOffset() const {
   return ScrollOffsetWithDelta(scroll_offset_, ScrollDelta());
 }
 
 void LayerImpl::SetDoubleSided(bool double_sided) {
   if (double_sided_ == double_sided)
     return;
@@ skipping 270 matching lines @@
 }
 
 void LayerImpl::AsValueInto(base::debug::TracedValue* state) const {
   TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"),
       state,
       "cc::LayerImpl",
       LayerTypeAsString(),
       this);
   state->SetInteger("layer_id", id());
-  state->BeginDictionary("bounds");
-  MathUtil::AddToTracedValue(bounds_, state);
-  state->EndDictionary();
+  MathUtil::AddToTracedValue("bounds", bounds_, state);
 
   state->SetDouble("opacity", opacity());
 
-  state->BeginArray("position");
-  MathUtil::AddToTracedValue(position_, state);
-  state->EndArray();
+  MathUtil::AddToTracedValue("position", position_, state);
 
   state->SetInteger("draws_content", DrawsContent());
   state->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
 
-  state->BeginArray("scroll_offset");
-  MathUtil::AddToTracedValue(scroll_offset_, state);
-  state->EndArray();
-
-  state->BeginArray("transform_origin");
-  MathUtil::AddToTracedValue(transform_origin_, state);
-  state->EndArray();
+  MathUtil::AddToTracedValue("scroll_offset", scroll_offset_, state);
+  MathUtil::AddToTracedValue("transform_origin", transform_origin_, state);
 
   bool clipped;
   gfx::QuadF layer_quad = MathUtil::MapQuad(
       screen_space_transform(),
       gfx::QuadF(gfx::Rect(content_bounds())),
       &clipped);
-  state->BeginArray("layer_quad");
-  MathUtil::AddToTracedValue(layer_quad, state);
-  state->EndArray();
+  MathUtil::AddToTracedValue("layer_quad", layer_quad, state);
   if (!touch_event_handler_region_.IsEmpty()) {
     state->BeginArray("touch_event_handler_region");
     touch_event_handler_region_.AsValueInto(state);
     state->EndArray();
   }
   if (have_wheel_event_handlers_) {
     gfx::Rect wheel_rect(content_bounds());
     Region wheel_region(wheel_rect);
     state->BeginArray("wheel_event_handler_region");
     wheel_region.AsValueInto(state);
@@ skipping 37 matching lines @@
     state->SetInteger("clip_parent", clip_parent_->id());
 
   state->SetBoolean("can_use_lcd_text", can_use_lcd_text());
   state->SetBoolean("contents_opaque", contents_opaque());
 
   state->SetBoolean(
       "has_animation_bounds",
       layer_animation_controller()->HasAnimationThatInflatesBounds());
 
   gfx::BoxF box;
-  if (LayerUtils::GetAnimationBounds(*this, &box)) {
-    state->BeginArray("animation_bounds");
-    MathUtil::AddToTracedValue(box, state);
-    state->EndArray();
-  }
+  if (LayerUtils::GetAnimationBounds(*this, &box))
+    MathUtil::AddToTracedValue("animation_bounds", box, state);
 
   if (debug_info_.get()) {
     std::string str;
     debug_info_->AppendAsTraceFormat(&str);
     base::JSONReader json_reader;
     scoped_ptr<base::Value> debug_info_value(json_reader.ReadToValue(str));
 
     if (debug_info_value->IsType(base::Value::TYPE_DICTIONARY)) {
       base::DictionaryValue* dictionary_value = nullptr;
       bool converted_to_dictionary =
@@ skipping 39 matching lines @@
   SetNeedsPushProperties();
   layer_tree_impl()->set_needs_update_draw_properties();
   if (should_have_render_surface) {
     render_surface_ = make_scoped_ptr(new RenderSurfaceImpl(this));
     return;
   }
   render_surface_.reset();
 }
 
 }  // namespace cc