Remove parts of //cc we aren't using

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 <map>
-
-#include "base/basictypes.h"
-#include "base/containers/hash_tables.h"
-#include "base/json/json_writer.h"
-#include "base/metrics/histogram.h"
-#include "base/stl_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "cc/animation/animation_id_provider.h"
-#include "cc/animation/scroll_offset_animation_curve.h"
-#include "cc/animation/scrollbar_animation_controller.h"
-#include "cc/animation/timing_function.h"
-#include "cc/base/math_util.h"
-#include "cc/base/util.h"
-#include "cc/debug/benchmark_instrumentation.h"
-#include "cc/debug/debug_rect_history.h"
-#include "cc/debug/devtools_instrumentation.h"
-#include "cc/debug/frame_rate_counter.h"
-#include "cc/debug/frame_viewer_instrumentation.h"
-#include "cc/debug/paint_time_counter.h"
-#include "cc/debug/rendering_stats_instrumentation.h"
-#include "cc/debug/traced_value.h"
-#include "cc/input/page_scale_animation.h"
-#include "cc/input/scroll_elasticity_helper.h"
-#include "cc/input/top_controls_manager.h"
-#include "cc/layers/append_quads_data.h"
-#include "cc/layers/heads_up_display_layer_impl.h"
-#include "cc/layers/layer_impl.h"
-#include "cc/layers/layer_iterator.h"
-#include "cc/layers/painted_scrollbar_layer_impl.h"
-#include "cc/layers/render_surface_impl.h"
-#include "cc/layers/scrollbar_layer_impl_base.h"
-#include "cc/output/compositor_frame_metadata.h"
-#include "cc/output/copy_output_request.h"
-#include "cc/output/delegating_renderer.h"
-#include "cc/output/gl_renderer.h"
-#include "cc/output/software_renderer.h"
-#include "cc/quads/render_pass_draw_quad.h"
-#include "cc/quads/shared_quad_state.h"
-#include "cc/quads/solid_color_draw_quad.h"
-#include "cc/quads/texture_draw_quad.h"
-#include "cc/resources/bitmap_tile_task_worker_pool.h"
-#include "cc/resources/eviction_tile_priority_queue.h"
-#include "cc/resources/gpu_rasterizer.h"
-#include "cc/resources/gpu_tile_task_worker_pool.h"
-#include "cc/resources/memory_history.h"
-#include "cc/resources/one_copy_tile_task_worker_pool.h"
-#include "cc/resources/picture_layer_tiling.h"
-#include "cc/resources/pixel_buffer_tile_task_worker_pool.h"
-#include "cc/resources/prioritized_resource_manager.h"
-#include "cc/resources/raster_tile_priority_queue.h"
-#include "cc/resources/resource_pool.h"
-#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/latency_info_swap_promise_monitor.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/single_thread_proxy.h"
-#include "cc/trees/tree_synchronizer.h"
-#include "gpu/GLES2/gl2extchromium.h"
-#include "gpu/command_buffer/client/gles2_interface.h"
-#include "ui/gfx/frame_time.h"
-#include "ui/gfx/geometry/rect_conversions.h"
-#include "ui/gfx/geometry/scroll_offset.h"
-#include "ui/gfx/geometry/size_conversions.h"
-#include "ui/gfx/geometry/vector2d_conversions.h"
-
-namespace cc {
-namespace {
-
-// Small helper class that saves the current viewport location as the user sees
-// it and resets to the same location.
-class ViewportAnchor {
- public:
-  ViewportAnchor(LayerImpl* inner_scroll, LayerImpl* outer_scroll)
-  : inner_(inner_scroll),
-    outer_(outer_scroll) {
-    viewport_in_content_coordinates_ = inner_->CurrentScrollOffset();
-
-    if (outer_)
-      viewport_in_content_coordinates_ += outer_->CurrentScrollOffset();
-  }
-
-  void ResetViewportToAnchoredPosition() {
-    DCHECK(outer_);
-
-    inner_->ClampScrollToMaxScrollOffset();
-    outer_->ClampScrollToMaxScrollOffset();
-
-    gfx::ScrollOffset viewport_location =
-        inner_->CurrentScrollOffset() + outer_->CurrentScrollOffset();
-
-    gfx::Vector2dF delta =
-        viewport_in_content_coordinates_.DeltaFrom(viewport_location);
-
-    delta = outer_->ScrollBy(delta);
-    inner_->ScrollBy(delta);
-  }
-
- private:
-  LayerImpl* inner_;
-  LayerImpl* outer_;
-  gfx::ScrollOffset viewport_in_content_coordinates_;
-};
-
-void DidVisibilityChange(LayerTreeHostImpl* id, bool visible) {
-  if (visible) {
-    TRACE_EVENT_ASYNC_BEGIN1("cc", "LayerTreeHostImpl::SetVisible", id,
-                             "LayerTreeHostImpl", id);
-    return;
-  }
-
-  TRACE_EVENT_ASYNC_END0("cc", "LayerTreeHostImpl::SetVisible", id);
-}
-
-size_t GetMaxTransferBufferUsageBytes(
-    const ContextProvider::Capabilities& context_capabilities,
-    double refresh_rate) {
-  // We want to make sure the default transfer buffer size is equal to the
-  // amount of data that can be uploaded by the compositor to avoid stalling
-  // the pipeline.
-  // For reference Chromebook Pixel can upload 1MB in about 0.5ms.
-  const size_t kMaxBytesUploadedPerMs = 1024 * 1024 * 2;
-
-  // We need to upload at least enough work to keep the GPU process busy until
-  // the next time it can handle a request to start more uploads from the
-  // compositor. We assume that it will pick up any sent upload requests within
-  // the time of a vsync, since the browser will want to swap a frame within
-  // that time interval, and then uploads should have a chance to be processed.
-  size_t ms_per_frame = std::floor(1000.0 / refresh_rate);
-  size_t max_transfer_buffer_usage_bytes =
-      ms_per_frame * kMaxBytesUploadedPerMs;
-
-  // The context may request a lower limit based on the device capabilities.
-  return std::min(context_capabilities.max_transfer_buffer_usage_bytes,
-                  max_transfer_buffer_usage_bytes);
-}
-
-size_t GetMaxStagingResourceCount() {
-  // Upper bound for number of staging resource to allow.
-  return 32;
-}
-
-}  // namespace
-
-LayerTreeHostImpl::FrameData::FrameData() : has_no_damage(false) {
-}
-
-LayerTreeHostImpl::FrameData::~FrameData() {}
-
-scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::Create(
-    const LayerTreeSettings& settings,
-    LayerTreeHostImplClient* client,
-    Proxy* proxy,
-    RenderingStatsInstrumentation* rendering_stats_instrumentation,
-    SharedBitmapManager* shared_bitmap_manager,
-    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    TaskGraphRunner* task_graph_runner,
-    int id) {
-  return make_scoped_ptr(new LayerTreeHostImpl(
-      settings, client, proxy, rendering_stats_instrumentation,
-      shared_bitmap_manager, gpu_memory_buffer_manager, task_graph_runner, id));
-}
-
-LayerTreeHostImpl::LayerTreeHostImpl(
-    const LayerTreeSettings& settings,
-    LayerTreeHostImplClient* client,
-    Proxy* proxy,
-    RenderingStatsInstrumentation* rendering_stats_instrumentation,
-    SharedBitmapManager* shared_bitmap_manager,
-    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    TaskGraphRunner* task_graph_runner,
-    int id)
-    : client_(client),
-      proxy_(proxy),
-      use_gpu_rasterization_(false),
-      gpu_rasterization_status_(GpuRasterizationStatus::OFF_DEVICE),
-      input_handler_client_(NULL),
-      did_lock_scrolling_layer_(false),
-      should_bubble_scrolls_(false),
-      wheel_scrolling_(false),
-      scroll_affects_scroll_handler_(false),
-      scroll_layer_id_when_mouse_over_scrollbar_(0),
-      tile_priorities_dirty_(false),
-      root_layer_scroll_offset_delegate_(NULL),
-      settings_(settings),
-      visible_(true),
-      cached_managed_memory_policy_(
-          PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
-          gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
-          ManagedMemoryPolicy::kDefaultNumResourcesLimit),
-      pinch_gesture_active_(false),
-      pinch_gesture_end_should_clear_scrolling_layer_(false),
-      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),
-      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),
-      task_graph_runner_(task_graph_runner),
-      id_(id),
-      requires_high_res_to_draw_(false),
-      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 SyncedTopControls, new SyncedElasticOverscroll);
-
-  TRACE_EVENT_OBJECT_CREATED_WITH_ID(
-      TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
-
-  top_controls_manager_ =
-      TopControlsManager::Create(this,
-                                 settings.top_controls_show_threshold,
-                                 settings.top_controls_hide_threshold);
-}
-
-LayerTreeHostImpl::~LayerTreeHostImpl() {
-  DCHECK(proxy_->IsImplThread());
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
-  TRACE_EVENT_OBJECT_DELETED_WITH_ID(
-      TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
-
-  if (input_handler_client_) {
-    input_handler_client_->WillShutdown();
-    input_handler_client_ = NULL;
-  }
-  if (scroll_elasticity_helper_)
-    scroll_elasticity_helper_.reset();
-
-  // The layer trees must be destroyed before the layer tree host. We've
-  // made a contract with our animation controllers that the registrar
-  // will outlive them, and we must make good.
-  if (recycle_tree_)
-    recycle_tree_->Shutdown();
-  if (pending_tree_)
-    pending_tree_->Shutdown();
-  active_tree_->Shutdown();
-  recycle_tree_ = nullptr;
-  pending_tree_ = nullptr;
-  active_tree_ = nullptr;
-  DestroyTileManager();
-}
-
-void LayerTreeHostImpl::BeginMainFrameAborted(CommitEarlyOutReason reason) {
-  // If the begin frame data was handled, then scroll and scale set was applied
-  // by the main thread, so the active tree needs to be updated as if these sent
-  // values were applied and committed.
-  if (CommitEarlyOutHandledCommit(reason)) {
-    active_tree_->ApplySentScrollAndScaleDeltasFromAbortedCommit();
-    active_tree_->ResetContentsTexturesPurged();
-  }
-}
-
-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 (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
-    // opportunity to create tilings.  Other paths can call UpdateDrawProperties
-    // more lazily when needed prior to drawing.  Because invalidations may
-    // be coming from the main thread, it's safe to do an update for lcd text
-    // at this point and see if lcd text needs to be disabled on any layers.
-    bool update_lcd_text = true;
-    sync_tree()->UpdateDrawProperties(update_lcd_text);
-    // Start working on newly created tiles immediately if needed.
-    if (tile_manager_ && tile_priorities_dirty_)
-      PrepareTiles();
-    else
-      NotifyReadyToActivate();
-  } else {
-    // If we're not in impl-side painting, the tree is immediately considered
-    // active.
-    ActivateSyncTree();
-  }
-
-  micro_benchmark_controller_.DidCompleteCommit();
-}
-
-bool LayerTreeHostImpl::CanDraw() const {
-  // Note: If you are changing this function or any other function that might
-  // affect the result of CanDraw, make sure to call
-  // client_->OnCanDrawStateChanged in the proper places and update the
-  // NotifyIfCanDrawChanged test.
-
-  if (!renderer_) {
-    TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer",
-                         TRACE_EVENT_SCOPE_THREAD);
-    return false;
-  }
-
-  // Must have an OutputSurface if |renderer_| is not NULL.
-  DCHECK(output_surface_);
-
-  // TODO(boliu): Make draws without root_layer work and move this below
-  // draw_and_swap_full_viewport_every_frame check. Tracked in crbug.com/264967.
-  if (!active_tree_->root_layer()) {
-    TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer",
-                         TRACE_EVENT_SCOPE_THREAD);
-    return false;
-  }
-
-  if (output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
-    return true;
-
-  if (DrawViewportSize().IsEmpty()) {
-    TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw empty viewport",
-                         TRACE_EVENT_SCOPE_THREAD);
-    return false;
-  }
-  if (active_tree_->ViewportSizeInvalid()) {
-    TRACE_EVENT_INSTANT0(
-        "cc", "LayerTreeHostImpl::CanDraw viewport size recently changed",
-        TRACE_EVENT_SCOPE_THREAD);
-    return false;
-  }
-  if (active_tree_->ContentsTexturesPurged()) {
-    TRACE_EVENT_INSTANT0(
-        "cc", "LayerTreeHostImpl::CanDraw contents textures purged",
-        TRACE_EVENT_SCOPE_THREAD);
-    return false;
-  }
-  if (EvictedUIResourcesExist()) {
-    TRACE_EVENT_INSTANT0(
-        "cc", "LayerTreeHostImpl::CanDraw UI resources evicted not recreated",
-        TRACE_EVENT_SCOPE_THREAD);
-    return false;
-  }
-  return true;
-}
-
-void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time) {
-  if (input_handler_client_)
-    input_handler_client_->Animate(monotonic_time);
-  AnimatePageScale(monotonic_time);
-  AnimateLayers(monotonic_time);
-  AnimateScrollbars(monotonic_time);
-  AnimateTopControls(monotonic_time);
-}
-
-void LayerTreeHostImpl::PrepareTiles() {
-  if (!tile_manager_)
-    return;
-  if (!tile_priorities_dirty_)
-    return;
-
-  tile_priorities_dirty_ = false;
-  tile_manager_->PrepareTiles(global_tile_state_);
-
-  client_->DidPrepareTiles();
-}
-
-void LayerTreeHostImpl::StartPageScaleAnimation(
-    const gfx::Vector2d& target_offset,
-    bool anchor_point,
-    float page_scale,
-    base::TimeDelta duration) {
-  if (!InnerViewportScrollLayer())
-    return;
-
-  gfx::ScrollOffset scroll_total = active_tree_->TotalScrollOffset();
-  gfx::SizeF scaled_scrollable_size = active_tree_->ScrollableSize();
-  gfx::SizeF viewport_size =
-      active_tree_->InnerViewportContainerLayer()->bounds();
-
-  // Easing constants experimentally determined.
-  scoped_ptr<TimingFunction> timing_function =
-      CubicBezierTimingFunction::Create(.8, 0, .3, .9);
-
-  // TODO(miletus) : Pass in ScrollOffset.
-  page_scale_animation_ = PageScaleAnimation::Create(
-      ScrollOffsetToVector2dF(scroll_total),
-      active_tree_->current_page_scale_factor(), viewport_size,
-      scaled_scrollable_size, timing_function.Pass());
-
-  if (anchor_point) {
-    gfx::Vector2dF anchor(target_offset);
-    page_scale_animation_->ZoomWithAnchor(anchor,
-                                          page_scale,
-                                          duration.InSecondsF());
-  } else {
-    gfx::Vector2dF scaled_target_offset = target_offset;
-    page_scale_animation_->ZoomTo(scaled_target_offset,
-                                  page_scale,
-                                  duration.InSecondsF());
-  }
-
-  SetNeedsAnimate();
-  client_->SetNeedsCommitOnImplThread();
-  client_->RenewTreePriority();
-}
-
-bool LayerTreeHostImpl::IsCurrentlyScrollingLayerAt(
-    const gfx::Point& viewport_point,
-    InputHandler::ScrollInputType type) {
-  if (!CurrentlyScrollingLayer())
-    return false;
-
-  gfx::PointF device_viewport_point =
-      gfx::ScalePoint(viewport_point, device_scale_factor_);
-
-  LayerImpl* layer_impl =
-      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
-
-  bool scroll_on_main_thread = false;
-  LayerImpl* scrolling_layer_impl = FindScrollLayerForDeviceViewportPoint(
-      device_viewport_point, type, layer_impl, &scroll_on_main_thread, NULL);
-  return CurrentlyScrollingLayer() == scrolling_layer_impl;
-}
-
-bool LayerTreeHostImpl::HaveWheelEventHandlersAt(
-    const gfx::Point& viewport_point) {
-  gfx::PointF device_viewport_point =
-      gfx::ScalePoint(viewport_point, device_scale_factor_);
-
-  LayerImpl* layer_impl =
-      active_tree_->FindLayerWithWheelHandlerThatIsHitByPoint(
-          device_viewport_point);
-
-  return layer_impl != NULL;
-}
-
-static LayerImpl* NextScrollLayer(LayerImpl* layer) {
-  if (LayerImpl* scroll_parent = layer->scroll_parent())
-    return scroll_parent;
-  return layer->parent();
-}
-
-static ScrollBlocksOn EffectiveScrollBlocksOn(LayerImpl* layer) {
-  ScrollBlocksOn blocks = SCROLL_BLOCKS_ON_NONE;
-  for (; layer; layer = NextScrollLayer(layer)) {
-    blocks |= layer->scroll_blocks_on();
-  }
-  return blocks;
-}
-
-bool LayerTreeHostImpl::DoTouchEventsBlockScrollAt(
-    const gfx::Point& viewport_point) {
-  gfx::PointF device_viewport_point =
-      gfx::ScalePoint(viewport_point, device_scale_factor_);
-
-  // First check if scrolling at this point is required to block on any
-  // touch event handlers.  Note that we must start at the innermost layer
-  // (as opposed to only the layer found to contain a touch handler region
-  // below) to ensure all relevant scroll-blocks-on values are applied.
-  LayerImpl* layer_impl =
-      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
-  ScrollBlocksOn blocking = EffectiveScrollBlocksOn(layer_impl);
-  if (!(blocking & SCROLL_BLOCKS_ON_START_TOUCH))
-    return false;
-
-  // Now determine if there are actually any handlers at that point.
-  // TODO(rbyers): Consider also honoring touch-action (crbug.com/347272).
-  layer_impl = active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
-      device_viewport_point);
-  return layer_impl != NULL;
-}
-
-scoped_ptr<SwapPromiseMonitor>
-LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
-    ui::LatencyInfo* latency) {
-  return make_scoped_ptr(
-      new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
-}
-
-ScrollElasticityHelper* LayerTreeHostImpl::CreateScrollElasticityHelper() {
-  DCHECK(!scroll_elasticity_helper_);
-  if (settings_.enable_elastic_overscroll) {
-    scroll_elasticity_helper_.reset(
-        ScrollElasticityHelper::CreateForLayerTreeHostImpl(this));
-  }
-  return scroll_elasticity_helper_.get();
-}
-
-void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
-    scoped_ptr<SwapPromise> swap_promise) {
-  swap_promises_for_main_thread_scroll_update_.push_back(swap_promise.Pass());
-}
-
-void LayerTreeHostImpl::TrackDamageForAllSurfaces(
-    LayerImpl* root_draw_layer,
-    const LayerImplList& render_surface_layer_list) {
-  // For now, we use damage tracking to compute a global scissor. To do this, we
-  // must compute all damage tracking before drawing anything, so that we know
-  // the root damage rect. The root damage rect is then used to scissor each
-  // surface.
-
-  for (int surface_index = render_surface_layer_list.size() - 1;
-       surface_index >= 0;
-       --surface_index) {
-    LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
-    RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
-    DCHECK(render_surface);
-    render_surface->damage_tracker()->UpdateDamageTrackingState(
-        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::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) {
-      value->BeginDictionary();
-      render_passes[i]->AsValueInto(value);
-      value->EndDictionary();
-    }
-    value->EndArray();
-  }
-}
-
-void LayerTreeHostImpl::FrameData::AppendRenderPass(
-    scoped_ptr<RenderPass> render_pass) {
-  render_passes_by_id[render_pass->id] = render_pass.get();
-  render_passes.push_back(render_pass.Pass());
-}
-
-DrawMode LayerTreeHostImpl::GetDrawMode() const {
-  if (resourceless_software_draw_) {
-    return DRAW_MODE_RESOURCELESS_SOFTWARE;
-  } else if (output_surface_->context_provider()) {
-    return DRAW_MODE_HARDWARE;
-  } 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 AppendQuadsForRenderSurfaceLayer(
-    RenderPass* target_render_pass,
-    LayerImpl* layer,
-    const RenderPass* contributing_render_pass,
-    AppendQuadsData* append_quads_data) {
-  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()) {
-    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 Region& fill_region) {
-  if (!root_layer || !SkColorGetA(screen_background_color))
-    return;
-  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;
-  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(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);
-  }
-}
-
-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);
-
-  // If the root render surface has no visible damage, then don't generate a
-  // frame at all.
-  RenderSurfaceImpl* root_surface =
-      active_tree_->root_layer()->render_surface();
-  bool root_surface_has_no_visible_damage =
-      !root_surface->damage_tracker()->current_damage_rect().Intersects(
-          root_surface->content_rect());
-  bool root_surface_has_contributing_layers =
-      !root_surface->layer_list().empty();
-  bool hud_wants_to_draw_ = active_tree_->hud_layer() &&
-                            active_tree_->hud_layer()->IsAnimatingHUDContents();
-  if (root_surface_has_contributing_layers &&
-      root_surface_has_no_visible_damage &&
-      active_tree_->LayersWithCopyOutputRequest().empty() &&
-      !output_surface_->capabilities().can_force_reclaim_resources &&
-      !hud_wants_to_draw_) {
-    TRACE_EVENT0("cc",
-                 "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
-    frame->has_no_damage = true;
-    DCHECK(!output_surface_->capabilities()
-               .draw_and_swap_full_viewport_every_frame);
-    return DRAW_SUCCESS;
-  }
-
-  TRACE_EVENT_BEGIN2(
-      "cc", "LayerTreeHostImpl::CalculateRenderPasses",
-      "render_surface_layer_list.size()",
-      static_cast<uint64>(frame->render_surface_layer_list->size()),
-      "RequiresHighResToDraw", RequiresHighResToDraw());
-
-  // Create the render passes in dependency order.
-  for (int surface_index = frame->render_surface_layer_list->size() - 1;
-       surface_index >= 0;
-       --surface_index) {
-    LayerImpl* render_surface_layer =
-        (*frame->render_surface_layer_list)[surface_index];
-    RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
-
-    bool should_draw_into_render_pass =
-        render_surface_layer->parent() == NULL ||
-        render_surface->contributes_to_drawn_surface() ||
-        render_surface_layer->HasCopyRequest();
-    if (should_draw_into_render_pass)
-      render_surface->AppendRenderPasses(frame);
-  }
-
-  // When we are displaying the HUD, change the root damage rect to cover the
-  // 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;
-  }
-
-  // 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;
-
-  int layers_drawn = 0;
-
-  const DrawMode draw_mode = GetDrawMode();
-
-  int num_missing_tiles = 0;
-  int num_incomplete_tiles = 0;
-  bool have_copy_request = false;
-  bool have_missing_animated_tiles = false;
-
-  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];
-
-    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,
-                                       &append_quads_data);
-    } else if (it.represents_itself() &&
-               !it->visible_content_rect().IsEmpty()) {
-      bool occluded =
-          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];
-
-            it->AppendQuads(render_pass, &append_quads_data);
-
-            contributing_render_pass_id =
-                it->NextContributingRenderPassId(contributing_render_pass_id);
-          }
-        }
-
-        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()));
-          }
-        }
-      }
-
-      ++layers_drawn;
-    }
-
-    rendering_stats_instrumentation_->AddVisibleContentArea(
-        append_quads_data.visible_content_area);
-    rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
-        append_quads_data.approximated_visible_content_area);
-
-    num_missing_tiles += append_quads_data.num_missing_tiles;
-    num_incomplete_tiles += append_quads_data.num_incomplete_tiles;
-
-    if (append_quads_data.num_missing_tiles) {
-      bool layer_has_animating_transform =
-          it->screen_space_transform_is_animating() ||
-          it->draw_transform_is_animating();
-      if (layer_has_animating_transform)
-        have_missing_animated_tiles = true;
-    }
-  }
-
-  if (have_missing_animated_tiles)
-    draw_result = DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
-
-  // When we have a copy request for a layer, we need to draw even if there
-  // would be animating checkerboards, because failing under those conditions
-  // triggers a new main frame, which may cause the copy request layer to be
-  // destroyed.
-  // TODO(danakj): Leaking scheduler internals into LayerTreeHostImpl here.
-  if (have_copy_request)
-    draw_result = DRAW_SUCCESS;
-
-  // When we require high res to draw, abort the draw (almost) always. This does
-  // not cause the scheduler to do a main frame, instead it will continue to try
-  // drawing until we finally complete, so the copy request will not be lost.
-  if (num_incomplete_tiles || num_missing_tiles) {
-    if (RequiresHighResToDraw())
-      draw_result = DRAW_ABORTED_MISSING_HIGH_RES_CONTENT;
-  }
-
-  // When this capability is set we don't have control over the surface the
-  // compositor draws to, so even though the frame may not be complete, the
-  // previous frame has already been potentially lost, so an incomplete frame is
-  // better than nothing, so this takes highest precidence.
-  if (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(), 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();
-    layer->TakeCopyRequestsAndTransformToTarget(&requests_to_abort);
-  }
-  for (size_t i = 0; i < requests_to_abort.size(); ++i)
-    requests_to_abort[i]->SendEmptyResult();
-
-  // If we're making a frame to draw, it better have at least one render pass.
-  DCHECK(!frame->render_passes.empty());
-
-  if (active_tree_->has_ever_been_drawn()) {
-    UMA_HISTOGRAM_COUNTS_100(
-        "Compositing.RenderPass.AppendQuadData.NumMissingTiles",
-        num_missing_tiles);
-    UMA_HISTOGRAM_COUNTS_100(
-        "Compositing.RenderPass.AppendQuadData.NumIncompleteTiles",
-        num_incomplete_tiles);
-  }
-
-  // Should only have one render pass in resourceless software mode.
-  DCHECK(draw_mode != DRAW_MODE_RESOURCELESS_SOFTWARE ||
-         frame->render_passes.size() == 1u)
-      << frame->render_passes.size();
-
-  TRACE_EVENT_END2("cc", "LayerTreeHostImpl::CalculateRenderPasses",
-                   "draw_result", draw_result, "missing tiles",
-                   num_missing_tiles);
-
-  return draw_result;
-}
-
-void LayerTreeHostImpl::MainThreadHasStoppedFlinging() {
-  top_controls_manager_->MainThreadHasStoppedFlinging();
-  if (input_handler_client_)
-    input_handler_client_->MainThreadHasStoppedFlinging();
-}
-
-void LayerTreeHostImpl::DidAnimateScrollOffset() {
-  client_->SetNeedsCommitOnImplThread();
-  client_->RenewTreePriority();
-}
-
-void LayerTreeHostImpl::SetViewportDamage(const gfx::Rect& damage_rect) {
-  viewport_damage_rect_.Union(damage_rect);
-}
-
-static inline RenderPass* FindRenderPassById(
-    RenderPassId render_pass_id,
-    const LayerTreeHostImpl::FrameData& frame) {
-  RenderPassIdHashMap::const_iterator it =
-      frame.render_passes_by_id.find(render_pass_id);
-  return it != frame.render_passes_by_id.end() ? it->second : NULL;
-}
-
-static void RemoveRenderPassesRecursive(RenderPassId remove_render_pass_id,
-                                        LayerTreeHostImpl::FrameData* frame) {
-  RenderPass* remove_render_pass =
-      FindRenderPassById(remove_render_pass_id, *frame);
-  // The pass was already removed by another quad - probably the original, and
-  // we are the replica.
-  if (!remove_render_pass)
-    return;
-  RenderPassList& render_passes = frame->render_passes;
-  RenderPassList::iterator to_remove = std::find(render_passes.begin(),
-                                                 render_passes.end(),
-                                                 remove_render_pass);
-
-  DCHECK(to_remove != render_passes.end());
-
-  scoped_ptr<RenderPass> removed_pass = render_passes.take(to_remove);
-  frame->render_passes.erase(to_remove);
-  frame->render_passes_by_id.erase(remove_render_pass_id);
-
-  // Now follow up for all RenderPass quads and remove their RenderPasses
-  // recursively.
-  const QuadList& quad_list = removed_pass->quad_list;
-  for (auto quad_list_iterator = quad_list.BackToFrontBegin();
-       quad_list_iterator != quad_list.BackToFrontEnd();
-       ++quad_list_iterator) {
-    const DrawQuad* current_quad = *quad_list_iterator;
-    if (current_quad->material != DrawQuad::RENDER_PASS)
-      continue;
-
-    RenderPassId next_remove_render_pass_id =
-        RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id;
-    RemoveRenderPassesRecursive(next_remove_render_pass_id, frame);
-  }
-}
-
-bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::ShouldRemoveRenderPass(
-    const RenderPassDrawQuad& quad, const FrameData& frame) const {
-  const RenderPass* render_pass =
-      FindRenderPassById(quad.render_pass_id, frame);
-  if (!render_pass)
-    return false;
-
-  // If any quad or RenderPass draws into this RenderPass, then keep it.
-  const QuadList& quad_list = render_pass->quad_list;
-  for (auto quad_list_iterator = quad_list.BackToFrontBegin();
-       quad_list_iterator != quad_list.BackToFrontEnd();
-       ++quad_list_iterator) {
-    const DrawQuad* current_quad = *quad_list_iterator;
-
-    if (current_quad->material != DrawQuad::RENDER_PASS)
-      return false;
-
-    const RenderPass* contributing_pass = FindRenderPassById(
-        RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id, frame);
-    if (contributing_pass)
-      return false;
-  }
-  return true;
-}
-
-// Defined for linking tests.
-template CC_EXPORT void LayerTreeHostImpl::RemoveRenderPasses<
-  LayerTreeHostImpl::CullRenderPassesWithNoQuads>(
-      CullRenderPassesWithNoQuads culler, FrameData*);
-
-// static
-template <typename RenderPassCuller>
-void LayerTreeHostImpl::RemoveRenderPasses(RenderPassCuller culler,
-                                           FrameData* frame) {
-  for (size_t it = culler.RenderPassListBegin(frame->render_passes);
-       it != culler.RenderPassListEnd(frame->render_passes);
-       it = culler.RenderPassListNext(it)) {
-    const RenderPass* current_pass = frame->render_passes[it];
-    const QuadList& quad_list = current_pass->quad_list;
-
-    for (auto quad_list_iterator = quad_list.BackToFrontBegin();
-         quad_list_iterator != quad_list.BackToFrontEnd();
-         ++quad_list_iterator) {
-      const DrawQuad* current_quad = *quad_list_iterator;
-
-      if (current_quad->material != DrawQuad::RENDER_PASS)
-        continue;
-
-      const RenderPassDrawQuad* render_pass_quad =
-          RenderPassDrawQuad::MaterialCast(current_quad);
-      if (!culler.ShouldRemoveRenderPass(*render_pass_quad, *frame))
-        continue;
-
-      // We are changing the vector in the middle of iteration. Because we
-      // delete render passes that draw into the current pass, we are
-      // guaranteed that any data from the iterator to the end will not
-      // change. So, capture the iterator position from the end of the
-      // list, and restore it after the change.
-      size_t position_from_end = frame->render_passes.size() - it;
-      RemoveRenderPassesRecursive(render_pass_quad->render_pass_id, frame);
-      it = frame->render_passes.size() - position_from_end;
-      DCHECK_GE(frame->render_passes.size(), position_from_end);
-    }
-  }
-}
-
-DrawResult LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
-  TRACE_EVENT1("cc",
-               "LayerTreeHostImpl::PrepareToDraw",
-               "SourceFrameNumber",
-               active_tree_->source_frame_number());
-  if (input_handler_client_)
-    input_handler_client_->ReconcileElasticOverscrollAndRootScroll();
-
-  UMA_HISTOGRAM_CUSTOM_COUNTS(
-      "Compositing.NumActiveLayers", active_tree_->NumLayers(), 1, 400, 20);
-
-  bool update_lcd_text = false;
-  bool ok = active_tree_->UpdateDrawProperties(update_lcd_text);
-  DCHECK(ok) << "UpdateDrawProperties failed during draw";
-
-  // This will cause NotifyTileStateChanged() to be called for any visible tiles
-  // that completed, which will add damage to the frame for them so they appear
-  // as part of the current frame being drawn.
-  if (tile_manager_)
-    tile_manager_->UpdateVisibleTiles(global_tile_state_);
-
-  frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
-  frame->render_passes.clear();
-  frame->render_passes_by_id.clear();
-  frame->will_draw_layers.clear();
-  frame->has_no_damage = false;
-
-  if (active_tree_->root_layer()) {
-    gfx::Rect device_viewport_damage_rect = viewport_damage_rect_;
-    viewport_damage_rect_ = gfx::Rect();
-
-    active_tree_->root_layer()->render_surface()->damage_tracker()->
-        AddDamageNextUpdate(device_viewport_damage_rect);
-  }
-
-  DrawResult draw_result = CalculateRenderPasses(frame);
-  if (draw_result != DRAW_SUCCESS) {
-    DCHECK(!output_surface_->capabilities()
-               .draw_and_swap_full_viewport_every_frame);
-    return draw_result;
-  }
-
-  // If we return DRAW_SUCCESS, then we expect DrawLayers() to be called before
-  // this function is called again.
-  return draw_result;
-}
-
-void LayerTreeHostImpl::EvictTexturesForTesting() {
-  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()->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) {
-
-  bool evicted_resources = client_->ReduceContentsTextureMemoryOnImplThread(
-      visible_ ? policy.bytes_limit_when_visible : 0,
-      ManagedMemoryPolicy::PriorityCutoffToValue(
-          visible_ ? policy.priority_cutoff_when_visible
-                   : gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING));
-  if (evicted_resources) {
-    active_tree_->SetContentsTexturesPurged();
-    if (pending_tree_)
-      pending_tree_->SetContentsTexturesPurged();
-    client_->SetNeedsCommitOnImplThread();
-    client_->OnCanDrawStateChanged(CanDraw());
-    client_->RenewTreePriority();
-  }
-
-  UpdateTileManagerMemoryPolicy(policy);
-}
-
-void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy(
-    const ManagedMemoryPolicy& policy) {
-  if (!tile_manager_)
-    return;
-
-  global_tile_state_.hard_memory_limit_in_bytes = 0;
-  global_tile_state_.soft_memory_limit_in_bytes = 0;
-  if (visible_ && policy.bytes_limit_when_visible > 0) {
-    global_tile_state_.hard_memory_limit_in_bytes =
-        policy.bytes_limit_when_visible;
-    global_tile_state_.soft_memory_limit_in_bytes =
-        (static_cast<int64>(global_tile_state_.hard_memory_limit_in_bytes) *
-         settings_.max_memory_for_prepaint_percentage) /
-        100;
-  }
-  global_tile_state_.memory_limit_policy =
-      ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
-          visible_ ?
-          policy.priority_cutoff_when_visible :
-          gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING);
-  global_tile_state_.num_resources_limit = policy.num_resources_limit;
-
-  // TODO(reveman): We should avoid keeping around unused resources if
-  // possible. crbug.com/224475
-  // Unused limit is calculated from soft-limit, as hard-limit may
-  // be very high and shouldn't typically be exceeded.
-  size_t unused_memory_limit_in_bytes = static_cast<size_t>(
-      (static_cast<int64>(global_tile_state_.soft_memory_limit_in_bytes) *
-       settings_.max_unused_resource_memory_percentage) /
-      100);
-
-  DCHECK(resource_pool_);
-  resource_pool_->CheckBusyResources(false);
-  // Soft limit is used for resource pool such that memory returns to soft
-  // limit after going over.
-  resource_pool_->SetResourceUsageLimits(
-      global_tile_state_.soft_memory_limit_in_bytes,
-      unused_memory_limit_in_bytes,
-      global_tile_state_.num_resources_limit);
-
-  // Release all staging resources when invisible.
-  if (staging_resource_pool_) {
-    staging_resource_pool_->CheckBusyResources(false);
-    staging_resource_pool_->SetResourceUsageLimits(
-        std::numeric_limits<size_t>::max(),
-        std::numeric_limits<size_t>::max(),
-        visible_ ? GetMaxStagingResourceCount() : 0);
-  }
-
-  DidModifyTilePriorities();
-}
-
-void LayerTreeHostImpl::DidModifyTilePriorities() {
-  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 (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 = nullptr;
-    }
-    layer_pairs->push_back(PictureLayerImpl::Pair(layer, twin_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);
-  return RasterTilePriorityQueue::Create(picture_layer_pairs_, tree_priority,
-                                         type);
-}
-
-scoped_ptr<EvictionTilePriorityQueue> LayerTreeHostImpl::BuildEvictionQueue(
-    TreePriority tree_priority) {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildEvictionQueue");
-  scoped_ptr<EvictionTilePriorityQueue> queue(new EvictionTilePriorityQueue);
-  picture_layer_pairs_.clear();
-  GetPictureLayerImplPairs(&picture_layer_pairs_, false);
-  queue->Build(picture_layer_pairs_, tree_priority);
-  return queue;
-}
-
-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;
-}
-
-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;
-
-  client_->NotifyReadyToDraw();
-}
-
-void LayerTreeHostImpl::NotifyTileStateChanged(const Tile* tile) {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileStateChanged");
-
-  if (active_tree_) {
-    LayerImpl* layer_impl =
-        active_tree_->FindActiveTreeLayerById(tile->layer_id());
-    if (layer_impl)
-      layer_impl->NotifyTileStateChanged(tile);
-  }
-
-  if (pending_tree_) {
-    LayerImpl* layer_impl =
-        pending_tree_->FindPendingTreeLayerById(tile->layer_id());
-    if (layer_impl)
-      layer_impl->NotifyTileStateChanged(tile);
-  }
-
-  // Check for a non-null active tree to avoid doing this during shutdown.
-  if (active_tree_ && !client_->IsInsideDraw() && tile->required_for_draw()) {
-    // The LayerImpl::NotifyTileStateChanged() should damage the layer, so this
-    // redraw will make those tiles be displayed.
-    SetNeedsRedraw();
-  }
-}
-
-void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
-  SetManagedMemoryPolicy(policy, zero_budget_);
-}
-
-void LayerTreeHostImpl::SetTreeActivationCallback(
-    const base::Closure& callback) {
-  DCHECK(proxy_->IsImplThread());
-  DCHECK(settings_.impl_side_painting || callback.is_null());
-  tree_activation_callback_ = callback;
-}
-
-void LayerTreeHostImpl::SetManagedMemoryPolicy(
-    const ManagedMemoryPolicy& policy, bool zero_budget) {
-  if (cached_managed_memory_policy_ == policy && zero_budget_ == zero_budget)
-    return;
-
-  ManagedMemoryPolicy old_policy = ActualManagedMemoryPolicy();
-
-  cached_managed_memory_policy_ = policy;
-  zero_budget_ = zero_budget;
-  ManagedMemoryPolicy actual_policy = ActualManagedMemoryPolicy();
-
-  if (old_policy == actual_policy)
-    return;
-
-  if (!proxy_->HasImplThread()) {
-    // In single-thread mode, this can be called on the main thread by
-    // GLRenderer::OnMemoryAllocationChanged.
-    DebugScopedSetImplThread impl_thread(proxy_);
-    EnforceManagedMemoryPolicy(actual_policy);
-  } else {
-    DCHECK(proxy_->IsImplThread());
-    EnforceManagedMemoryPolicy(actual_policy);
-  }
-
-  // If there is already enough memory to draw everything imaginable and the
-  // new memory limit does not change this, then do not re-commit. Don't bother
-  // skipping commits if this is not visible (commits don't happen when not
-  // visible, there will almost always be a commit when this becomes visible).
-  bool needs_commit = true;
-  if (visible() &&
-      actual_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
-      old_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
-      actual_policy.priority_cutoff_when_visible ==
-          old_policy.priority_cutoff_when_visible) {
-    needs_commit = false;
-  }
-
-  if (needs_commit)
-    client_->SetNeedsCommitOnImplThread();
-}
-
-void LayerTreeHostImpl::SetExternalDrawConstraints(
-    const gfx::Transform& transform,
-    const gfx::Rect& viewport,
-    const gfx::Rect& clip,
-    const gfx::Rect& viewport_rect_for_tile_priority,
-    const gfx::Transform& transform_for_tile_priority,
-    bool resourceless_software_draw) {
-  gfx::Rect viewport_rect_for_tile_priority_in_view_space;
-  if (!resourceless_software_draw) {
-    gfx::Transform screen_to_view(gfx::Transform::kSkipInitialization);
-    if (transform_for_tile_priority.GetInverse(&screen_to_view)) {
-      // Convert from screen space to view space.
-      viewport_rect_for_tile_priority_in_view_space =
-          gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
-              screen_to_view, viewport_rect_for_tile_priority));
-    }
-  }
-
-  if (external_transform_ != transform || external_viewport_ != viewport ||
-      resourceless_software_draw_ != resourceless_software_draw ||
-      viewport_rect_for_tile_priority_ !=
-          viewport_rect_for_tile_priority_in_view_space) {
-    active_tree_->set_needs_update_draw_properties();
-  }
-
-  external_transform_ = transform;
-  external_viewport_ = viewport;
-  external_clip_ = clip;
-  viewport_rect_for_tile_priority_ =
-      viewport_rect_for_tile_priority_in_view_space;
-  resourceless_software_draw_ = resourceless_software_draw;
-}
-
-void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
-  if (damage_rect.IsEmpty())
-    return;
-  NotifySwapPromiseMonitorsOfSetNeedsRedraw();
-  client_->SetNeedsRedrawRectOnImplThread(damage_rect);
-}
-
-void LayerTreeHostImpl::DidSwapBuffers() {
-  client_->DidSwapBuffersOnImplThread();
-}
-
-void LayerTreeHostImpl::DidSwapBuffersComplete() {
-  client_->DidSwapBuffersCompleteOnImplThread();
-}
-
-void LayerTreeHostImpl::ReclaimResources(const CompositorFrameAck* ack) {
-  // TODO(piman): We may need to do some validation on this ack before
-  // processing it.
-  if (renderer_)
-    renderer_->ReceiveSwapBuffersAck(*ack);
-
-  // In OOM, we now might be able to release more resources that were held
-  // because they were exported.
-  if (tile_manager_) {
-    DCHECK(resource_pool_);
-
-    resource_pool_->CheckBusyResources(false);
-    resource_pool_->ReduceResourceUsage();
-  }
-  // If we're not visible, we likely released resources, so we want to
-  // aggressively flush here to make sure those DeleteTextures make it to the
-  // GPU process to free up the memory.
-  if (output_surface_->context_provider() && !visible_) {
-    output_surface_->context_provider()->ContextGL()->ShallowFlushCHROMIUM();
-  }
-}
-
-void LayerTreeHostImpl::OnCanDrawStateChangedForTree() {
-  client_->OnCanDrawStateChanged(CanDraw());
-}
-
-CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
-  CompositorFrameMetadata metadata;
-  metadata.device_scale_factor = device_scale_factor_;
-  metadata.page_scale_factor = active_tree_->current_page_scale_factor();
-  metadata.scrollable_viewport_size = active_tree_->ScrollableViewportSize();
-  metadata.root_layer_size = active_tree_->ScrollableSize();
-  metadata.min_page_scale_factor = active_tree_->min_page_scale_factor();
-  metadata.max_page_scale_factor = active_tree_->max_page_scale_factor();
-  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;
-}
-
-void LayerTreeHostImpl::DrawLayers(FrameData* frame,
-                                   base::TimeTicks frame_begin_time) {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
-  DCHECK(CanDraw());
-
-  if (!frame->composite_events.empty()) {
-    frame_timing_tracker_->SaveTimeStamps(frame_begin_time,
-                                          frame->composite_events);
-  }
-
-  if (frame->has_no_damage) {
-    TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
-    DCHECK(!output_surface_->capabilities()
-               .draw_and_swap_full_viewport_every_frame);
-    return;
-  }
-
-  DCHECK(!frame->render_passes.empty());
-
-  fps_counter_->SaveTimeStamp(frame_begin_time,
-                              !output_surface_->context_provider());
-  rendering_stats_instrumentation_->IncrementFrameCount(1);
-
-  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,
-        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());
-  }
-
-  bool is_new_trace;
-  TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
-  if (is_new_trace) {
-    if (pending_tree_) {
-      LayerTreeHostCommon::CallFunctionForSubtree(
-          pending_tree_->root_layer(),
-          [](LayerImpl* layer) { layer->DidBeginTracing(); });
-    }
-    LayerTreeHostCommon::CallFunctionForSubtree(
-        active_tree_->root_layer(),
-        [](LayerImpl* layer) { layer->DidBeginTracing(); });
-  }
-
-  {
-    TRACE_EVENT0("cc", "DrawLayers.FrameViewerTracing");
-    TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
-        frame_viewer_instrumentation::kCategoryLayerTree,
-        "cc::LayerTreeHostImpl", id_, AsValueWithFrame(frame));
-  }
-
-  const DrawMode draw_mode = GetDrawMode();
-
-  // Because the contents of the HUD depend on everything else in the frame, the
-  // contents of its texture are updated as the last thing before the frame is
-  // drawn.
-  if (active_tree_->hud_layer()) {
-    TRACE_EVENT0("cc", "DrawLayers.UpdateHudTexture");
-    active_tree_->hud_layer()->UpdateHudTexture(draw_mode,
-                                                resource_provider_.get());
-  }
-
-  if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE) {
-    bool disable_picture_quad_image_filtering =
-        IsActivelyScrolling() || animation_registrar_->needs_animate_layers();
-
-    scoped_ptr<SoftwareRenderer> temp_software_renderer =
-        SoftwareRenderer::Create(this, &settings_.renderer_settings,
-                                 output_surface_.get(), NULL);
-    temp_software_renderer->DrawFrame(&frame->render_passes,
-                                      device_scale_factor_,
-                                      DeviceViewport(),
-                                      DeviceClip(),
-                                      disable_picture_quad_image_filtering);
-  } else {
-    renderer_->DrawFrame(&frame->render_passes,
-                         device_scale_factor_,
-                         DeviceViewport(),
-                         DeviceClip(),
-                         false);
-  }
-  // The render passes should be consumed by the renderer.
-  DCHECK(frame->render_passes.empty());
-  frame->render_passes_by_id.clear();
-
-  // The next frame should start by assuming nothing has changed, and changes
-  // are noted as they occur.
-  // TODO(boliu): If we did a temporary software renderer frame, propogate the
-  // damage forward to the next frame.
-  for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
-    (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
-        DidDrawDamagedArea();
-  }
-  active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
-
-  active_tree_->set_has_ever_been_drawn(true);
-  devtools_instrumentation::DidDrawFrame(id_);
-  benchmark_instrumentation::IssueImplThreadRenderingStatsEvent(
-      rendering_stats_instrumentation_->impl_thread_rendering_stats());
-  rendering_stats_instrumentation_->AccumulateAndClearImplThreadStats();
-}
-
-void LayerTreeHostImpl::DidDrawAllLayers(const FrameData& frame) {
-  for (size_t i = 0; i < frame.will_draw_layers.size(); ++i)
-    frame.will_draw_layers[i]->DidDraw(resource_provider_.get());
-
-  // Once all layers have been drawn, pending texture uploads should no
-  // longer block future uploads.
-  resource_provider_->MarkPendingUploadsAsNonBlocking();
-}
-
-void LayerTreeHostImpl::FinishAllRendering() {
-  if (renderer_)
-    renderer_->Finish();
-}
-
-void LayerTreeHostImpl::SetUseGpuRasterization(bool use_gpu) {
-  if (use_gpu == use_gpu_rasterization_)
-    return;
-
-  // Note that this must happen first, in case the rest of the calls want to
-  // query the new state of |use_gpu_rasterization_|.
-  use_gpu_rasterization_ = use_gpu;
-
-  // Clean up and replace existing tile manager with another one that uses
-  // appropriate rasterizer.
-  ReleaseTreeResources();
-  if (tile_manager_) {
-    DestroyTileManager();
-    CreateAndSetTileManager();
-  }
-  RecreateTreeResources();
-
-  // We have released tilings for both active and pending tree.
-  // We would not have any content to draw until the pending tree is activated.
-  // Prevent the active tree from drawing until activation.
-  SetRequiresHighResToDraw();
-}
-
-const RendererCapabilitiesImpl&
-LayerTreeHostImpl::GetRendererCapabilities() const {
-  return renderer_->Capabilities();
-}
-
-bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
-  ResetRequiresHighResToDraw();
-  if (frame.has_no_damage) {
-    active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
-    return false;
-  }
-  CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
-  active_tree()->FinishSwapPromises(&metadata);
-  for (auto& latency : metadata.latency_info) {
-    TRACE_EVENT_FLOW_STEP0(
-        "input,benchmark",
-        "LatencyInfo.Flow",
-        TRACE_ID_DONT_MANGLE(latency.trace_id),
-        "SwapBuffers");
-    // Only add the latency component once for renderer swap, not the browser
-    // swap.
-    if (!latency.FindLatency(ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT,
-                             0, nullptr)) {
-      latency.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT,
-                               0, 0);
-    }
-  }
-  renderer_->SwapBuffers(metadata);
-  return true;
-}
-
-void LayerTreeHostImpl::WillBeginImplFrame(const BeginFrameArgs& args) {
-  // Sample the frame time now. This time will be used for updating animations
-  // when we draw.
-  UpdateCurrentBeginFrameArgs(args);
-  // Cache the begin impl frame interval
-  begin_impl_frame_interval_ = args.interval;
-
-  if (is_likely_to_require_a_draw_) {
-    // Optimistically schedule a draw. This will let us expect the tile manager
-    // to complete its work so that we can draw new tiles within the impl frame
-    // we are beginning now.
-    SetNeedsRedraw();
-  }
-}
-
-void LayerTreeHostImpl::UpdateViewportContainerSizes() {
-  LayerImpl* inner_container = active_tree_->InnerViewportContainerLayer();
-  LayerImpl* outer_container = active_tree_->OuterViewportContainerLayer();
-
-  if (!inner_container)
-    return;
-
-  // TODO(bokan): This code is currently specific to top controls. It should be
-  // made general. crbug.com/464814.
-  if (!TopControlsHeight()) {
-    if (outer_container)
-      outer_container->SetBoundsDelta(gfx::Vector2dF());
-
-    inner_container->SetBoundsDelta(gfx::Vector2dF());
-    active_tree_->InnerViewportScrollLayer()->SetBoundsDelta(gfx::Vector2dF());
-
-    return;
-  }
-
-  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 - 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();
-  float target_height = outer_container->BoundsForScrolling().width() /
-      aspect_ratio;
-  float current_outer_height = outer_container->BoundsForScrolling().height() -
-      outer_container->bounds_delta().y();
-  gfx::Vector2dF delta(0, target_height - current_outer_height);
-
-  outer_container->SetBoundsDelta(delta);
-  active_tree_->InnerViewportScrollLayer()->SetBoundsDelta(delta);
-
-  anchor.ResetViewportToAnchoredPosition();
-}
-
-void LayerTreeHostImpl::SynchronouslyInitializeAllTiles() {
-  // Only valid for the single-threaded non-scheduled/synchronous case
-  // using the zero copy raster worker pool.
-  if (tile_manager_)
-    single_thread_synchronous_task_graph_runner_->RunUntilIdle();
-}
-
-void LayerTreeHostImpl::DidLoseOutputSurface() {
-  if (resource_provider_)
-    resource_provider_->DidLoseOutputSurface();
-  client_->DidLoseOutputSurfaceOnImplThread();
-}
-
-bool LayerTreeHostImpl::HaveRootScrollLayer() const {
-  return !!InnerViewportScrollLayer();
-}
-
-LayerImpl* LayerTreeHostImpl::RootLayer() const {
-  return active_tree_->root_layer();
-}
-
-LayerImpl* LayerTreeHostImpl::InnerViewportScrollLayer() const {
-  return active_tree_->InnerViewportScrollLayer();
-}
-
-LayerImpl* LayerTreeHostImpl::OuterViewportScrollLayer() const {
-  return active_tree_->OuterViewportScrollLayer();
-}
-
-LayerImpl* LayerTreeHostImpl::CurrentlyScrollingLayer() const {
-  return active_tree_->CurrentlyScrollingLayer();
-}
-
-bool LayerTreeHostImpl::IsActivelyScrolling() const {
-  return (did_lock_scrolling_layer_ && CurrentlyScrollingLayer()) ||
-         (InnerViewportScrollLayer() &&
-          InnerViewportScrollLayer()->IsExternalFlingActive()) ||
-         (OuterViewportScrollLayer() &&
-          OuterViewportScrollLayer()->IsExternalFlingActive());
-}
-
-// Content layers can be either directly scrollable or contained in an outer
-// scrolling layer which applies the scroll transform. Given a content layer,
-// this function returns the associated scroll layer if any.
-static LayerImpl* FindScrollLayerForContentLayer(LayerImpl* layer_impl) {
-  if (!layer_impl)
-    return NULL;
-
-  if (layer_impl->scrollable())
-    return layer_impl;
-
-  if (layer_impl->DrawsContent() &&
-      layer_impl->parent() &&
-      layer_impl->parent()->scrollable())
-    return layer_impl->parent();
-
-  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());
-
-  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());
-    // Process any requests in the UI resource queue.  The request queue is
-    // given in LayerTreeHost::FinishCommitOnImplThread.  This must take place
-    // before the swap.
-    pending_tree_->ProcessUIResourceRequestQueue();
-
-    if (pending_tree_->needs_full_tree_sync()) {
-      active_tree_->SetRootLayer(
-          TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
-                                             active_tree_->DetachLayerTree(),
-                                             active_tree_.get()));
-    }
-    TreeSynchronizer::PushProperties(pending_tree_->root_layer(),
-                                     active_tree_->root_layer());
-    pending_tree_->PushPropertiesTo(active_tree_.get());
-
-    // 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_);
-
-    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 (!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 =
-        rendering_stats_instrumentation_->GetRenderingStats();
-    // TODO(hendrikw): This requires a different metric when we commit directly
-    // to the active tree.  See crbug.com/429311.
-    paint_time_counter_->SavePaintTime(
-        stats.commit_to_activate_duration.GetLastTimeDelta() +
-        stats.draw_duration.GetLastTimeDelta());
-  }
-
-  scoped_ptr<PendingPageScaleAnimation> pending_page_scale_animation =
-      active_tree_->TakePendingPageScaleAnimation();
-  if (pending_page_scale_animation) {
-    StartPageScaleAnimation(
-        pending_page_scale_animation->target_offset,
-        pending_page_scale_animation->use_anchor,
-        pending_page_scale_animation->scale,
-        pending_page_scale_animation->duration);
-  }
-}
-
-void LayerTreeHostImpl::SetVisible(bool visible) {
-  DCHECK(proxy_->IsImplThread());
-
-  if (visible_ == visible)
-    return;
-  visible_ = visible;
-  DidVisibilityChange(this, visible_);
-  EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
-
-  // If we just became visible, we have to ensure that we draw high res tiles,
-  // to prevent checkerboard/low res flashes.
-  if (visible_)
-    SetRequiresHighResToDraw();
-  else
-    EvictAllUIResources();
-
-  // Evict tiles immediately if invisible since this tab may never get another
-  // draw or timer tick.
-  if (!visible_)
-    PrepareTiles();
-
-  if (!renderer_)
-    return;
-
-  renderer_->SetVisible(visible);
-}
-
-void LayerTreeHostImpl::SetNeedsAnimate() {
-  NotifySwapPromiseMonitorsOfSetNeedsRedraw();
-  client_->SetNeedsAnimateOnImplThread();
-}
-
-void LayerTreeHostImpl::SetNeedsRedraw() {
-  NotifySwapPromiseMonitorsOfSetNeedsRedraw();
-  client_->SetNeedsRedrawOnImplThread();
-}
-
-ManagedMemoryPolicy LayerTreeHostImpl::ActualManagedMemoryPolicy() const {
-  ManagedMemoryPolicy actual = cached_managed_memory_policy_;
-  if (debug_state_.rasterize_only_visible_content) {
-    actual.priority_cutoff_when_visible =
-        gpu::MemoryAllocation::CUTOFF_ALLOW_REQUIRED_ONLY;
-  } else if (use_gpu_rasterization()) {
-    actual.priority_cutoff_when_visible =
-        gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
-  }
-
-  if (zero_budget_) {
-    actual.bytes_limit_when_visible = 0;
-  }
-
-  return actual;
-}
-
-size_t LayerTreeHostImpl::memory_allocation_limit_bytes() const {
-  return ActualManagedMemoryPolicy().bytes_limit_when_visible;
-}
-
-int LayerTreeHostImpl::memory_allocation_priority_cutoff() const {
-  return ManagedMemoryPolicy::PriorityCutoffToValue(
-      ActualManagedMemoryPolicy().priority_cutoff_when_visible);
-}
-
-void LayerTreeHostImpl::ReleaseTreeResources() {
-  active_tree_->ReleaseResources();
-  if (pending_tree_)
-    pending_tree_->ReleaseResources();
-  if (recycle_tree_)
-    recycle_tree_->ReleaseResources();
-
-  EvictAllUIResources();
-}
-
-void LayerTreeHostImpl::RecreateTreeResources() {
-  active_tree_->RecreateResources();
-  if (pending_tree_)
-    pending_tree_->RecreateResources();
-  if (recycle_tree_)
-    recycle_tree_->RecreateResources();
-}
-
-void LayerTreeHostImpl::CreateAndSetRenderer() {
-  DCHECK(!renderer_);
-  DCHECK(output_surface_);
-  DCHECK(resource_provider_);
-
-  if (output_surface_->capabilities().delegated_rendering) {
-    renderer_ = DelegatingRenderer::Create(this, &settings_.renderer_settings,
-                                           output_surface_.get(),
-                                           resource_provider_.get());
-  } else if (output_surface_->context_provider()) {
-    renderer_ = GLRenderer::Create(
-        this, &settings_.renderer_settings, output_surface_.get(),
-        resource_provider_.get(), texture_mailbox_deleter_.get(),
-        settings_.renderer_settings.highp_threshold_min);
-  } else if (output_surface_->software_device()) {
-    renderer_ = SoftwareRenderer::Create(this, &settings_.renderer_settings,
-                                         output_surface_.get(),
-                                         resource_provider_.get());
-  }
-  DCHECK(renderer_);
-
-  renderer_->SetVisible(visible_);
-  SetFullRootLayerDamage();
-
-  // See note in LayerTreeImpl::UpdateDrawProperties.  Renderer needs to be
-  // initialized to get max texture size.  Also, after releasing resources,
-  // trees need another update to generate new ones.
-  active_tree_->set_needs_update_draw_properties();
-  if (pending_tree_)
-    pending_tree_->set_needs_update_draw_properties();
-  client_->UpdateRendererCapabilitiesOnImplThread();
-}
-
-void LayerTreeHostImpl::CreateAndSetTileManager() {
-  DCHECK(!tile_manager_);
-  DCHECK(settings_.impl_side_painting);
-  DCHECK(output_surface_);
-  DCHECK(resource_provider_);
-
-  rasterizer_ = CreateRasterizer();
-  CreateResourceAndTileTaskWorkerPool(&tile_task_worker_pool_, &resource_pool_,
-                                      &staging_resource_pool_);
-  DCHECK(tile_task_worker_pool_);
-  DCHECK(resource_pool_);
-
-  base::SingleThreadTaskRunner* task_runner =
-      proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
-                              : proxy_->MainThreadTaskRunner();
-  DCHECK(task_runner);
-  size_t scheduled_raster_task_limit =
-      IsSynchronousSingleThreaded() ? std::numeric_limits<size_t>::max()
-                                    : settings_.scheduled_raster_task_limit;
-  tile_manager_ =
-      TileManager::Create(this, task_runner, resource_pool_.get(),
-                          tile_task_worker_pool_->AsTileTaskRunner(),
-                          rasterizer_.get(), scheduled_raster_task_limit);
-
-  UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
-}
-
-scoped_ptr<Rasterizer> LayerTreeHostImpl::CreateRasterizer() {
-  ContextProvider* context_provider = output_surface_->context_provider();
-  if (use_gpu_rasterization_ && context_provider) {
-    return GpuRasterizer::Create(context_provider, resource_provider_.get(),
-                                 settings_.use_distance_field_text,
-                                 settings_.threaded_gpu_rasterization_enabled,
-                                 settings_.gpu_rasterization_msaa_sample_count);
-  }
-  return SoftwareRasterizer::Create();
-}
-
-void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
-    scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
-    scoped_ptr<ResourcePool>* resource_pool,
-    scoped_ptr<ResourcePool>* staging_resource_pool) {
-  base::SingleThreadTaskRunner* task_runner =
-      proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
-                              : proxy_->MainThreadTaskRunner();
-  DCHECK(task_runner);
-
-  ContextProvider* context_provider = output_surface_->context_provider();
-  if (!context_provider) {
-    *resource_pool =
-        ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
-
-    *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
-        task_runner, task_graph_runner_, 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, task_graph_runner_,
-        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,
-        context_provider->ContextCapabilities().gpu.egl_image_external);
-
-    if (settings_.use_zero_copy || IsSynchronousSingleThreaded()) {
-      *resource_pool =
-          ResourcePool::Create(resource_provider_.get(), image_target);
-
-      TaskGraphRunner* task_graph_runner;
-      if (IsSynchronousSingleThreaded()) {
-        DCHECK(!single_thread_synchronous_task_graph_runner_);
-        single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner);
-        task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
-      } else {
-        task_graph_runner = task_graph_runner_;
-      }
-
-      *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create(
-          task_runner, task_graph_runner, resource_provider_.get());
-      return;
-    }
-
-    if (settings_.use_one_copy) {
-      // We need to create a staging resource pool when using copy rasterizer.
-      *staging_resource_pool =
-          ResourcePool::Create(resource_provider_.get(), image_target);
-      *resource_pool =
-          ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
-
-      *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
-          task_runner, task_graph_runner_, context_provider,
-          resource_provider_.get(), staging_resource_pool_.get());
-      return;
-    }
-  }
-
-  // Synchronous single-threaded mode depends on tiles being ready to
-  // draw when raster is complete.  Therefore, it must use one of zero
-  // copy, software raster, or GPU raster (in the branches above).
-  DCHECK(!IsSynchronousSingleThreaded());
-
-  *resource_pool = ResourcePool::Create(
-      resource_provider_.get(), GL_TEXTURE_2D);
-
-  *tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create(
-      task_runner, task_graph_runner_, context_provider,
-      resource_provider_.get(),
-      GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
-                                     settings_.renderer_settings.refresh_rate));
-}
-
-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::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) {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
-
-  // Since we will create a new resource provider, we cannot continue to use
-  // the old resources (i.e. render_surfaces and texture IDs). Clear them
-  // before we destroy the old resource provider.
-  ReleaseTreeResources();
-
-  // Note: order is important here.
-  renderer_ = nullptr;
-  DestroyTileManager();
-  resource_provider_ = nullptr;
-  output_surface_ = nullptr;
-
-  if (!output_surface->BindToClient(this)) {
-    // Avoid recreating tree resources because we might not have enough
-    // information to do this yet (eg. we don't have a TileManager at this
-    // point).
-    return false;
-  }
-
-  output_surface_ = output_surface.Pass();
-  resource_provider_ = ResourceProvider::Create(
-      output_surface_.get(), shared_bitmap_manager_, gpu_memory_buffer_manager_,
-      proxy_->blocking_main_thread_task_runner(),
-      settings_.renderer_settings.highp_threshold_min,
-      settings_.renderer_settings.use_rgba_4444_textures,
-      settings_.renderer_settings.texture_id_allocation_chunk_size);
-
-  if (output_surface_->capabilities().deferred_gl_initialization)
-    EnforceZeroBudget(true);
-
-  CreateAndSetRenderer();
-
-  if (settings_.impl_side_painting && settings_.raster_enabled)
-    CreateAndSetTileManager();
-  RecreateTreeResources();
-
-  // Initialize vsync parameters to sane values.
-  const base::TimeDelta display_refresh_interval =
-      base::TimeDelta::FromMicroseconds(
-          base::Time::kMicrosecondsPerSecond /
-          settings_.renderer_settings.refresh_rate);
-  CommitVSyncParameters(base::TimeTicks(), display_refresh_interval);
-
-  // TODO(brianderson): Don't use a hard-coded parent draw time.
-  base::TimeDelta parent_draw_time =
-      (!settings_.use_external_begin_frame_source &&
-       output_surface_->capabilities().adjust_deadline_for_parent)
-          ? BeginFrameArgs::DefaultEstimatedParentDrawTime()
-          : base::TimeDelta();
-  client_->SetEstimatedParentDrawTime(parent_draw_time);
-
-  int max_frames_pending = output_surface_->capabilities().max_frames_pending;
-  if (max_frames_pending <= 0)
-    max_frames_pending = OutputSurface::DEFAULT_MAX_FRAMES_PENDING;
-  client_->SetMaxSwapsPendingOnImplThread(max_frames_pending);
-  client_->OnCanDrawStateChanged(CanDraw());
-
-  // There will not be anything to draw here, so set high res
-  // to avoid checkerboards, typically when we are recovering
-  // from lost context.
-  SetRequiresHighResToDraw();
-
-  return true;
-}
-
-void LayerTreeHostImpl::CommitVSyncParameters(base::TimeTicks timebase,
-                                              base::TimeDelta interval) {
-  client_->CommitVSyncParameters(timebase, interval);
-}
-
-void LayerTreeHostImpl::DeferredInitialize() {
-  DCHECK(output_surface_->capabilities().deferred_gl_initialization);
-  DCHECK(settings_.impl_side_painting);
-  DCHECK(output_surface_->context_provider());
-
-  ReleaseTreeResources();
-  renderer_ = nullptr;
-  DestroyTileManager();
-
-  resource_provider_->InitializeGL();
-
-  CreateAndSetRenderer();
-  EnforceZeroBudget(false);
-  CreateAndSetTileManager();
-  RecreateTreeResources();
-
-  client_->SetNeedsCommitOnImplThread();
-}
-
-void LayerTreeHostImpl::ReleaseGL() {
-  DCHECK(output_surface_->capabilities().deferred_gl_initialization);
-  DCHECK(settings_.impl_side_painting);
-  DCHECK(output_surface_->context_provider());
-
-  ReleaseTreeResources();
-  renderer_ = nullptr;
-  DestroyTileManager();
-
-  resource_provider_->InitializeSoftware();
-  output_surface_->ReleaseContextProvider();
-
-  CreateAndSetRenderer();
-  EnforceZeroBudget(true);
-  CreateAndSetTileManager();
-  RecreateTreeResources();
-
-  client_->SetNeedsCommitOnImplThread();
-}
-
-void LayerTreeHostImpl::SetViewportSize(const gfx::Size& device_viewport_size) {
-  if (device_viewport_size == device_viewport_size_)
-    return;
-  TRACE_EVENT_INSTANT2("cc", "LayerTreeHostImpl::SetViewportSize",
-                       TRACE_EVENT_SCOPE_THREAD, "width",
-                       device_viewport_size.width(), "height",
-                       device_viewport_size.height());
-
-  if (pending_tree_)
-    active_tree_->SetViewportSizeInvalid();
-
-  device_viewport_size_ = device_viewport_size;
-
-  UpdateViewportContainerSizes();
-  client_->OnCanDrawStateChanged(CanDraw());
-  SetFullRootLayerDamage();
-  active_tree_->set_needs_update_draw_properties();
-}
-
-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);
-}
-
-const gfx::Rect LayerTreeHostImpl::ViewportRectForTilePriority() const {
-  if (viewport_rect_for_tile_priority_.IsEmpty())
-    return DeviceViewport();
-
-  return viewport_rect_for_tile_priority_;
-}
-
-gfx::Size LayerTreeHostImpl::DrawViewportSize() const {
-  return DeviceViewport().size();
-}
-
-gfx::Rect LayerTreeHostImpl::DeviceViewport() const {
-  if (external_viewport_.IsEmpty())
-    return gfx::Rect(device_viewport_size_);
-
-  return external_viewport_;
-}
-
-gfx::Rect LayerTreeHostImpl::DeviceClip() const {
-  if (external_clip_.IsEmpty())
-    return DeviceViewport();
-
-  return external_clip_;
-}
-
-const gfx::Transform& LayerTreeHostImpl::DrawTransform() const {
-  return external_transform_;
-}
-
-void LayerTreeHostImpl::DidChangeTopControlsPosition() {
-  UpdateViewportContainerSizes();
-  SetNeedsRedraw();
-  SetNeedsAnimate();
-  active_tree_->set_needs_update_draw_properties();
-  SetFullRootLayerDamage();
-}
-
-float LayerTreeHostImpl::TopControlsHeight() const {
-  return 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,
-    LayerImpl* layer_impl,
-    bool* scroll_on_main_thread,
-    bool* optional_has_ancestor_scroll_handler) const {
-  DCHECK(scroll_on_main_thread);
-
-  ScrollBlocksOn block_mode = EffectiveScrollBlocksOn(layer_impl);
-
-  // Walk up the hierarchy and look for a scrollable layer.
-  LayerImpl* potentially_scrolling_layer_impl = NULL;
-  for (; layer_impl; layer_impl = NextScrollLayer(layer_impl)) {
-    // The content layer can also block attempts to scroll outside the main
-    // thread.
-    ScrollStatus status =
-        layer_impl->TryScroll(device_viewport_point, type, block_mode);
-    if (status == SCROLL_ON_MAIN_THREAD) {
-      *scroll_on_main_thread = true;
-      return NULL;
-    }
-
-    LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
-    if (!scroll_layer_impl)
-      continue;
-
-    status =
-        scroll_layer_impl->TryScroll(device_viewport_point, type, block_mode);
-    // If any layer wants to divert the scroll event to the main thread, abort.
-    if (status == SCROLL_ON_MAIN_THREAD) {
-      *scroll_on_main_thread = true;
-      return NULL;
-    }
-
-    if (optional_has_ancestor_scroll_handler &&
-        scroll_layer_impl->have_scroll_event_handlers())
-      *optional_has_ancestor_scroll_handler = true;
-
-    if (status == SCROLL_STARTED && !potentially_scrolling_layer_impl)
-      potentially_scrolling_layer_impl = scroll_layer_impl;
-  }
-
-  // Falling back to the root scroll layer ensures generation of root overscroll
-  // notifications while preventing scroll updates from being unintentionally
-  // forwarded to the main thread.
-  if (!potentially_scrolling_layer_impl)
-    potentially_scrolling_layer_impl = OuterViewportScrollLayer()
-                                           ? OuterViewportScrollLayer()
-                                           : InnerViewportScrollLayer();
-
-  return potentially_scrolling_layer_impl;
-}
-
-// Similar to LayerImpl::HasAncestor, but walks up the scroll parents.
-static bool HasScrollAncestor(LayerImpl* child, LayerImpl* scroll_ancestor) {
-  DCHECK(scroll_ancestor);
-  for (LayerImpl* ancestor = child; ancestor;
-       ancestor = NextScrollLayer(ancestor)) {
-    if (ancestor->scrollable())
-      return ancestor == scroll_ancestor;
-  }
-  return false;
-}
-
-InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
-    const gfx::Point& viewport_point,
-    InputHandler::ScrollInputType type) {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
-
-  top_controls_manager_->ScrollBegin();
-
-  DCHECK(!CurrentlyScrollingLayer());
-  ClearCurrentlyScrollingLayer();
-
-  gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
-                                                      device_scale_factor_);
-  LayerImpl* layer_impl =
-      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
-
-  if (layer_impl) {
-    LayerImpl* scroll_layer_impl =
-        active_tree_->FindFirstScrollingLayerThatIsHitByPoint(
-            device_viewport_point);
-    if (scroll_layer_impl && !HasScrollAncestor(layer_impl, scroll_layer_impl))
-      return SCROLL_UNKNOWN;
-  }
-
-  bool scroll_on_main_thread = false;
-  LayerImpl* scrolling_layer_impl =
-      FindScrollLayerForDeviceViewportPoint(device_viewport_point,
-                                            type,
-                                            layer_impl,
-                                            &scroll_on_main_thread,
-                                            &scroll_affects_scroll_handler_);
-
-  if (scroll_on_main_thread) {
-    UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
-    return SCROLL_ON_MAIN_THREAD;
-  }
-
-  if (scrolling_layer_impl) {
-    active_tree_->SetCurrentlyScrollingLayer(scrolling_layer_impl);
-    should_bubble_scrolls_ = (type != NON_BUBBLING_GESTURE);
-    wheel_scrolling_ = (type == WHEEL);
-    client_->RenewTreePriority();
-    UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
-    return SCROLL_STARTED;
-  }
-  return SCROLL_IGNORED;
-}
-
-InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
-    const gfx::Point& viewport_point,
-    const gfx::Vector2dF& scroll_delta) {
-  if (LayerImpl* layer_impl = CurrentlyScrollingLayer()) {
-    return ScrollAnimationUpdateTarget(layer_impl, scroll_delta)
-               ? SCROLL_STARTED
-               : SCROLL_IGNORED;
-  }
-  // ScrollAnimated is only used for wheel scrolls. We use the same bubbling
-  // behavior as ScrollBy to determine which layer to animate, but we do not
-  // do the Android-specific things in ScrollBy like showing top controls.
-  InputHandler::ScrollStatus scroll_status = ScrollBegin(viewport_point, WHEEL);
-  if (scroll_status == SCROLL_STARTED) {
-    gfx::Vector2dF pending_delta = scroll_delta;
-    for (LayerImpl* layer_impl = CurrentlyScrollingLayer(); layer_impl;
-         layer_impl = layer_impl->parent()) {
-      if (!layer_impl->scrollable())
-        continue;
-
-      gfx::ScrollOffset current_offset = layer_impl->CurrentScrollOffset();
-      gfx::ScrollOffset target_offset =
-          ScrollOffsetWithDelta(current_offset, pending_delta);
-      target_offset.SetToMax(gfx::ScrollOffset());
-      target_offset.SetToMin(layer_impl->MaxScrollOffset());
-      gfx::Vector2dF actual_delta = target_offset.DeltaFrom(current_offset);
-
-      const float kEpsilon = 0.1f;
-      bool can_layer_scroll = (std::abs(actual_delta.x()) > kEpsilon ||
-                               std::abs(actual_delta.y()) > kEpsilon);
-
-      if (!can_layer_scroll) {
-        layer_impl->ScrollBy(actual_delta);
-        pending_delta -= actual_delta;
-        continue;
-      }
-
-      active_tree_->SetCurrentlyScrollingLayer(layer_impl);
-
-      ScrollAnimationCreate(layer_impl, target_offset, current_offset);
-
-      SetNeedsAnimate();
-      return SCROLL_STARTED;
-    }
-  }
-  ScrollEnd();
-  return scroll_status;
-}
-
-gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
-    LayerImpl* layer_impl,
-    float scale_from_viewport_to_screen_space,
-    const gfx::PointF& viewport_point,
-    const gfx::Vector2dF& viewport_delta) {
-  // Layers with non-invertible screen space transforms should not have passed
-  // the scroll hit test in the first place.
-  DCHECK(layer_impl->screen_space_transform().IsInvertible());
-  gfx::Transform inverse_screen_space_transform(
-      gfx::Transform::kSkipInitialization);
-  bool did_invert = layer_impl->screen_space_transform().GetInverse(
-      &inverse_screen_space_transform);
-  // TODO(shawnsingh): With the advent of impl-side crolling for non-root
-  // layers, we may need to explicitly handle uninvertible transforms here.
-  DCHECK(did_invert);
-
-  gfx::PointF screen_space_point =
-      gfx::ScalePoint(viewport_point, scale_from_viewport_to_screen_space);
-
-  gfx::Vector2dF screen_space_delta = viewport_delta;
-  screen_space_delta.Scale(scale_from_viewport_to_screen_space);
-
-  // First project the scroll start and end points to local layer space to find
-  // the scroll delta in layer coordinates.
-  bool start_clipped, end_clipped;
-  gfx::PointF screen_space_end_point = screen_space_point + screen_space_delta;
-  gfx::PointF local_start_point =
-      MathUtil::ProjectPoint(inverse_screen_space_transform,
-                             screen_space_point,
-                             &start_clipped);
-  gfx::PointF local_end_point =
-      MathUtil::ProjectPoint(inverse_screen_space_transform,
-                             screen_space_end_point,
-                             &end_clipped);
-
-  // In general scroll point coordinates should not get clipped.
-  DCHECK(!start_clipped);
-  DCHECK(!end_clipped);
-  if (start_clipped || end_clipped)
-    return gfx::Vector2dF();
-
-  // local_start_point and local_end_point are in content space but we want to
-  // move them to layer space for scrolling.
-  float width_scale = 1.f / layer_impl->contents_scale_x();
-  float height_scale = 1.f / layer_impl->contents_scale_y();
-  local_start_point.Scale(width_scale, height_scale);
-  local_end_point.Scale(width_scale, height_scale);
-
-  // Apply the scroll delta.
-  gfx::ScrollOffset previous_offset = layer_impl->CurrentScrollOffset();
-  layer_impl->ScrollBy(local_end_point - local_start_point);
-  gfx::ScrollOffset scrolled =
-      layer_impl->CurrentScrollOffset() - previous_offset;
-
-  // Get the end point in the layer's content space so we can apply its
-  // ScreenSpaceTransform.
-  gfx::PointF actual_local_end_point =
-      local_start_point + gfx::Vector2dF(scrolled.x(), scrolled.y());
-  gfx::PointF actual_local_content_end_point =
-      gfx::ScalePoint(actual_local_end_point,
-                      1.f / width_scale,
-                      1.f / height_scale);
-
-  // Calculate the applied scroll delta in viewport space coordinates.
-  gfx::PointF actual_screen_space_end_point =
-      MathUtil::MapPoint(layer_impl->screen_space_transform(),
-                         actual_local_content_end_point,
-                         &end_clipped);
-  DCHECK(!end_clipped);
-  if (end_clipped)
-    return gfx::Vector2dF();
-  gfx::PointF actual_viewport_end_point =
-      gfx::ScalePoint(actual_screen_space_end_point,
-                      1.f / scale_from_viewport_to_screen_space);
-  return actual_viewport_end_point - viewport_point;
-}
-
-static gfx::Vector2dF ScrollLayerWithLocalDelta(
-    LayerImpl* layer_impl,
-    const gfx::Vector2dF& local_delta,
-    float page_scale_factor) {
-  gfx::ScrollOffset previous_offset = layer_impl->CurrentScrollOffset();
-  gfx::Vector2dF delta = local_delta;
-  delta.Scale(1.f / page_scale_factor);
-  layer_impl->ScrollBy(delta);
-  gfx::ScrollOffset scrolled =
-      layer_impl->CurrentScrollOffset() - previous_offset;
-  return gfx::Vector2dF(scrolled.x(), scrolled.y());
-}
-
-bool LayerTreeHostImpl::ShouldTopControlsConsumeScroll(
-    const gfx::Vector2dF& scroll_delta) const {
-  DCHECK(CurrentlyScrollingLayer());
-
-  // Always consume if it's in the direction to show the top controls.
-  if (scroll_delta.y() < 0)
-    return true;
-
-  if (active_tree()->TotalScrollOffset().y() <
-      active_tree()->TotalMaxScrollOffset().y())
-    return true;
-
-  return false;
-}
-
-InputHandlerScrollResult LayerTreeHostImpl::ScrollBy(
-    const gfx::Point& viewport_point,
-    const gfx::Vector2dF& scroll_delta) {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
-  if (!CurrentlyScrollingLayer())
-    return InputHandlerScrollResult();
-
-  gfx::Vector2dF pending_delta = scroll_delta;
-  gfx::Vector2dF unused_root_delta;
-  bool did_scroll_x = false;
-  bool did_scroll_y = false;
-  bool did_scroll_top_controls = false;
-
-  bool consume_by_top_controls = ShouldTopControlsConsumeScroll(scroll_delta);
-
-  // There's an edge case where the outer viewport isn't scrollable when the
-  // scroll starts, however, as the top controls show the outer viewport becomes
-  // scrollable. Therefore, always try scrolling the outer viewport before the
-  // inner.
-  // TODO(bokan): Move the top controls logic out of the loop since the scroll
-  // that causes the outer viewport to become scrollable will still be applied
-  // to the inner viewport.
-  LayerImpl* start_layer = CurrentlyScrollingLayer();
-  if (start_layer == InnerViewportScrollLayer() && OuterViewportScrollLayer())
-      start_layer = OuterViewportScrollLayer();
-
-  for (LayerImpl* layer_impl = start_layer;
-       layer_impl;
-       layer_impl = layer_impl->parent()) {
-    if (!layer_impl->scrollable())
-      continue;
-
-    if (layer_impl == InnerViewportScrollLayer() ||
-        layer_impl == OuterViewportScrollLayer()) {
-      if (consume_by_top_controls) {
-        gfx::Vector2dF excess_delta =
-            top_controls_manager_->ScrollBy(pending_delta);
-        gfx::Vector2dF applied_delta = pending_delta - excess_delta;
-        pending_delta = excess_delta;
-        // Force updating of vertical adjust values if needed.
-        if (applied_delta.y() != 0)
-          did_scroll_top_controls = true;
-      }
-      // Track root layer deltas for reporting overscroll.
-      if (layer_impl == InnerViewportScrollLayer())
-        unused_root_delta = pending_delta;
-    }
-
-    gfx::Vector2dF applied_delta;
-    // Gesture events need to be transformed from viewport coordinates to local
-    // layer coordinates so that the scrolling contents exactly follow the
-    // user's finger. In contrast, wheel events represent a fixed amount of
-    // scrolling so we can just apply them directly, but the page scale factor
-    // is applied to the scroll delta.
-    if (!wheel_scrolling_) {
-      float scale_from_viewport_to_screen_space = device_scale_factor_;
-      applied_delta =
-          ScrollLayerWithViewportSpaceDelta(layer_impl,
-                                            scale_from_viewport_to_screen_space,
-                                            viewport_point, pending_delta);
-    } else {
-      applied_delta = ScrollLayerWithLocalDelta(
-          layer_impl, pending_delta, active_tree_->current_page_scale_factor());
-    }
-
-    const float kEpsilon = 0.1f;
-    if (layer_impl == InnerViewportScrollLayer()) {
-      unused_root_delta.Subtract(applied_delta);
-      if (std::abs(unused_root_delta.x()) < kEpsilon)
-        unused_root_delta.set_x(0.0f);
-      if (std::abs(unused_root_delta.y()) < kEpsilon)
-        unused_root_delta.set_y(0.0f);
-      // Disable overscroll on axes which is impossible to scroll.
-      if (settings_.report_overscroll_only_for_scrollable_axes) {
-        if (std::abs(active_tree_->TotalMaxScrollOffset().x()) <= kEpsilon ||
-            !layer_impl->user_scrollable_horizontal())
-          unused_root_delta.set_x(0.0f);
-        if (std::abs(active_tree_->TotalMaxScrollOffset().y()) <= kEpsilon ||
-            !layer_impl->user_scrollable_vertical())
-          unused_root_delta.set_y(0.0f);
-      }
-    }
-
-    // Scrolls should bubble perfectly between the outer and inner viewports.
-    bool allow_unrestricted_bubbling_for_current_layer =
-        layer_impl == OuterViewportScrollLayer();
-    bool allow_bubbling_for_current_layer =
-        allow_unrestricted_bubbling_for_current_layer || should_bubble_scrolls_;
-
-    // If the layer wasn't able to move, try the next one in the hierarchy.
-    bool did_move_layer_x = std::abs(applied_delta.x()) > kEpsilon;
-    bool did_move_layer_y = std::abs(applied_delta.y()) > kEpsilon;
-    did_scroll_x |= did_move_layer_x;
-    did_scroll_y |= did_move_layer_y;
-    if (!did_move_layer_x && !did_move_layer_y) {
-      if (allow_bubbling_for_current_layer || !did_lock_scrolling_layer_)
-        continue;
-      else
-        break;
-    }
-
-    did_lock_scrolling_layer_ = true;
-
-    // When scrolls are allowed to bubble, it's important that the original
-    // scrolling layer be preserved. This ensures that, after a scroll bubbles,
-    // the user can reverse scroll directions and immediately resume scrolling
-    // the original layer that scrolled.
-    if (!should_bubble_scrolls_)
-      active_tree_->SetCurrentlyScrollingLayer(layer_impl);
-
-    if (!allow_bubbling_for_current_layer)
-      break;
-
-    if (allow_unrestricted_bubbling_for_current_layer) {
-      pending_delta -= applied_delta;
-    } else {
-      // If the applied delta is within 45 degrees of the input delta, bail out
-      // to make it easier to scroll just one layer in one direction without
-      // affecting any of its parents.
-      float angle_threshold = 45;
-      if (MathUtil::SmallestAngleBetweenVectors(applied_delta, pending_delta) <
-          angle_threshold) {
-        pending_delta = gfx::Vector2dF();
-        break;
-      }
-
-      // Allow further movement only on an axis perpendicular to the direction
-      // in which the layer moved.
-      gfx::Vector2dF perpendicular_axis(-applied_delta.y(), applied_delta.x());
-      pending_delta =
-          MathUtil::ProjectVector(pending_delta, perpendicular_axis);
-    }
-
-    if (gfx::ToRoundedVector2d(pending_delta).IsZero())
-      break;
-  }
-
-  bool did_scroll_content = did_scroll_x || did_scroll_y;
-  if (did_scroll_content) {
-    // If we are scrolling with an active scroll handler, forward latency
-    // tracking information to the main thread so the delay introduced by the
-    // handler is accounted for.
-    if (scroll_affects_scroll_handler())
-      NotifySwapPromiseMonitorsOfForwardingToMainThread();
-    client_->SetNeedsCommitOnImplThread();
-    SetNeedsRedraw();
-    client_->RenewTreePriority();
-  }
-
-  // Scrolling along an axis resets accumulated root overscroll for that axis.
-  if (did_scroll_x)
-    accumulated_root_overscroll_.set_x(0);
-  if (did_scroll_y)
-    accumulated_root_overscroll_.set_y(0);
-  accumulated_root_overscroll_ += unused_root_delta;
-
-  InputHandlerScrollResult scroll_result;
-  scroll_result.did_scroll = did_scroll_content || did_scroll_top_controls;
-  scroll_result.did_overscroll_root = !unused_root_delta.IsZero();
-  scroll_result.accumulated_root_overscroll = accumulated_root_overscroll_;
-  scroll_result.unused_scroll_delta = unused_root_delta;
-  return scroll_result;
-}
-
-// This implements scrolling by page as described here:
-// http://msdn.microsoft.com/en-us/library/windows/desktop/ms645601(v=vs.85).aspx#_win32_The_Mouse_Wheel
-// for events with WHEEL_PAGESCROLL set.
-bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point& viewport_point,
-                                               ScrollDirection direction) {
-  DCHECK(wheel_scrolling_);
-
-  for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
-       layer_impl;
-       layer_impl = layer_impl->parent()) {
-    if (!layer_impl->scrollable())
-      continue;
-
-    if (!layer_impl->HasScrollbar(VERTICAL))
-      continue;
-
-    float height = layer_impl->clip_height();
-
-    // These magical values match WebKit and are designed to scroll nearly the
-    // entire visible content height but leave a bit of overlap.
-    float page = std::max(height * 0.875f, 1.f);
-    if (direction == SCROLL_BACKWARD)
-      page = -page;
-
-    gfx::Vector2dF delta = gfx::Vector2dF(0.f, page);
-
-    gfx::Vector2dF applied_delta =
-        ScrollLayerWithLocalDelta(layer_impl, delta, 1.f);
-
-    if (!applied_delta.IsZero()) {
-      client_->SetNeedsCommitOnImplThread();
-      SetNeedsRedraw();
-      client_->RenewTreePriority();
-      return true;
-    }
-
-    active_tree_->SetCurrentlyScrollingLayer(layer_impl);
-  }
-
-  return false;
-}
-
-void LayerTreeHostImpl::SetRootLayerScrollOffsetDelegate(
-      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
-  root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
-  active_tree_->SetRootLayerScrollOffsetDelegate(
-      root_layer_scroll_offset_delegate_);
-}
-
-void LayerTreeHostImpl::OnRootLayerDelegatedScrollOffsetChanged() {
-  DCHECK(root_layer_scroll_offset_delegate_);
-  client_->SetNeedsCommitOnImplThread();
-  SetNeedsRedraw();
-  active_tree_->OnRootLayerDelegatedScrollOffsetChanged();
-  active_tree_->set_needs_update_draw_properties();
-}
-
-void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
-  active_tree_->ClearCurrentlyScrollingLayer();
-  did_lock_scrolling_layer_ = false;
-  scroll_affects_scroll_handler_ = false;
-  accumulated_root_overscroll_ = gfx::Vector2dF();
-}
-
-void LayerTreeHostImpl::ScrollEnd() {
-  top_controls_manager_->ScrollEnd();
-  ClearCurrentlyScrollingLayer();
-}
-
-InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
-  if (!active_tree_->CurrentlyScrollingLayer())
-    return SCROLL_IGNORED;
-
-  if (settings_.ignore_root_layer_flings &&
-      (active_tree_->CurrentlyScrollingLayer() == InnerViewportScrollLayer() ||
-       active_tree_->CurrentlyScrollingLayer() == OuterViewportScrollLayer())) {
-    ClearCurrentlyScrollingLayer();
-    return SCROLL_IGNORED;
-  }
-
-  if (!wheel_scrolling_) {
-    // Allow the fling to lock to the first layer that moves after the initial
-    // fling |ScrollBy()| event.
-    did_lock_scrolling_layer_ = false;
-    should_bubble_scrolls_ = false;
-  }
-
-  return SCROLL_STARTED;
-}
-
-float LayerTreeHostImpl::DeviceSpaceDistanceToLayer(
-    const gfx::PointF& device_viewport_point,
-    LayerImpl* layer_impl) {
-  if (!layer_impl)
-    return std::numeric_limits<float>::max();
-
-  gfx::Rect layer_impl_bounds(
-      layer_impl->content_bounds());
-
-  gfx::RectF device_viewport_layer_impl_bounds = MathUtil::MapClippedRect(
-      layer_impl->screen_space_transform(),
-      layer_impl_bounds);
-
-  return device_viewport_layer_impl_bounds.ManhattanDistanceToPoint(
-      device_viewport_point);
-}
-
-void LayerTreeHostImpl::MouseMoveAt(const gfx::Point& viewport_point) {
-  gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
-                                                      device_scale_factor_);
-  LayerImpl* layer_impl =
-      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
-  if (HandleMouseOverScrollbar(layer_impl, device_viewport_point))
-    return;
-
-  if (scroll_layer_id_when_mouse_over_scrollbar_) {
-    LayerImpl* scroll_layer_impl = active_tree_->LayerById(
-        scroll_layer_id_when_mouse_over_scrollbar_);
-
-    // The check for a null scroll_layer_impl below was added to see if it will
-    // eliminate the crashes described in http://crbug.com/326635.
-    // TODO(wjmaclean) Add a unit test if this fixes the crashes.
-    ScrollbarAnimationController* animation_controller =
-        scroll_layer_impl ? scroll_layer_impl->scrollbar_animation_controller()
-                          : NULL;
-    if (animation_controller)
-      animation_controller->DidMouseMoveOffScrollbar();
-    scroll_layer_id_when_mouse_over_scrollbar_ = 0;
-  }
-
-  bool scroll_on_main_thread = false;
-  LayerImpl* scroll_layer_impl = FindScrollLayerForDeviceViewportPoint(
-      device_viewport_point, InputHandler::GESTURE, layer_impl,
-      &scroll_on_main_thread, NULL);
-  if (scroll_on_main_thread || !scroll_layer_impl)
-    return;
-
-  ScrollbarAnimationController* animation_controller =
-      scroll_layer_impl->scrollbar_animation_controller();
-  if (!animation_controller)
-    return;
-
-  // TODO(wjmaclean) Is it ok to choose distance from more than two scrollbars?
-  float distance_to_scrollbar = std::numeric_limits<float>::max();
-  for (LayerImpl::ScrollbarSet::iterator it =
-           scroll_layer_impl->scrollbars()->begin();
-       it != scroll_layer_impl->scrollbars()->end();
-       ++it)
-    distance_to_scrollbar =
-        std::min(distance_to_scrollbar,
-                 DeviceSpaceDistanceToLayer(device_viewport_point, *it));
-
-  animation_controller->DidMouseMoveNear(distance_to_scrollbar /
-                                         device_scale_factor_);
-}
-
-bool LayerTreeHostImpl::HandleMouseOverScrollbar(LayerImpl* layer_impl,
-    const gfx::PointF& device_viewport_point) {
-  if (layer_impl && layer_impl->ToScrollbarLayer()) {
-    int scroll_layer_id = layer_impl->ToScrollbarLayer()->ScrollLayerId();
-    layer_impl = active_tree_->LayerById(scroll_layer_id);
-    if (layer_impl && layer_impl->scrollbar_animation_controller()) {
-      scroll_layer_id_when_mouse_over_scrollbar_ = scroll_layer_id;
-      layer_impl->scrollbar_animation_controller()->DidMouseMoveNear(0);
-    } else {
-      scroll_layer_id_when_mouse_over_scrollbar_ = 0;
-    }
-
-    return true;
-  }
-
-  return false;
-}
-
-void LayerTreeHostImpl::PinchGestureBegin() {
-  pinch_gesture_active_ = true;
-  previous_pinch_anchor_ = gfx::Point();
-  client_->RenewTreePriority();
-  pinch_gesture_end_should_clear_scrolling_layer_ = !CurrentlyScrollingLayer();
-  if (active_tree_->OuterViewportScrollLayer()) {
-    active_tree_->SetCurrentlyScrollingLayer(
-        active_tree_->OuterViewportScrollLayer());
-  } else {
-    active_tree_->SetCurrentlyScrollingLayer(
-        active_tree_->InnerViewportScrollLayer());
-  }
-  top_controls_manager_->PinchBegin();
-}
-
-void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
-                                           const gfx::Point& anchor) {
-  if (!InnerViewportScrollLayer())
-    return;
-
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
-
-  // For a moment the scroll offset ends up being outside of the max range. This
-  // confuses the delegate so we switch it off till after we're done processing
-  // the pinch update.
-  active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
-
-  // Keep the center-of-pinch anchor specified by (x, y) in a stable
-  // position over the course of the magnify.
-  float page_scale = active_tree_->current_page_scale_factor();
-  gfx::PointF previous_scale_anchor = gfx::ScalePoint(anchor, 1.f / page_scale);
-  active_tree_->SetPageScaleOnActiveTree(page_scale * magnify_delta);
-  page_scale = active_tree_->current_page_scale_factor();
-  gfx::PointF new_scale_anchor = gfx::ScalePoint(anchor, 1.f / page_scale);
-  gfx::Vector2dF move = previous_scale_anchor - new_scale_anchor;
-
-  previous_pinch_anchor_ = anchor;
-
-  // If clamping the inner viewport scroll offset causes a change, it should
-  // be accounted for from the intended move.
-  move -= InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
-
-  // We manually manage the bubbling behaviour here as it is different to that
-  // implemented in LayerTreeHostImpl::ScrollBy(). Specifically:
-  // 1) we want to explicit limit the bubbling to the outer/inner viewports,
-  // 2) we don't want the directional limitations on the unused parts that
-  //    ScrollBy() implements, and
-  // 3) pinching should not engage the top controls manager.
-  gfx::Vector2dF unused = OuterViewportScrollLayer()
-                              ? OuterViewportScrollLayer()->ScrollBy(move)
-                              : move;
-
-  if (!unused.IsZero()) {
-    InnerViewportScrollLayer()->ScrollBy(unused);
-    InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
-  }
-
-  active_tree_->SetRootLayerScrollOffsetDelegate(
-      root_layer_scroll_offset_delegate_);
-
-  client_->SetNeedsCommitOnImplThread();
-  SetNeedsRedraw();
-  client_->RenewTreePriority();
-}
-
-void LayerTreeHostImpl::PinchGestureEnd() {
-  pinch_gesture_active_ = false;
-  if (pinch_gesture_end_should_clear_scrolling_layer_) {
-    pinch_gesture_end_should_clear_scrolling_layer_ = false;
-    ClearCurrentlyScrollingLayer();
-  }
-  top_controls_manager_->PinchEnd();
-  client_->SetNeedsCommitOnImplThread();
-  // When a pinch ends, we may be displaying content cached at incorrect scales,
-  // so updating draw properties and drawing will ensure we are using the right
-  // scales that we want when we're not inside a pinch.
-  active_tree_->set_needs_update_draw_properties();
-  SetNeedsRedraw();
-}
-
-static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
-                                LayerImpl* layer_impl) {
-  if (!layer_impl)
-    return;
-
-  gfx::ScrollOffset scroll_delta = layer_impl->PullDeltaForMainThread();
-
-  if (!scroll_delta.IsZero()) {
-    LayerTreeHostCommon::ScrollUpdateInfo scroll;
-    scroll.layer_id = layer_impl->id();
-    scroll.scroll_delta = gfx::Vector2d(scroll_delta.x(), scroll_delta.y());
-    scroll_info->scrolls.push_back(scroll);
-  }
-
-  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_);
-
-  return scroll_info.Pass();
-}
-
-void LayerTreeHostImpl::SetFullRootLayerDamage() {
-  SetViewportDamage(gfx::Rect(DrawViewportSize()));
-}
-
-void LayerTreeHostImpl::ScrollViewportInnerFirst(gfx::Vector2dF scroll_delta) {
-  DCHECK(InnerViewportScrollLayer());
-  LayerImpl* scroll_layer = InnerViewportScrollLayer();
-
-  gfx::Vector2dF unused_delta = scroll_layer->ScrollBy(scroll_delta);
-  if (!unused_delta.IsZero() && OuterViewportScrollLayer())
-    OuterViewportScrollLayer()->ScrollBy(unused_delta);
-}
-
-void LayerTreeHostImpl::ScrollViewportBy(gfx::Vector2dF scroll_delta) {
-  DCHECK(InnerViewportScrollLayer());
-  LayerImpl* scroll_layer = OuterViewportScrollLayer()
-                                ? OuterViewportScrollLayer()
-                                : InnerViewportScrollLayer();
-
-  gfx::Vector2dF unused_delta = scroll_layer->ScrollBy(scroll_delta);
-
-  if (!unused_delta.IsZero() && (scroll_layer == OuterViewportScrollLayer()))
-    InnerViewportScrollLayer()->ScrollBy(unused_delta);
-}
-
-void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks monotonic_time) {
-  if (!page_scale_animation_)
-    return;
-
-  gfx::ScrollOffset scroll_total = active_tree_->TotalScrollOffset();
-
-  if (!page_scale_animation_->IsAnimationStarted())
-    page_scale_animation_->StartAnimation(monotonic_time);
-
-  active_tree_->SetPageScaleOnActiveTree(
-      page_scale_animation_->PageScaleFactorAtTime(monotonic_time));
-  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_->animation())
-    return;
-
-  gfx::Vector2dF scroll = top_controls_manager_->Animate(time);
-
-  if (top_controls_manager_->animation())
-    SetNeedsAnimate();
-
-  if (active_tree_->TotalScrollOffset().y() == 0.f)
-    return;
-
-  if (scroll.IsZero())
-    return;
-
-  ScrollViewportBy(gfx::ScaleVector2d(
-      scroll, 1.f / active_tree_->current_page_scale_factor()));
-  SetNeedsRedraw();
-  client_->SetNeedsCommitOnImplThread();
-  client_->RenewTreePriority();
-}
-
-void LayerTreeHostImpl::AnimateScrollbars(base::TimeTicks monotonic_time) {
-  if (scrollbar_animation_controllers_.empty())
-    return;
-
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateScrollbars");
-  std::set<ScrollbarAnimationController*> controllers_copy =
-      scrollbar_animation_controllers_;
-  for (auto& it : controllers_copy)
-    it->Animate(monotonic_time);
-
-  SetNeedsAnimate();
-}
-
-void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time) {
-  if (!settings_.accelerated_animation_enabled || !active_tree_->root_layer())
-    return;
-
-  if (animation_registrar_->AnimateLayers(monotonic_time))
-    SetNeedsAnimate();
-}
-
-void LayerTreeHostImpl::UpdateAnimationState(bool start_ready_animations) {
-  if (!settings_.accelerated_animation_enabled || !active_tree_->root_layer())
-    return;
-
-  scoped_ptr<AnimationEventsVector> events =
-      animation_registrar_->CreateEvents();
-  const bool has_active_animations = animation_registrar_->UpdateAnimationState(
-      start_ready_animations, events.get());
-
-  if (!events->empty())
-    client_->PostAnimationEventsToMainThreadOnImplThread(events.Pass());
-
-  if (has_active_animations)
-    SetNeedsAnimate();
-}
-
-void LayerTreeHostImpl::ActivateAnimations() {
-  if (!settings_.accelerated_animation_enabled || !active_tree_->root_layer())
-    return;
-
-  if (animation_registrar_->ActivateAnimations())
-    SetNeedsAnimate();
-}
-
-std::string LayerTreeHostImpl::LayerTreeAsJson() const {
-  std::string str;
-  if (active_tree_->root_layer()) {
-    scoped_ptr<base::Value> json(active_tree_->root_layer()->LayerTreeAsJson());
-    base::JSONWriter::WriteWithOptions(
-        json.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
-  }
-  return str;
-}
-
-int LayerTreeHostImpl::SourceAnimationFrameNumber() const {
-  return fps_counter_->current_frame_number();
-}
-
-void LayerTreeHostImpl::StartAnimatingScrollbarAnimationController(
-    ScrollbarAnimationController* controller) {
-  scrollbar_animation_controllers_.insert(controller);
-  SetNeedsAnimate();
-}
-
-void LayerTreeHostImpl::StopAnimatingScrollbarAnimationController(
-    ScrollbarAnimationController* controller) {
-  scrollbar_animation_controllers_.erase(controller);
-}
-
-void LayerTreeHostImpl::PostDelayedScrollbarAnimationTask(
-    const base::Closure& task,
-    base::TimeDelta delay) {
-  client_->PostDelayedAnimationTaskOnImplThread(task, delay);
-}
-
-void LayerTreeHostImpl::SetNeedsRedrawForScrollbarAnimation() {
-  SetNeedsRedraw();
-}
-
-void LayerTreeHostImpl::SetTreePriority(TreePriority priority) {
-  if (!tile_manager_)
-    return;
-
-  if (global_tile_state_.tree_priority == priority)
-    return;
-  global_tile_state_.tree_priority = priority;
-  DidModifyTilePriorities();
-}
-
-TreePriority LayerTreeHostImpl::GetTreePriority() const {
-  return global_tile_state_.tree_priority;
-}
-
-void LayerTreeHostImpl::UpdateCurrentBeginFrameArgs(
-    const BeginFrameArgs& args) {
-  DCHECK(!current_begin_frame_args_.IsValid());
-  current_begin_frame_args_ = args;
-  // TODO(skyostil): Stop overriding the frame time once the usage of frame
-  // timing is unified.
-  current_begin_frame_args_.frame_time = gfx::FrameTime::Now();
-}
-
-void LayerTreeHostImpl::ResetCurrentBeginFrameArgsForNextFrame() {
-  current_begin_frame_args_ = BeginFrameArgs();
-}
-
-BeginFrameArgs LayerTreeHostImpl::CurrentBeginFrameArgs() const {
-  // 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::trace_event::ConvertableToTraceFormat>
-LayerTreeHostImpl::AsValueWithFrame(FrameData* frame) const {
-  scoped_refptr<base::trace_event::TracedValue> state =
-      new base::trace_event::TracedValue();
-  AsValueWithFrameInto(frame, state.get());
-  return state;
-}
-
-void LayerTreeHostImpl::AsValueWithFrameInto(
-    FrameData* frame,
-    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::map<const Tile*, TilePriority> tile_map;
-  active_tree_->GetAllTilesAndPrioritiesForTracing(&tile_map);
-  if (pending_tree_)
-    pending_tree_->GetAllTilesAndPrioritiesForTracing(&tile_map);
-
-  state->BeginArray("active_tiles");
-  for (const auto& pair : tile_map) {
-    const Tile* tile = pair.first;
-    const TilePriority& priority = pair.second;
-
-    state->BeginDictionary();
-    tile->AsValueWithPriorityInto(priority, state);
-    state->EndDictionary();
-  }
-  state->EndArray();
-
-  if (tile_manager_) {
-    state->BeginDictionary("tile_manager_basic_state");
-    tile_manager_->BasicStateAsValueInto(state);
-    state->EndDictionary();
-  }
-  state->BeginDictionary("active_tree");
-  active_tree_->AsValueInto(state);
-  state->EndDictionary();
-  if (pending_tree_) {
-    state->BeginDictionary("pending_tree");
-    pending_tree_->AsValueInto(state);
-    state->EndDictionary();
-  }
-  if (frame) {
-    state->BeginDictionary("frame");
-    frame->AsValueInto(state);
-    state->EndDictionary();
-  }
-}
-
-void LayerTreeHostImpl::ActivationStateAsValueInto(
-    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) {
-  if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
-    return;
-  if (debug_state_.continuous_painting != new_debug_state.continuous_painting)
-    paint_time_counter_->ClearHistory();
-
-  debug_state_ = new_debug_state;
-  UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
-  SetFullRootLayerDamage();
-}
-
-void LayerTreeHostImpl::CreateUIResource(UIResourceId uid,
-                                         const UIResourceBitmap& bitmap) {
-  DCHECK_GT(uid, 0);
-
-  GLint wrap_mode = 0;
-  switch (bitmap.GetWrapMode()) {
-    case UIResourceBitmap::CLAMP_TO_EDGE:
-      wrap_mode = GL_CLAMP_TO_EDGE;
-      break;
-    case UIResourceBitmap::REPEAT:
-      wrap_mode = GL_REPEAT;
-      break;
-  }
-
-  // Allow for multiple creation requests with the same UIResourceId.  The
-  // previous resource is simply deleted.
-  ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
-  if (id)
-    DeleteUIResource(uid);
-
-  ResourceFormat format = resource_provider_->best_texture_format();
-  switch (bitmap.GetFormat()) {
-    case UIResourceBitmap::RGBA8:
-      break;
-    case UIResourceBitmap::ALPHA_8:
-      format = ALPHA_8;
-      break;
-    case UIResourceBitmap::ETC1:
-      format = ETC1;
-      break;
-  }
-  id = resource_provider_->CreateResource(
-      bitmap.GetSize(), wrap_mode, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
-      format);
-
-  UIResourceData data;
-  data.resource_id = id;
-  data.size = bitmap.GetSize();
-  data.opaque = bitmap.GetOpaque();
-
-  ui_resource_map_[uid] = data;
-
-  AutoLockUIResourceBitmap bitmap_lock(bitmap);
-  resource_provider_->CopyToResource(id, bitmap_lock.GetPixels(),
-                                     bitmap.GetSize());
-  MarkUIResourceNotEvicted(uid);
-}
-
-void LayerTreeHostImpl::DeleteUIResource(UIResourceId uid) {
-  ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
-  if (id) {
-    resource_provider_->DeleteResource(id);
-    ui_resource_map_.erase(uid);
-  }
-  MarkUIResourceNotEvicted(uid);
-}
-
-void LayerTreeHostImpl::EvictAllUIResources() {
-  if (ui_resource_map_.empty())
-    return;
-
-  for (UIResourceMap::const_iterator iter = ui_resource_map_.begin();
-      iter != ui_resource_map_.end();
-      ++iter) {
-    evicted_ui_resources_.insert(iter->first);
-    resource_provider_->DeleteResource(iter->second.resource_id);
-  }
-  ui_resource_map_.clear();
-
-  client_->SetNeedsCommitOnImplThread();
-  client_->OnCanDrawStateChanged(CanDraw());
-  client_->RenewTreePriority();
-}
-
-ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
-    UIResourceId uid) const {
-  UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
-  if (iter != ui_resource_map_.end())
-    return iter->second.resource_id;
-  return 0;
-}
-
-bool LayerTreeHostImpl::IsUIResourceOpaque(UIResourceId uid) const {
-  UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
-  DCHECK(iter != ui_resource_map_.end());
-  return iter->second.opaque;
-}
-
-bool LayerTreeHostImpl::EvictedUIResourcesExist() const {
-  return !evicted_ui_resources_.empty();
-}
-
-void LayerTreeHostImpl::MarkUIResourceNotEvicted(UIResourceId uid) {
-  std::set<UIResourceId>::iterator found_in_evicted =
-      evicted_ui_resources_.find(uid);
-  if (found_in_evicted == evicted_ui_resources_.end())
-    return;
-  evicted_ui_resources_.erase(found_in_evicted);
-  if (evicted_ui_resources_.empty())
-    client_->OnCanDrawStateChanged(CanDraw());
-}
-
-void LayerTreeHostImpl::ScheduleMicroBenchmark(
-    scoped_ptr<MicroBenchmarkImpl> benchmark) {
-  micro_benchmark_controller_.ScheduleRun(benchmark.Pass());
-}
-
-void LayerTreeHostImpl::InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
-  swap_promise_monitor_.insert(monitor);
-}
-
-void LayerTreeHostImpl::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
-  swap_promise_monitor_.erase(monitor);
-}
-
-void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
-  std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
-  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::ScrollAnimationCreate(
-    LayerImpl* layer_impl,
-    const gfx::ScrollOffset& target_offset,
-    const gfx::ScrollOffset& current_offset) {
-  scoped_ptr<ScrollOffsetAnimationCurve> curve =
-      ScrollOffsetAnimationCurve::Create(target_offset,
-                                         EaseInOutTimingFunction::Create());
-  curve->SetInitialValue(current_offset);
-
-  scoped_ptr<Animation> animation = Animation::Create(
-      curve.Pass(), AnimationIdProvider::NextAnimationId(),
-      AnimationIdProvider::NextGroupId(), Animation::SCROLL_OFFSET);
-  animation->set_is_impl_only(true);
-
-  layer_impl->layer_animation_controller()->AddAnimation(animation.Pass());
-}
-
-bool LayerTreeHostImpl::ScrollAnimationUpdateTarget(
-    LayerImpl* layer_impl,
-    const gfx::Vector2dF& scroll_delta) {
-  Animation* animation =
-      layer_impl->layer_animation_controller()
-          ? layer_impl->layer_animation_controller()->GetAnimation(
-                Animation::SCROLL_OFFSET)
-          : nullptr;
-  if (!animation)
-    return false;
-
-  ScrollOffsetAnimationCurve* curve =
-      animation->curve()->ToScrollOffsetAnimationCurve();
-
-  gfx::ScrollOffset new_target =
-      gfx::ScrollOffsetWithDelta(curve->target_value(), scroll_delta);
-  new_target.SetToMax(gfx::ScrollOffset());
-  new_target.SetToMin(layer_impl->MaxScrollOffset());
-
-  curve->UpdateTarget(
-      animation->TrimTimeToCurrentIteration(CurrentBeginFrameArgs().frame_time)
-          .InSecondsF(),
-      new_target);
-
-  return true;
-}
-}  // namespace cc