Update from https://crrev.com/316786

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 50 matching lines @@
 #include "cc/resources/software_rasterizer.h"
 #include "cc/resources/texture_mailbox_deleter.h"
 #include "cc/resources/tile_task_worker_pool.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/resources/zero_copy_tile_task_worker_pool.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
-#include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
@@ skipping 146 matching lines @@
       is_likely_to_require_a_draw_(false),
       frame_timing_tracker_(FrameTimingTracker::Create()) {
   DCHECK(proxy_->IsImplThread());
   DidVisibilityChange(this, visible_);
   animation_registrar_->set_supports_scroll_animations(
       proxy_->SupportsImplScrolling());
 
   SetDebugState(settings.initial_debug_state);
 
   // LTHI always has an active tree.
-  active_tree_ = LayerTreeImpl::create(this, new SyncedProperty<ScaleGroup>(),
-                                       new SyncedElasticOverscroll);
+  active_tree_ =
+      LayerTreeImpl::create(this, new SyncedProperty<ScaleGroup>(),
+                            new SyncedTopControls, new SyncedElasticOverscroll);
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
 
   if (settings.calculate_top_controls_position) {
     top_controls_manager_ =
         TopControlsManager::Create(this,
                                    settings.top_controls_show_threshold,
                                    settings.top_controls_hide_threshold);
   }
@@ skipping 38 matching lines @@
 
 void LayerTreeHostImpl::BeginCommit() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::BeginCommit");
 
   // Ensure all textures are returned so partial texture updates can happen
   // during the commit. Impl-side-painting doesn't upload during commits, so
   // is unaffected.
   if (!settings_.impl_side_painting && output_surface_)
     output_surface_->ForceReclaimResources();
 
-  if (UsePendingTreeForSync())
+  if (settings_.impl_side_painting && !proxy_->CommitToActiveTree())
     CreatePendingTree();
 }
 
 void LayerTreeHostImpl::CommitComplete() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
 
   sync_tree()->set_needs_update_draw_properties();
 
   if (settings_.impl_side_painting) {
     // Impl-side painting needs an update immediately post-commit to have the
@@ skipping 232 matching lines @@
         render_surface->layer_list(),
         render_surface_layer->id(),
         render_surface->SurfacePropertyChangedOnlyFromDescendant(),
         render_surface->content_rect(),
         render_surface_layer->mask_layer(),
         render_surface_layer->filters());
   }
 }
 
 void LayerTreeHostImpl::FrameData::AsValueInto(
-    base::debug::TracedValue* value) const {
+    base::trace_event::TracedValue* value) const {
   value->SetBoolean("has_no_damage", has_no_damage);
 
   // Quad data can be quite large, so only dump render passes if we select
   // cc.debug.quads.
   bool quads_enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"), &quads_enabled);
   if (quads_enabled) {
     value->BeginArray("render_passes");
     for (size_t i = 0; i < render_passes.size(); ++i) {
@@ skipping 19 matching lines @@
   } else {
     DCHECK_EQ(!output_surface_->software_device(),
               output_surface_->capabilities().delegated_rendering &&
                   !output_surface_->capabilities().deferred_gl_initialization)
         << output_surface_->capabilities().delegated_rendering << " "
         << output_surface_->capabilities().deferred_gl_initialization;
     return DRAW_MODE_SOFTWARE;
   }
 }
 
-static void AppendQuadsForLayer(
-    RenderPass* target_render_pass,
-    LayerImpl* layer,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
-    AppendQuadsData* append_quads_data) {
-  layer->AppendQuads(
-      target_render_pass,
-      occlusion_tracker.GetCurrentOcclusionForLayer(layer->draw_transform()),
-      append_quads_data);
-}
-
 static void AppendQuadsForRenderSurfaceLayer(
     RenderPass* target_render_pass,
     LayerImpl* layer,
     const RenderPass* contributing_render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data) {
-  bool is_replica = false;
-  layer->render_surface()->AppendQuads(target_render_pass,
-                                       occlusion_tracker,
-                                       append_quads_data,
-                                       is_replica,
-                                       contributing_render_pass->id);
+  RenderSurfaceImpl* surface = layer->render_surface();
+  const gfx::Transform& draw_transform = surface->draw_transform();
+  const Occlusion& occlusion = surface->occlusion_in_content_space();
+  SkColor debug_border_color = surface->GetDebugBorderColor();
+  float debug_border_width = surface->GetDebugBorderWidth();
+  LayerImpl* mask_layer = layer->mask_layer();
+
+  surface->AppendQuads(target_render_pass, draw_transform, occlusion,
+                       debug_border_color, debug_border_width, mask_layer,
+                       append_quads_data, contributing_render_pass->id);
 
   // Add replica after the surface so that it appears below the surface.
   if (layer->has_replica()) {
-    is_replica = true;
-    layer->render_surface()->AppendQuads(target_render_pass,
-                                         occlusion_tracker,
-                                         append_quads_data,
-                                         is_replica,
-                                         contributing_render_pass->id);
+    const gfx::Transform& replica_draw_transform =
+        surface->replica_draw_transform();
+    Occlusion replica_occlusion = occlusion.GetOcclusionWithGivenDrawTransform(
+        surface->replica_draw_transform());
+    SkColor replica_debug_border_color = surface->GetReplicaDebugBorderColor();
+    float replica_debug_border_width = surface->GetReplicaDebugBorderWidth();
+    // TODO(danakj): By using the same RenderSurfaceImpl for both the
+    // content and its reflection, it's currently not possible to apply a
+    // separate mask to the reflection layer or correctly handle opacity in
+    // reflections (opacity must be applied after drawing both the layer and its
+    // reflection). The solution is to introduce yet another RenderSurfaceImpl
+    // to draw the layer and its reflection in. For now we only apply a separate
+    // reflection mask if the contents don't have a mask of their own.
+    LayerImpl* replica_mask_layer =
+        mask_layer ? mask_layer : layer->replica_layer()->mask_layer();
+
+    surface->AppendQuads(target_render_pass, replica_draw_transform,
+                         replica_occlusion, replica_debug_border_color,
+                         replica_debug_border_width, replica_mask_layer,
+                         append_quads_data, contributing_render_pass->id);
   }
 }
 
-static void AppendQuadsToFillScreen(
-    const gfx::Rect& root_scroll_layer_rect,
-    RenderPass* target_render_pass,
-    LayerImpl* root_layer,
-    SkColor screen_background_color,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker) {
+static void AppendQuadsToFillScreen(const gfx::Rect& root_scroll_layer_rect,
+                                    RenderPass* target_render_pass,
+                                    LayerImpl* root_layer,
+                                    SkColor screen_background_color,
+                                    const Region& fill_region) {
   if (!root_layer || !SkColorGetA(screen_background_color))
     return;
-
-  Region fill_region = occlusion_tracker.ComputeVisibleRegionInScreen();
   if (fill_region.IsEmpty())
     return;
 
   // 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;
@@ skipping 83 matching lines @@
   // entire root surface. This will disable partial-swap/scissor optimizations
   // that would prevent the HUD from updating, since the HUD does not cause
   // damage itself, to prevent it from messing with damage visualizations. Since
   // damage visualizations are done off the LayerImpls and RenderSurfaceImpls,
   // changing the RenderPass does not affect them.
   if (active_tree_->hud_layer()) {
     RenderPass* root_pass = frame->render_passes.back();
     root_pass->damage_rect = root_pass->output_rect;
   }
 
-  OcclusionTracker<LayerImpl> occlusion_tracker(
-      active_tree_->root_layer()->render_surface()->content_rect());
-  occlusion_tracker.set_minimum_tracking_size(
-      settings_.minimum_occlusion_tracking_size);
-
-  if (debug_state_.show_occluding_rects) {
-    occlusion_tracker.set_occluding_screen_space_rects_container(
-        &frame->occluding_screen_space_rects);
-  }
-  if (debug_state_.show_non_occluding_rects) {
-    occlusion_tracker.set_non_occluding_screen_space_rects_container(
-        &frame->non_occluding_screen_space_rects);
-  }
-
-  // Add quads to the Render passes in front-to-back order to allow for testing
-  // occlusion and performing culling during the tree walk.
-  typedef LayerIterator<LayerImpl> LayerIteratorType;
+  // Grab this region here before iterating layers. Taking copy requests from
+  // the layers while constructing the render passes will dirty the render
+  // surface layer list and this unoccluded region, flipping the dirty bit to
+  // true, and making us able to query for it without doing
+  // UpdateDrawProperties again. The value inside the Region is not actually
+  // changed until UpdateDrawProperties happens, so a reference to it is safe.
+  const Region& unoccluded_screen_space_region =
+      active_tree_->UnoccludedScreenSpaceRegion();
 
   // Typically when we are missing a texture and use a checkerboard quad, we
   // still draw the frame. However when the layer being checkerboarded is moving
   // due to an impl-animation, we drop the frame to avoid flashing due to the
   // texture suddenly appearing in the future.
   DrawResult draw_result = DRAW_SUCCESS;
   // When we have a copy request for a layer, we need to draw no matter
   // what, as the layer may disappear after this frame.
   bool have_copy_request = false;
 
   int layers_drawn = 0;
 
   const DrawMode draw_mode = GetDrawMode();
 
   int num_missing_tiles = 0;
   int num_incomplete_tiles = 0;
 
-  LayerIteratorType end =
-      LayerIteratorType::End(frame->render_surface_layer_list);
-  for (LayerIteratorType it =
-           LayerIteratorType::Begin(frame->render_surface_layer_list);
-       it != end;
-       ++it) {
+  auto end = LayerIterator<LayerImpl>::End(frame->render_surface_layer_list);
+  for (auto it =
+           LayerIterator<LayerImpl>::Begin(frame->render_surface_layer_list);
+       it != end; ++it) {
     RenderPassId target_render_pass_id =
         it.target_render_surface_layer()->render_surface()->GetRenderPassId();
     RenderPass* target_render_pass =
         frame->render_passes_by_id[target_render_pass_id];
 
-    occlusion_tracker.EnterLayer(it);
-
     AppendQuadsData append_quads_data;
 
     if (it.represents_target_render_surface()) {
       if (it->HasCopyRequest()) {
         have_copy_request = true;
         it->TakeCopyRequestsAndTransformToTarget(
             &target_render_pass->copy_requests);
       }
     } else if (it.represents_contributing_render_surface() &&
                it->render_surface()->contributes_to_drawn_surface()) {
       RenderPassId contributing_render_pass_id =
           it->render_surface()->GetRenderPassId();
       RenderPass* contributing_render_pass =
           frame->render_passes_by_id[contributing_render_pass_id];
       AppendQuadsForRenderSurfaceLayer(target_render_pass,
                                        *it,
                                        contributing_render_pass,
-                                       occlusion_tracker,
                                        &append_quads_data);
     } else if (it.represents_itself() &&
                !it->visible_content_rect().IsEmpty()) {
       bool occluded =
-          occlusion_tracker.GetCurrentOcclusionForLayer(it->draw_transform())
-              .IsOccluded(it->visible_content_rect());
+          it->draw_properties().occlusion_in_content_space.IsOccluded(
+              it->visible_content_rect());
       if (!occluded && it->WillDraw(draw_mode, resource_provider_.get())) {
         DCHECK_EQ(active_tree_, it->layer_tree_impl());
 
         frame->will_draw_layers.push_back(*it);
 
         if (it->HasContributingDelegatedRenderPasses()) {
           RenderPassId contributing_render_pass_id =
               it->FirstContributingRenderPassId();
           while (frame->render_passes_by_id.find(contributing_render_pass_id) !=
                  frame->render_passes_by_id.end()) {
             RenderPass* render_pass =
                 frame->render_passes_by_id[contributing_render_pass_id];
 
-            AppendQuadsForLayer(render_pass,
-                                *it,
-                                occlusion_tracker,
-                                &append_quads_data);
+            it->AppendQuads(render_pass, &append_quads_data);
 
             contributing_render_pass_id =
                 it->NextContributingRenderPassId(contributing_render_pass_id);
           }
         }
 
-        AppendQuadsForLayer(target_render_pass,
-                            *it,
-                            occlusion_tracker,
-                            &append_quads_data);
+        it->AppendQuads(target_render_pass, &append_quads_data);
 
         // For layers that represent themselves, add composite frame timing
         // requests if the visible rect intersects the requested rect.
         for (const auto& request : it->frame_timing_requests()) {
           const gfx::Rect& request_content_rect =
               it->LayerRectToContentRect(request.rect());
           if (request_content_rect.Intersects(it->visible_content_rect())) {
             frame->composite_events.push_back(
                 FrameTimingTracker::FrameAndRectIds(
                     active_tree_->source_frame_number(), request.id()));
@@ skipping 18 matching lines @@
           it->draw_transform_is_animating();
       if (layer_has_animating_transform)
         draw_result = DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
     }
 
     if (append_quads_data.num_incomplete_tiles ||
         append_quads_data.num_missing_tiles) {
       if (RequiresHighResToDraw())
         draw_result = DRAW_ABORTED_MISSING_HIGH_RES_CONTENT;
     }
-
-    occlusion_tracker.LeaveLayer(it);
   }
 
   if (have_copy_request ||
       output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
     draw_result = DRAW_SUCCESS;
 
 #if DCHECK_IS_ON()
   for (const auto& render_pass : frame->render_passes) {
     for (const auto& quad : render_pass->quad_list)
       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(
         active_tree_->RootScrollLayerDeviceViewportBounds(),
-        frame->render_passes.back(),
-        active_tree_->root_layer(),
-        active_tree_->background_color(),
-        occlusion_tracker);
+        frame->render_passes.back(), active_tree_->root_layer(),
+        active_tree_->background_color(), unoccluded_screen_space_region);
   }
 
   RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
   renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
 
   // Any copy requests left in the tree are not going to get serviced, and
   // should be aborted.
   ScopedPtrVector<CopyOutputRequest> requests_to_abort;
   while (!active_tree_->LayersWithCopyOutputRequest().empty()) {
     LayerImpl* layer = active_tree_->LayersWithCopyOutputRequest().back();
@@ skipping 195 matching lines @@
   EnforceManagedMemoryPolicy(ManagedMemoryPolicy(0));
 }
 
 void LayerTreeHostImpl::BlockNotifyReadyToActivateForTesting(bool block) {
   NOTREACHED();
 }
 
 void LayerTreeHostImpl::ResetTreesForTesting() {
   if (active_tree_)
     active_tree_->DetachLayerTree();
-  active_tree_ = LayerTreeImpl::create(this, active_tree()->page_scale_factor(),
-                                       active_tree()->elastic_overscroll());
+  active_tree_ =
+      LayerTreeImpl::create(this, active_tree()->page_scale_factor(),
+                            active_tree()->top_controls_shown_ratio(),
+                            active_tree()->elastic_overscroll());
   if (pending_tree_)
     pending_tree_->DetachLayerTree();
   pending_tree_ = nullptr;
   if (recycle_tree_)
     recycle_tree_->DetachLayerTree();
   recycle_tree_ = nullptr;
 }
 
 void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
@@ skipping 71 matching lines @@
   DCHECK(settings_.impl_side_painting);
   // Mark priorities as dirty and schedule a PrepareTiles().
   tile_priorities_dirty_ = true;
   client_->SetNeedsPrepareTilesOnImplThread();
 }
 
 void LayerTreeHostImpl::GetPictureLayerImplPairs(
     std::vector<PictureLayerImpl::Pair>* layer_pairs,
     bool need_valid_tile_priorities) const {
   DCHECK(layer_pairs->empty());
-  for (std::vector<PictureLayerImpl*>::const_iterator it =
-           picture_layers_.begin();
-       it != picture_layers_.end();
-       ++it) {
-    PictureLayerImpl* layer = *it;
 
-    if (!layer->IsOnActiveOrPendingTree() ||
-        (need_valid_tile_priorities && !layer->HasValidTilePriorities()))
+  for (auto& layer : active_tree_->picture_layers()) {
+    if (need_valid_tile_priorities && !layer->HasValidTilePriorities())
       continue;
-
     PictureLayerImpl* twin_layer = layer->GetPendingOrActiveTwinLayer();
-
     // Ignore the twin layer when tile priorities are invalid.
     if (need_valid_tile_priorities && twin_layer &&
-        !twin_layer->HasValidTilePriorities())
-      twin_layer = NULL;
+        !twin_layer->HasValidTilePriorities()) {
+      twin_layer = nullptr;
+    }
+    layer_pairs->push_back(PictureLayerImpl::Pair(layer, twin_layer));
+  }
 
-    // If the current tree is ACTIVE_TREE, then always generate a layer_pair.
-    // If current tree is PENDING_TREE, then only generate a layer_pair if
-    // there is no twin layer.
-    if (layer->GetTree() == ACTIVE_TREE) {
-      DCHECK_IMPLIES(twin_layer, twin_layer->GetTree() == PENDING_TREE);
-      layer_pairs->push_back(PictureLayerImpl::Pair(layer, twin_layer));
-    } else if (!twin_layer) {
-      DCHECK(layer->GetTree() == PENDING_TREE);
-      layer_pairs->push_back(PictureLayerImpl::Pair(NULL, layer));
+  if (pending_tree_) {
+    for (auto& layer : pending_tree_->picture_layers()) {
+      if (need_valid_tile_priorities && !layer->HasValidTilePriorities())
+        continue;
+      if (PictureLayerImpl* twin_layer = layer->GetPendingOrActiveTwinLayer()) {
+        if (!need_valid_tile_priorities ||
+            twin_layer->HasValidTilePriorities()) {
+          // Already captured from the active tree.
+          continue;
+        }
+      }
+      layer_pairs->push_back(PictureLayerImpl::Pair(nullptr, layer));
     }
   }
 }
 
 scoped_ptr<RasterTilePriorityQueue> LayerTreeHostImpl::BuildRasterQueue(
     TreePriority tree_priority,
     RasterTilePriorityQueue::Type type) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildRasterQueue");
   picture_layer_pairs_.clear();
   GetPictureLayerImplPairs(&picture_layer_pairs_, true);
@@ skipping 13 matching lines @@
 
 void LayerTreeHostImpl::SetIsLikelyToRequireADraw(
     bool is_likely_to_require_a_draw) {
   // Proactively tell the scheduler that we expect to draw within each vsync
   // until we get all the tiles ready to draw. If we happen to miss a required
   // for draw tile here, then we will miss telling the scheduler each frame that
   // we intend to draw so it may make worse scheduling decisions.
   is_likely_to_require_a_draw_ = is_likely_to_require_a_draw;
 }
 
-const std::vector<PictureLayerImpl*>& LayerTreeHostImpl::GetPictureLayers()
-    const {
-  return picture_layers_;
-}
-
 void LayerTreeHostImpl::NotifyReadyToActivate() {
   client_->NotifyReadyToActivate();
 }
 
 void LayerTreeHostImpl::NotifyReadyToDraw() {
   // Tiles that are ready will cause NotifyTileStateChanged() to be called so we
   // don't need to schedule a draw here. Just stop WillBeginImplFrame() from
   // causing optimistic requests to draw a frame.
   is_likely_to_require_a_draw_ = false;
 
@@ skipping 162 matching lines @@
   if (top_controls_manager_) {
     metadata.location_bar_offset =
         gfx::Vector2dF(0.f, top_controls_manager_->ControlsTopOffset());
     metadata.location_bar_content_translation =
         gfx::Vector2dF(0.f, top_controls_manager_->ContentTopOffset());
   }
 
   active_tree_->GetViewportSelection(&metadata.selection_start,
                                      &metadata.selection_end);
 
+  LayerImpl* root_layer_for_overflow = OuterViewportScrollLayer()
+                                           ? OuterViewportScrollLayer()
+                                           : InnerViewportScrollLayer();
+  if (root_layer_for_overflow) {
+    metadata.root_overflow_x_hidden =
+        !root_layer_for_overflow->user_scrollable_horizontal();
+    metadata.root_overflow_y_hidden =
+        !root_layer_for_overflow->user_scrollable_vertical();
+  }
+
   if (!InnerViewportScrollLayer())
     return metadata;
 
   // TODO(miletus) : Change the metadata to hold ScrollOffset.
   metadata.root_scroll_offset = gfx::ScrollOffsetToVector2dF(
       active_tree_->TotalScrollOffset());
 
   return metadata;
 }
 
@@ skipping 27 matching lines @@
   if (tile_manager_) {
     memory_history_->SaveEntry(
         tile_manager_->memory_stats_from_last_assign());
   }
 
   if (debug_state_.ShowHudRects()) {
     debug_rect_history_->SaveDebugRectsForCurrentFrame(
         active_tree_->root_layer(),
         active_tree_->hud_layer(),
         *frame->render_surface_layer_list,
-        frame->occluding_screen_space_rects,
-        frame->non_occluding_screen_space_rects,
         debug_state_);
   }
 
   if (!settings_.impl_side_painting && debug_state_.continuous_painting) {
     const RenderingStats& stats =
         rendering_stats_instrumentation_->GetRenderingStats();
     paint_time_counter_->SavePaintTime(
         stats.begin_main_frame_to_commit_duration.GetLastTimeDelta());
   }
 
@@ skipping 157 matching lines @@
 
   ViewportAnchor anchor(InnerViewportScrollLayer(),
                         OuterViewportScrollLayer());
 
   // Adjust the inner viewport by shrinking/expanding the container to account
   // for the change in top controls height since the last Resize from Blink.
   float top_controls_layout_height =
       active_tree_->top_controls_shrink_blink_size()
           ? active_tree_->top_controls_height()
           : 0.f;
-  inner_container->SetBoundsDelta(
-      gfx::Vector2dF(0, top_controls_layout_height -
-                            active_tree_->total_top_controls_content_offset()));
+  inner_container->SetBoundsDelta(gfx::Vector2dF(
+      0,
+      top_controls_layout_height - top_controls_manager_->ContentTopOffset()));
 
   if (!outer_container || outer_container->BoundsForScrolling().IsEmpty())
     return;
 
   // Adjust the outer viewport container as well, since adjusting only the
   // inner may cause its bounds to exceed those of the outer, causing scroll
   // clamping. We adjust it so it maintains the same aspect ratio as the
   // inner viewport.
   float aspect_ratio = inner_container->BoundsForScrolling().width() /
       inner_container->BoundsForScrolling().height();
@@ skipping 67 matching lines @@
   return NULL;
 }
 
 void LayerTreeHostImpl::CreatePendingTree() {
   CHECK(!pending_tree_);
   if (recycle_tree_)
     recycle_tree_.swap(pending_tree_);
   else
     pending_tree_ =
         LayerTreeImpl::create(this, active_tree()->page_scale_factor(),
+                              active_tree()->top_controls_shown_ratio(),
                               active_tree()->elastic_overscroll());
 
-  // Update the delta from the active tree, which may have
-  // adjusted its delta prior to the pending tree being created.
-  DCHECK_EQ(0.f, pending_tree_->sent_top_controls_delta());
-  pending_tree_->set_top_controls_delta(
-      active_tree_->top_controls_delta() -
-      active_tree_->sent_top_controls_delta());
-  pending_tree_->set_top_controls_height(active_tree_->top_controls_height());
-
   client_->OnCanDrawStateChanged(CanDraw());
   TRACE_EVENT_ASYNC_BEGIN0("cc", "PendingTree:waiting", pending_tree_.get());
 }
 
 void LayerTreeHostImpl::ActivateSyncTree() {
   if (pending_tree_) {
     TRACE_EVENT_ASYNC_END0("cc", "PendingTree:waiting", pending_tree_.get());
 
     active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
     active_tree_->PushPersistedState(pending_tree_.get());
@@ skipping 14 matching lines @@
 
     // Now that we've synced everything from the pending tree to the active
     // tree, rename the pending tree the recycle tree so we can reuse it on the
     // next sync.
     DCHECK(!recycle_tree_);
     pending_tree_.swap(recycle_tree_);
 
     active_tree_->SetRootLayerScrollOffsetDelegate(
         root_layer_scroll_offset_delegate_);
 
-    if (top_controls_manager_) {
-      top_controls_manager_->SetTopControlsHeight(
-          active_tree_->top_controls_height());
-      top_controls_manager_->SetControlsTopOffset(
-          active_tree_->total_top_controls_content_offset() -
-          active_tree_->top_controls_height());
-    }
-
     UpdateViewportContainerSizes();
   } else {
     active_tree_->ProcessUIResourceRequestQueue();
   }
 
   active_tree_->DidBecomeActive();
   ActivateAnimations();
   if (settings_.impl_side_painting) {
     client_->RenewTreePriority();
     // If we have any picture layers, then by activating we also modified tile
     // priorities.
-    if (!picture_layers_.empty())
+    if (!active_tree_->picture_layers().empty())
       DidModifyTilePriorities();
   }
 
   client_->OnCanDrawStateChanged(CanDraw());
   client_->DidActivateSyncTree();
   if (!tree_activation_callback_.is_null())
     tree_activation_callback_.Run();
 
   if (debug_state_.continuous_painting) {
     const RenderingStats& stats =
@@ skipping 187 matching lines @@
         resource_provider_.get());
     return;
   }
 
   if (use_gpu_rasterization_) {
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
 
     *tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
         task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
-        resource_provider_.get());
+        static_cast<GpuRasterizer*>(rasterizer_.get()));
     return;
   }
 
   if (GetRendererCapabilities().using_image) {
     unsigned image_target = settings_.use_image_texture_target;
     DCHECK_IMPLIES(
         image_target == GL_TEXTURE_RECTANGLE_ARB,
         context_provider->ContextCapabilities().gpu.texture_rectangle);
     DCHECK_IMPLIES(
         image_target == GL_TEXTURE_EXTERNAL_OES,
@@ skipping 44 matching lines @@
 
 void LayerTreeHostImpl::DestroyTileManager() {
   tile_manager_ = nullptr;
   resource_pool_ = nullptr;
   staging_resource_pool_ = nullptr;
   tile_task_worker_pool_ = nullptr;
   rasterizer_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
 }
 
-bool LayerTreeHostImpl::UsePendingTreeForSync() const {
-  // In impl-side painting, synchronize to the pending tree so that it has
-  // time to raster before being displayed.
-  return settings_.impl_side_painting;
-}
-
 bool LayerTreeHostImpl::IsSynchronousSingleThreaded() const {
   return !proxy_->HasImplThread() && !settings_.single_thread_proxy_scheduler;
 }
 
 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
   SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(
     scoped_ptr<OutputSurface> output_surface) {
@@ skipping 168 matching lines @@
 }
 
 void LayerTreeHostImpl::DidChangeTopControlsPosition() {
   UpdateViewportContainerSizes();
   SetNeedsRedraw();
   SetNeedsAnimate();
   active_tree_->set_needs_update_draw_properties();
   SetFullRootLayerDamage();
 }
 
-void LayerTreeHostImpl::SetControlsTopOffset(float offset) {
-  float current_top_offset = active_tree_->top_controls_content_offset() -
-                             active_tree_->top_controls_height();
-  active_tree_->set_top_controls_delta(offset - current_top_offset);
+float LayerTreeHostImpl::TopControlsHeight() const {
+  return active_tree_->top_controls_height();
 }
 
-float LayerTreeHostImpl::ControlsTopOffset() const {
-  return active_tree_->total_top_controls_content_offset() -
-         active_tree_->top_controls_height();
+void LayerTreeHostImpl::SetCurrentTopControlsShownRatio(float ratio) {
+  if (active_tree_->SetCurrentTopControlsShownRatio(ratio))
+    DidChangeTopControlsPosition();
+}
+
+float LayerTreeHostImpl::CurrentTopControlsShownRatio() const {
+  return active_tree_->CurrentTopControlsShownRatio();
 }
 
 void LayerTreeHostImpl::BindToClient(InputHandlerClient* client) {
   DCHECK(input_handler_client_ == NULL);
   input_handler_client_ = client;
 }
 
 LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
     const gfx::PointF& device_viewport_point,
     InputHandler::ScrollInputType type,
@@ skipping 732 matching lines @@
   for (size_t i = 0; i < layer_impl->children().size(); ++i)
     CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
 }
 
 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
   scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
 
   CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
   scroll_info->page_scale_delta =
       active_tree_->page_scale_factor()->PullDeltaForMainThread();
+  scroll_info->top_controls_delta =
+      active_tree()->top_controls_shown_ratio()->PullDeltaForMainThread();
   scroll_info->elastic_overscroll_delta =
       active_tree_->elastic_overscroll()->PullDeltaForMainThread();
   scroll_info->swap_promises.swap(swap_promises_for_main_thread_scroll_update_);
-  scroll_info->top_controls_delta = active_tree()->top_controls_delta();
-  active_tree_->set_sent_top_controls_delta(scroll_info->top_controls_delta);
 
   return scroll_info.Pass();
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage() {
   SetViewportDamage(gfx::Rect(DrawViewportSize()));
 }
 
 void LayerTreeHostImpl::ScrollViewportInnerFirst(gfx::Vector2dF scroll_delta) {
   DCHECK(InnerViewportScrollLayer());
@@ skipping 198 matching lines @@
   // Try to use the current frame time to keep animations non-jittery.  But if
   // we're not in a frame (because this is during an input event or a delayed
   // task), fall back to physical time.  This should still be monotonic.
   if (current_begin_frame_args_.IsValid())
     return current_begin_frame_args_;
   return BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, gfx::FrameTime::Now(), base::TimeTicks(),
       BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL);
 }
 
-scoped_refptr<base::debug::ConvertableToTraceFormat>
+scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 LayerTreeHostImpl::AsValue() const {
   return AsValueWithFrame(NULL);
 }
 
-scoped_refptr<base::debug::ConvertableToTraceFormat>
+scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 LayerTreeHostImpl::AsValueWithFrame(FrameData* frame) const {
-  scoped_refptr<base::debug::TracedValue> state =
-      new base::debug::TracedValue();
+  scoped_refptr<base::trace_event::TracedValue> state =
+      new base::trace_event::TracedValue();
   AsValueWithFrameInto(frame, state.get());
   return state;
 }
 
-void LayerTreeHostImpl::AsValueInto(base::debug::TracedValue* value) const {
+void LayerTreeHostImpl::AsValueInto(
+    base::trace_event::TracedValue* value) const {
   return AsValueWithFrameInto(NULL, value);
 }
 
 void LayerTreeHostImpl::AsValueWithFrameInto(
     FrameData* frame,
-    base::debug::TracedValue* state) const {
+    base::trace_event::TracedValue* state) const {
   if (this->pending_tree_) {
     state->BeginDictionary("activation_state");
     ActivationStateAsValueInto(state);
     state->EndDictionary();
   }
   MathUtil::AddToTracedValue("device_viewport_size", device_viewport_size_,
                              state);
 
   std::set<const Tile*> tiles;
   active_tree_->GetAllTilesForTracing(&tiles);
@@ skipping 25 matching lines @@
     pending_tree_->AsValueInto(state);
     state->EndDictionary();
   }
   if (frame) {
     state->BeginDictionary("frame");
     frame->AsValueInto(state);
     state->EndDictionary();
   }
 }
 
-scoped_refptr<base::debug::ConvertableToTraceFormat>
+scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 LayerTreeHostImpl::ActivationStateAsValue() const {
-  scoped_refptr<base::debug::TracedValue> state =
-      new base::debug::TracedValue();
+  scoped_refptr<base::trace_event::TracedValue> state =
+      new base::trace_event::TracedValue();
   ActivationStateAsValueInto(state.get());
   return state;
 }
 
 void LayerTreeHostImpl::ActivationStateAsValueInto(
-    base::debug::TracedValue* state) const {
+    base::trace_event::TracedValue* state) const {
   TracedValue::SetIDRef(this, state, "lthi");
   if (tile_manager_) {
     state->BeginDictionary("tile_manager");
     tile_manager_->BasicStateAsValueInto(state);
     state->EndDictionary();
   }
 }
 
 void LayerTreeHostImpl::SetDebugState(
     const LayerTreeDebugState& new_debug_state) {
@@ skipping 132 matching lines @@
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfForwardingToMainThread() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnForwardScrollUpdateToMainThreadOnImpl();
 }
 
-void LayerTreeHostImpl::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
-  DCHECK(std::find(picture_layers_.begin(), picture_layers_.end(), layer) ==
-         picture_layers_.end());
-  picture_layers_.push_back(layer);
-}
-
-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