Update from https://crrev.com/312600

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 202 matching lines @@
       fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
       paint_time_counter_(PaintTimeCounter::Create()),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       texture_mailbox_deleter_(new TextureMailboxDeleter(
           proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
                                   : proxy_->MainThreadTaskRunner())),
       max_memory_needed_bytes_(0),
       zero_budget_(false),
       device_scale_factor_(1.f),
-      overhang_ui_resource_id_(0),
       resourceless_software_draw_(false),
       begin_impl_frame_interval_(BeginFrameArgs::DefaultInterval()),
       animation_registrar_(AnimationRegistrar::Create()),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       micro_benchmark_controller_(this),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       id_(id),
       requires_high_res_to_draw_(false),
       required_for_draw_tile_is_top_of_raster_queue_(false) {
@@ skipping 354 matching lines @@
     is_replica = true;
     layer->render_surface()->AppendQuads(target_render_pass,
                                          occlusion_tracker,
                                          append_quads_data,
                                          is_replica,
                                          contributing_render_pass->id);
   }
 }
 
 static void AppendQuadsToFillScreen(
-    ResourceProvider::ResourceId overhang_resource_id,
-    const gfx::SizeF& overhang_resource_scaled_size,
     const gfx::Rect& root_scroll_layer_rect,
     RenderPass* target_render_pass,
     LayerImpl* root_layer,
     SkColor screen_background_color,
     const OcclusionTracker<LayerImpl>& occlusion_tracker) {
   if (!root_layer || !SkColorGetA(screen_background_color))
     return;
 
   Region fill_region = occlusion_tracker.ComputeVisibleRegionInScreen();
   if (fill_region.IsEmpty())
     return;
 
-  // Divide the fill region into the part to be filled with the overhang
-  // resource and the part to be filled with the background color.
-  Region screen_background_color_region = fill_region;
-  Region overhang_region;
-  if (overhang_resource_id) {
-    overhang_region = fill_region;
-    overhang_region.Subtract(root_scroll_layer_rect);
-    screen_background_color_region.Intersect(root_scroll_layer_rect);
-  }
-
   // Manually create the quad state for the gutter quads, as the root layer
   // doesn't have any bounds and so can't generate this itself.
   // TODO(danakj): Make the gutter quads generated by the solid color layer
   // (make it smarter about generating quads to fill unoccluded areas).
 
   gfx::Rect root_target_rect = root_layer->render_surface()->content_rect();
   float opacity = 1.f;
   int sorting_context_id = 0;
   SharedQuadState* shared_quad_state =
       target_render_pass->CreateAndAppendSharedQuadState();
   shared_quad_state->SetAll(gfx::Transform(),
                             root_target_rect.size(),
                             root_target_rect,
                             root_target_rect,
                             false,
                             opacity,
                             SkXfermode::kSrcOver_Mode,
                             sorting_context_id);
 
-  for (Region::Iterator fill_rects(screen_background_color_region);
-       fill_rects.has_rect();
+  for (Region::Iterator fill_rects(fill_region); fill_rects.has_rect();
        fill_rects.next()) {
     gfx::Rect screen_space_rect = fill_rects.rect();
     gfx::Rect visible_screen_space_rect = screen_space_rect;
     // Skip the quad culler and just append the quads directly to avoid
     // occlusion checks.
     SolidColorDrawQuad* quad =
         target_render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     quad->SetNew(shared_quad_state,
                  screen_space_rect,
                  visible_screen_space_rect,
                  screen_background_color,
                  false);
   }
-  for (Region::Iterator fill_rects(overhang_region);
-       fill_rects.has_rect();
-       fill_rects.next()) {
-    DCHECK(overhang_resource_id);
-    gfx::Rect screen_space_rect = fill_rects.rect();
-    gfx::Rect opaque_screen_space_rect = screen_space_rect;
-    gfx::Rect visible_screen_space_rect = screen_space_rect;
-    TextureDrawQuad* tex_quad =
-        target_render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
-    const float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f};
-    tex_quad->SetNew(
-        shared_quad_state,
-        screen_space_rect,
-        opaque_screen_space_rect,
-        visible_screen_space_rect,
-        overhang_resource_id,
-        false,
-        gfx::PointF(
-            screen_space_rect.x() / overhang_resource_scaled_size.width(),
-            screen_space_rect.y() / overhang_resource_scaled_size.height()),
-        gfx::PointF(
-            screen_space_rect.right() / overhang_resource_scaled_size.width(),
-            screen_space_rect.bottom() /
-                overhang_resource_scaled_size.height()),
-        screen_background_color,
-        vertex_opacity,
-        false,
-        false);
-  }
 }
 
 DrawResult LayerTreeHostImpl::CalculateRenderPasses(
     FrameData* frame) {
   DCHECK(frame->render_passes.empty());
   DCHECK(CanDraw());
   DCHECK(active_tree_->root_layer());
 
   TrackDamageForAllSurfaces(active_tree_->root_layer(),
                             *frame->render_surface_layer_list);
@@ skipping 192 matching lines @@
       DCHECK(quad->shared_quad_state);
     DCHECK(frame->render_passes_by_id.find(render_pass->id) !=
            frame->render_passes_by_id.end());
   }
 #endif
   DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
 
   if (!active_tree_->has_transparent_background()) {
     frame->render_passes.back()->has_transparent_background = false;
     AppendQuadsToFillScreen(
-        ResourceIdForUIResource(overhang_ui_resource_id_),
-        gfx::ScaleSize(overhang_ui_resource_size_, device_scale_factor_),
         active_tree_->RootScrollLayerDeviceViewportBounds(),
         frame->render_passes.back(),
         active_tree_->root_layer(),
         active_tree_->background_color(),
         occlusion_tracker);
   }
 
   RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
   renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
 
@@ skipping 1318 matching lines @@
     active_tree_->SetViewportSizeInvalid();
 
   device_viewport_size_ = device_viewport_size;
 
   UpdateViewportContainerSizes();
   client_->OnCanDrawStateChanged(CanDraw());
   SetFullRootLayerDamage();
   active_tree_->set_needs_update_draw_properties();
 }
 
-void LayerTreeHostImpl::SetOverhangUIResource(
-    UIResourceId overhang_ui_resource_id,
-    const gfx::Size& overhang_ui_resource_size) {
-  overhang_ui_resource_id_ = overhang_ui_resource_id;
-  overhang_ui_resource_size_ = overhang_ui_resource_size;
-}
-
 void LayerTreeHostImpl::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor == device_scale_factor_)
     return;
   device_scale_factor_ = device_scale_factor;
 
   SetFullRootLayerDamage();
 }
 
 void LayerTreeHostImpl::SetPageScaleOnActiveTree(float page_scale_factor) {
   active_tree_->SetPageScaleOnActiveTree(page_scale_factor);
@@ skipping 845 matching lines @@
   gfx::ScrollOffset next_scroll = gfx::ScrollOffset(
       page_scale_animation_->ScrollOffsetAtTime(monotonic_time));
 
   ScrollViewportInnerFirst(next_scroll.DeltaFrom(scroll_total));
   SetNeedsRedraw();
 
   if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
     page_scale_animation_ = nullptr;
     client_->SetNeedsCommitOnImplThread();
     client_->RenewTreePriority();
+    client_->DidCompletePageScaleAnimationOnImplThread();
   } else {
     SetNeedsAnimate();
   }
 }
 
 void LayerTreeHostImpl::AnimateTopControls(base::TimeTicks time) {
   if (!top_controls_manager_ || !top_controls_manager_->animation())
     return;
 
   gfx::Vector2dF scroll = top_controls_manager_->Animate(time);
@@ skipping 388 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc