Update from https://crrev.com/312600

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 <string>
 
@@ skipping 112 matching lines @@
       visible_(true),
       page_scale_factor_(1.f),
       min_page_scale_factor_(1.f),
       max_page_scale_factor_(1.f),
       has_gpu_rasterization_trigger_(false),
       content_is_suitable_for_gpu_rasterization_(true),
       gpu_rasterization_histogram_recorded_(false),
       background_color_(SK_ColorWHITE),
       has_transparent_background_(false),
       partial_texture_update_requests_(0),
+      did_complete_scale_animation_(false),
       in_paint_layer_contents_(false),
       total_frames_used_for_lcd_text_metrics_(0),
       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
       next_commit_forces_redraw_(false),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       surface_id_namespace_(0u),
       next_surface_sequence_(1u) {
   if (settings_.accelerated_animation_enabled)
     animation_registrar_ = AnimationRegistrar::Create();
@@ skipping 33 matching lines @@
   proxy_->Start();
   if (settings_.accelerated_animation_enabled) {
     animation_registrar_->set_supports_scroll_animations(
         proxy_->SupportsImplScrolling());
   }
 }
 
 LayerTreeHost::~LayerTreeHost() {
   TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
 
-  overhang_ui_resource_ = nullptr;
-
   if (root_layer_.get())
     root_layer_->SetLayerTreeHost(NULL);
 
   DCHECK(swap_promise_monitor_.empty());
 
   BreakSwapPromises(SwapPromise::COMMIT_FAILS);
 
   if (proxy_) {
     DCHECK(proxy_->IsMainThread());
     proxy_->Stop();
@@ skipping 155 matching lines @@
   host_impl->SetDebugState(debug_state_);
   if (pending_page_scale_animation_) {
     sync_tree->SetPendingPageScaleAnimation(
         pending_page_scale_animation_.Pass());
   }
 
   if (!ui_resource_request_queue_.empty()) {
     sync_tree->set_ui_resource_request_queue(ui_resource_request_queue_);
     ui_resource_request_queue_.clear();
   }
-  if (overhang_ui_resource_) {
-    host_impl->SetOverhangUIResource(
-        overhang_ui_resource_->id(),
-        GetUIResourceSize(overhang_ui_resource_->id()));
-  }
 
   DCHECK(!sync_tree->ViewportSizeInvalid());
 
   if (new_impl_tree_has_no_evicted_resources) {
     if (sync_tree->ContentsTexturesPurged())
       sync_tree->ResetContentsTexturesPurged();
   }
 
   sync_tree->set_has_ever_been_drawn(false);
 
@@ skipping 18 matching lines @@
       root_layer_->AddChild(hud_layer_);
   } else if (hud_layer_.get()) {
     hud_layer_->RemoveFromParent();
     hud_layer_ = NULL;
   }
 }
 
 void LayerTreeHost::CommitComplete() {
   source_frame_number_++;
   client_->DidCommit();
+  if (did_complete_scale_animation_) {
+    client_->DidCompletePageScaleAnimation();
+    did_complete_scale_animation_ = false;
+  }
 }
 
 void LayerTreeHost::SetOutputSurface(scoped_ptr<OutputSurface> surface) {
   TRACE_EVENT0("cc", "LayerTreeHost::SetOutputSurface");
   DCHECK(output_surface_lost_);
   DCHECK(surface);
 
   proxy_->SetOutputSurface(surface.Pass());
 }
 
@@ skipping 292 matching lines @@
       min_page_scale_factor == min_page_scale_factor_ &&
       max_page_scale_factor == max_page_scale_factor_)
     return;
 
   page_scale_factor_ = page_scale_factor;
   min_page_scale_factor_ = min_page_scale_factor;
   max_page_scale_factor_ = max_page_scale_factor;
   SetNeedsCommit();
 }
 
-void LayerTreeHost::SetOverhangBitmap(const SkBitmap& bitmap) {
-  DCHECK(bitmap.width() && bitmap.height());
-  DCHECK_EQ(bitmap.bytesPerPixel(), 4);
-
-  SkBitmap bitmap_copy;
-  if (bitmap.isImmutable()) {
-    bitmap_copy = bitmap;
-  } else {
-    bitmap.copyTo(&bitmap_copy);
-    bitmap_copy.setImmutable();
-  }
-
-  UIResourceBitmap overhang_bitmap(bitmap_copy);
-  overhang_bitmap.SetWrapMode(UIResourceBitmap::REPEAT);
-  overhang_ui_resource_ = ScopedUIResource::Create(this, overhang_bitmap);
-}
-
 void LayerTreeHost::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
   if (!visible)
     ReduceMemoryUsage();
   proxy_->SetVisible(visible);
 }
 
 void LayerTreeHost::SetThrottleFrameProduction(bool throttle) {
@@ skipping 36 matching lines @@
 
   DCHECK(!root_layer()->parent());
 
   bool result = UpdateLayers(root_layer(), queue);
 
   micro_benchmark_controller_.DidUpdateLayers();
 
   return result || next_commit_forces_redraw_;
 }
 
+void LayerTreeHost::DidCompletePageScaleAnimation() {
+  did_complete_scale_animation_ = true;
+}
+
 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)
@@ skipping 586 matching lines @@
     bool children_need_begin_frames) const {
   proxy_->SetChildrenNeedBeginFrames(children_need_begin_frames);
 }
 
 void LayerTreeHost::SendBeginFramesToChildren(
     const BeginFrameArgs& args) const {
   client_->SendBeginFramesToChildren(args);
 }
 
 }  // namespace cc