1// Copyright 2011 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "cc/trees/layer_tree_host_impl.h"
6
7#include <algorithm>
8#include <limits>
9
10#include "base/basictypes.h"
11#include "base/containers/hash_tables.h"
12#include "base/debug/trace_event_argument.h"
13#include "base/json/json_writer.h"
14#include "base/metrics/histogram.h"
15#include "base/stl_util.h"
16#include "base/strings/stringprintf.h"
17#include "cc/animation/animation_id_provider.h"
18#include "cc/animation/scroll_offset_animation_curve.h"
19#include "cc/animation/scrollbar_animation_controller.h"
20#include "cc/animation/timing_function.h"
21#include "cc/base/latency_info_swap_promise_monitor.h"
22#include "cc/base/math_util.h"
23#include "cc/base/util.h"
24#include "cc/debug/benchmark_instrumentation.h"
25#include "cc/debug/debug_rect_history.h"
26#include "cc/debug/devtools_instrumentation.h"
27#include "cc/debug/frame_rate_counter.h"
28#include "cc/debug/paint_time_counter.h"
29#include "cc/debug/rendering_stats_instrumentation.h"
30#include "cc/debug/traced_value.h"
31#include "cc/input/page_scale_animation.h"
32#include "cc/input/top_controls_manager.h"
33#include "cc/layers/append_quads_data.h"
34#include "cc/layers/heads_up_display_layer_impl.h"
35#include "cc/layers/layer_impl.h"
36#include "cc/layers/layer_iterator.h"
37#include "cc/layers/painted_scrollbar_layer_impl.h"
38#include "cc/layers/render_surface_impl.h"
39#include "cc/layers/scrollbar_layer_impl_base.h"
40#include "cc/output/compositor_frame_metadata.h"
41#include "cc/output/copy_output_request.h"
42#include "cc/output/delegating_renderer.h"
43#include "cc/output/gl_renderer.h"
44#include "cc/output/software_renderer.h"
45#include "cc/quads/render_pass_draw_quad.h"
46#include "cc/quads/shared_quad_state.h"
47#include "cc/quads/solid_color_draw_quad.h"
48#include "cc/quads/texture_draw_quad.h"
49#include "cc/resources/bitmap_raster_worker_pool.h"
50#include "cc/resources/eviction_tile_priority_queue.h"
51#include "cc/resources/gpu_raster_worker_pool.h"
52#include "cc/resources/memory_history.h"
53#include "cc/resources/one_copy_raster_worker_pool.h"
54#include "cc/resources/picture_layer_tiling.h"
55#include "cc/resources/pixel_buffer_raster_worker_pool.h"
56#include "cc/resources/prioritized_resource_manager.h"
57#include "cc/resources/raster_tile_priority_queue.h"
58#include "cc/resources/raster_worker_pool.h"
59#include "cc/resources/resource_pool.h"
60#include "cc/resources/texture_mailbox_deleter.h"
61#include "cc/resources/ui_resource_bitmap.h"
62#include "cc/resources/zero_copy_raster_worker_pool.h"
63#include "cc/scheduler/delay_based_time_source.h"
64#include "cc/trees/damage_tracker.h"
65#include "cc/trees/layer_tree_host.h"
66#include "cc/trees/layer_tree_host_common.h"
67#include "cc/trees/layer_tree_impl.h"
68#include "cc/trees/occlusion_tracker.h"
69#include "cc/trees/single_thread_proxy.h"
70#include "cc/trees/tree_synchronizer.h"
71#include "gpu/command_buffer/client/gles2_interface.h"
72#include "gpu/GLES2/gl2extchromium.h"
73#include "ui/gfx/frame_time.h"
74#include "ui/gfx/geometry/rect_conversions.h"
75#include "ui/gfx/size_conversions.h"
76#include "ui/gfx/vector2d_conversions.h"
77
78namespace cc {
79namespace {
80
81void DidVisibilityChange(LayerTreeHostImpl* id, bool visible) {
82  if (visible) {
83    TRACE_EVENT_ASYNC_BEGIN1("webkit",
84                             "LayerTreeHostImpl::SetVisible",
85                             id,
86                             "LayerTreeHostImpl",
87                             id);
88    return;
89  }
90
91  TRACE_EVENT_ASYNC_END0("webkit", "LayerTreeHostImpl::SetVisible", id);
92}
93
94size_t GetMaxTransferBufferUsageBytes(
95    const ContextProvider::Capabilities& context_capabilities,
96    double refresh_rate) {
97  // We want to make sure the default transfer buffer size is equal to the
98  // amount of data that can be uploaded by the compositor to avoid stalling
99  // the pipeline.
100  // For reference Chromebook Pixel can upload 1MB in about 0.5ms.
101  const size_t kMaxBytesUploadedPerMs = 1024 * 1024 * 2;
102
103  // We need to upload at least enough work to keep the GPU process busy until
104  // the next time it can handle a request to start more uploads from the
105  // compositor. We assume that it will pick up any sent upload requests within
106  // the time of a vsync, since the browser will want to swap a frame within
107  // that time interval, and then uploads should have a chance to be processed.
108  size_t ms_per_frame = std::floor(1000.0 / refresh_rate);
109  size_t max_transfer_buffer_usage_bytes =
110      ms_per_frame * kMaxBytesUploadedPerMs;
111
112  // The context may request a lower limit based on the device capabilities.
113  return std::min(context_capabilities.max_transfer_buffer_usage_bytes,
114                  max_transfer_buffer_usage_bytes);
115}
116
117unsigned GetMapImageTextureTarget(
118    const ContextProvider::Capabilities& context_capabilities) {
119  if (context_capabilities.gpu.egl_image_external)
120    return GL_TEXTURE_EXTERNAL_OES;
121  if (context_capabilities.gpu.texture_rectangle)
122    return GL_TEXTURE_RECTANGLE_ARB;
123
124  return GL_TEXTURE_2D;
125}
126
127size_t GetMaxStagingResourceCount() {
128  // Upper bound for number of staging resource to allow.
129  return 32;
130}
131
132}  // namespace
133
134class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
135 public:
136  static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(
137      LayerTreeHostImpl* layer_tree_host_impl,
138      scoped_refptr<DelayBasedTimeSource> time_source) {
139    return make_scoped_ptr(
140        new LayerTreeHostImplTimeSourceAdapter(layer_tree_host_impl,
141                                               time_source));
142  }
143  virtual ~LayerTreeHostImplTimeSourceAdapter() {
144    time_source_->SetClient(NULL);
145    time_source_->SetActive(false);
146  }
147
148  virtual void OnTimerTick() OVERRIDE {
149    // In single threaded mode we attempt to simulate changing the current
150    // thread by maintaining a fake thread id. When we switch from one
151    // thread to another, we construct DebugScopedSetXXXThread objects that
152    // update the thread id. This lets DCHECKS that ensure we're on the
153    // right thread to work correctly in single threaded mode. The problem
154    // here is that the timer tasks are run via the message loop, and when
155    // they run, we've had no chance to construct a DebugScopedSetXXXThread
156    // object. The result is that we report that we're running on the main
157    // thread. In multi-threaded mode, this timer is run on the compositor
158    // thread, so to keep this consistent in single-threaded mode, we'll
159    // construct a DebugScopedSetImplThread object. There is no need to do
160    // this in multi-threaded mode since the real thread id's will be
161    // correct. In fact, setting fake thread id's interferes with the real
162    // thread id's and causes breakage.
163    scoped_ptr<DebugScopedSetImplThread> set_impl_thread;
164    if (!layer_tree_host_impl_->proxy()->HasImplThread()) {
165      set_impl_thread.reset(
166          new DebugScopedSetImplThread(layer_tree_host_impl_->proxy()));
167    }
168
169    layer_tree_host_impl_->Animate(
170        layer_tree_host_impl_->CurrentBeginFrameArgs().frame_time);
171    layer_tree_host_impl_->UpdateBackgroundAnimateTicking(true);
172    bool start_ready_animations = true;
173    layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
174
175    if (layer_tree_host_impl_->pending_tree()) {
176      layer_tree_host_impl_->pending_tree()->UpdateDrawProperties();
177      layer_tree_host_impl_->ManageTiles();
178    }
179
180    layer_tree_host_impl_->ResetCurrentBeginFrameArgsForNextFrame();
181  }
182
183  void SetActive(bool active) {
184    if (active != time_source_->Active())
185      time_source_->SetActive(active);
186  }
187
188  bool Active() const { return time_source_->Active(); }
189
190 private:
191  LayerTreeHostImplTimeSourceAdapter(
192      LayerTreeHostImpl* layer_tree_host_impl,
193      scoped_refptr<DelayBasedTimeSource> time_source)
194      : layer_tree_host_impl_(layer_tree_host_impl),
195        time_source_(time_source) {
196    time_source_->SetClient(this);
197  }
198
199  LayerTreeHostImpl* layer_tree_host_impl_;
200  scoped_refptr<DelayBasedTimeSource> time_source_;
201
202  DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImplTimeSourceAdapter);
203};
204
205LayerTreeHostImpl::FrameData::FrameData()
206    : contains_incomplete_tile(false), has_no_damage(false) {}
207
208LayerTreeHostImpl::FrameData::~FrameData() {}
209
210scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::Create(
211    const LayerTreeSettings& settings,
212    LayerTreeHostImplClient* client,
213    Proxy* proxy,
214    RenderingStatsInstrumentation* rendering_stats_instrumentation,
215    SharedBitmapManager* manager,
216    int id) {
217  return make_scoped_ptr(new LayerTreeHostImpl(
218      settings, client, proxy, rendering_stats_instrumentation, manager, id));
219}
220
221LayerTreeHostImpl::LayerTreeHostImpl(
222    const LayerTreeSettings& settings,
223    LayerTreeHostImplClient* client,
224    Proxy* proxy,
225    RenderingStatsInstrumentation* rendering_stats_instrumentation,
226    SharedBitmapManager* manager,
227    int id)
228    : client_(client),
229      proxy_(proxy),
230      use_gpu_rasterization_(false),
231      input_handler_client_(NULL),
232      did_lock_scrolling_layer_(false),
233      should_bubble_scrolls_(false),
234      wheel_scrolling_(false),
235      scroll_affects_scroll_handler_(false),
236      scroll_layer_id_when_mouse_over_scrollbar_(0),
237      tile_priorities_dirty_(false),
238      root_layer_scroll_offset_delegate_(NULL),
239      settings_(settings),
240      visible_(true),
241      cached_managed_memory_policy_(
242          PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
243          gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
244          ManagedMemoryPolicy::kDefaultNumResourcesLimit),
245      pinch_gesture_active_(false),
246      pinch_gesture_end_should_clear_scrolling_layer_(false),
247      fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
248      paint_time_counter_(PaintTimeCounter::Create()),
249      memory_history_(MemoryHistory::Create()),
250      debug_rect_history_(DebugRectHistory::Create()),
251      texture_mailbox_deleter_(new TextureMailboxDeleter(
252          proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
253                                  : proxy_->MainThreadTaskRunner())),
254      max_memory_needed_bytes_(0),
255      zero_budget_(false),
256      device_scale_factor_(1.f),
257      overhang_ui_resource_id_(0),
258      resourceless_software_draw_(false),
259      begin_impl_frame_interval_(BeginFrameArgs::DefaultInterval()),
260      animation_registrar_(AnimationRegistrar::Create()),
261      rendering_stats_instrumentation_(rendering_stats_instrumentation),
262      micro_benchmark_controller_(this),
263      need_to_update_visible_tiles_before_draw_(false),
264      shared_bitmap_manager_(manager),
265      id_(id) {
266  DCHECK(proxy_->IsImplThread());
267  DidVisibilityChange(this, visible_);
268  animation_registrar_->set_supports_scroll_animations(
269      proxy_->SupportsImplScrolling());
270
271  SetDebugState(settings.initial_debug_state);
272
273  // LTHI always has an active tree.
274  active_tree_ = LayerTreeImpl::create(this);
275  TRACE_EVENT_OBJECT_CREATED_WITH_ID(
276      TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
277
278  if (settings.calculate_top_controls_position) {
279    top_controls_manager_ =
280        TopControlsManager::Create(this,
281                                   settings.top_controls_height,
282                                   settings.top_controls_show_threshold,
283                                   settings.top_controls_hide_threshold);
284
285    // TODO(bokan): This is a quick fix. The browser should lock the top
286    // controls to shown on creation but this appears not to work. Tracked
287    // in crbug.com/417680.
288    // Initialize with top controls showing.
289    SetControlsTopOffset(0.f);
290  }
291}
292
293LayerTreeHostImpl::~LayerTreeHostImpl() {
294  DCHECK(proxy_->IsImplThread());
295  TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
296  TRACE_EVENT_OBJECT_DELETED_WITH_ID(
297      TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
298
299  if (input_handler_client_) {
300    input_handler_client_->WillShutdown();
301    input_handler_client_ = NULL;
302  }
303
304  // The layer trees must be destroyed before the layer tree host. We've
305  // made a contract with our animation controllers that the registrar
306  // will outlive them, and we must make good.
307  if (recycle_tree_)
308    recycle_tree_->Shutdown();
309  if (pending_tree_)
310    pending_tree_->Shutdown();
311  active_tree_->Shutdown();
312  recycle_tree_.reset();
313  pending_tree_.reset();
314  active_tree_.reset();
315  DestroyTileManager();
316}
317
318void LayerTreeHostImpl::BeginMainFrameAborted(bool did_handle) {
319  // If the begin frame data was handled, then scroll and scale set was applied
320  // by the main thread, so the active tree needs to be updated as if these sent
321  // values were applied and committed.
322  if (did_handle) {
323    active_tree_->ApplySentScrollAndScaleDeltasFromAbortedCommit();
324    active_tree_->ResetContentsTexturesPurged();
325  }
326}
327
328void LayerTreeHostImpl::BeginCommit() {
329  TRACE_EVENT0("cc", "LayerTreeHostImpl::BeginCommit");
330
331  if (UsePendingTreeForSync())
332    CreatePendingTree();
333}
334
335void LayerTreeHostImpl::CommitComplete() {
336  TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
337
338  if (pending_tree_)
339    pending_tree_->ApplyScrollDeltasSinceBeginMainFrame();
340  sync_tree()->set_needs_update_draw_properties();
341
342  if (settings_.impl_side_painting) {
343    // Impl-side painting needs an update immediately post-commit to have the
344    // opportunity to create tilings.  Other paths can call UpdateDrawProperties
345    // more lazily when needed prior to drawing.
346    sync_tree()->UpdateDrawProperties();
347    // Start working on newly created tiles immediately if needed.
348    if (tile_manager_ && tile_priorities_dirty_)
349      ManageTiles();
350    else
351      NotifyReadyToActivate();
352  } else {
353    // If we're not in impl-side painting, the tree is immediately considered
354    // active.
355    ActivateSyncTree();
356  }
357
358  micro_benchmark_controller_.DidCompleteCommit();
359}
360
361bool LayerTreeHostImpl::CanDraw() const {
362  // Note: If you are changing this function or any other function that might
363  // affect the result of CanDraw, make sure to call
364  // client_->OnCanDrawStateChanged in the proper places and update the
365  // NotifyIfCanDrawChanged test.
366
367  if (!renderer_) {
368    TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer",
369                         TRACE_EVENT_SCOPE_THREAD);
370    return false;
371  }
372
373  // Must have an OutputSurface if |renderer_| is not NULL.
374  DCHECK(output_surface_);
375
376  // TODO(boliu): Make draws without root_layer work and move this below
377  // draw_and_swap_full_viewport_every_frame check. Tracked in crbug.com/264967.
378  if (!active_tree_->root_layer()) {
379    TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer",
380                         TRACE_EVENT_SCOPE_THREAD);
381    return false;
382  }
383
384  if (output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
385    return true;
386
387  if (DrawViewportSize().IsEmpty()) {
388    TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw empty viewport",
389                         TRACE_EVENT_SCOPE_THREAD);
390    return false;
391  }
392  if (active_tree_->ViewportSizeInvalid()) {
393    TRACE_EVENT_INSTANT0(
394        "cc", "LayerTreeHostImpl::CanDraw viewport size recently changed",
395        TRACE_EVENT_SCOPE_THREAD);
396    return false;
397  }
398  if (active_tree_->ContentsTexturesPurged()) {
399    TRACE_EVENT_INSTANT0(
400        "cc", "LayerTreeHostImpl::CanDraw contents textures purged",
401        TRACE_EVENT_SCOPE_THREAD);
402    return false;
403  }
404  if (EvictedUIResourcesExist()) {
405    TRACE_EVENT_INSTANT0(
406        "cc", "LayerTreeHostImpl::CanDraw UI resources evicted not recreated",
407        TRACE_EVENT_SCOPE_THREAD);
408    return false;
409  }
410  return true;
411}
412
413void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time) {
414  if (input_handler_client_)
415    input_handler_client_->Animate(monotonic_time);
416  AnimatePageScale(monotonic_time);
417  AnimateLayers(monotonic_time);
418  AnimateScrollbars(monotonic_time);
419  AnimateTopControls(monotonic_time);
420}
421
422void LayerTreeHostImpl::ManageTiles() {
423  if (!tile_manager_)
424    return;
425  if (!tile_priorities_dirty_)
426    return;
427
428  tile_priorities_dirty_ = false;
429  tile_manager_->ManageTiles(global_tile_state_);
430
431  client_->DidManageTiles();
432}
433
434bool LayerTreeHostImpl::IsCurrentlyScrollingLayerAt(
435    const gfx::Point& viewport_point,
436    InputHandler::ScrollInputType type) {
437  if (!CurrentlyScrollingLayer())
438    return false;
439
440  gfx::PointF device_viewport_point =
441      gfx::ScalePoint(viewport_point, device_scale_factor_);
442
443  LayerImpl* layer_impl =
444      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
445
446  bool scroll_on_main_thread = false;
447  LayerImpl* scrolling_layer_impl = FindScrollLayerForDeviceViewportPoint(
448      device_viewport_point, type, layer_impl, &scroll_on_main_thread, NULL);
449  return CurrentlyScrollingLayer() == scrolling_layer_impl;
450}
451
452bool LayerTreeHostImpl::HaveTouchEventHandlersAt(
453    const gfx::Point& viewport_point) {
454
455  gfx::PointF device_viewport_point =
456      gfx::ScalePoint(viewport_point, device_scale_factor_);
457
458  LayerImpl* layer_impl =
459      active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
460          device_viewport_point);
461
462  return layer_impl != NULL;
463}
464
465scoped_ptr<SwapPromiseMonitor>
466LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
467    ui::LatencyInfo* latency) {
468  return scoped_ptr<SwapPromiseMonitor>(
469      new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
470}
471
472void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
473    scoped_ptr<SwapPromise> swap_promise) {
474  swap_promises_for_main_thread_scroll_update_.push_back(swap_promise.Pass());
475}
476
477void LayerTreeHostImpl::TrackDamageForAllSurfaces(
478    LayerImpl* root_draw_layer,
479    const LayerImplList& render_surface_layer_list) {
480  // For now, we use damage tracking to compute a global scissor. To do this, we
481  // must compute all damage tracking before drawing anything, so that we know
482  // the root damage rect. The root damage rect is then used to scissor each
483  // surface.
484
485  for (int surface_index = render_surface_layer_list.size() - 1;
486       surface_index >= 0;
487       --surface_index) {
488    LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
489    RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
490    DCHECK(render_surface);
491    render_surface->damage_tracker()->UpdateDamageTrackingState(
492        render_surface->layer_list(),
493        render_surface_layer->id(),
494        render_surface->SurfacePropertyChangedOnlyFromDescendant(),
495        render_surface->content_rect(),
496        render_surface_layer->mask_layer(),
497        render_surface_layer->filters());
498  }
499}
500
501void LayerTreeHostImpl::FrameData::AsValueInto(
502    base::debug::TracedValue* value) const {
503  value->SetBoolean("contains_incomplete_tile", contains_incomplete_tile);
504  value->SetBoolean("has_no_damage", has_no_damage);
505
506  // Quad data can be quite large, so only dump render passes if we select
507  // cc.debug.quads.
508  bool quads_enabled;
509  TRACE_EVENT_CATEGORY_GROUP_ENABLED(
510      TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"), &quads_enabled);
511  if (quads_enabled) {
512    value->BeginArray("render_passes");
513    for (size_t i = 0; i < render_passes.size(); ++i) {
514      value->BeginDictionary();
515      render_passes[i]->AsValueInto(value);
516      value->EndDictionary();
517    }
518    value->EndArray();
519  }
520}
521
522void LayerTreeHostImpl::FrameData::AppendRenderPass(
523    scoped_ptr<RenderPass> render_pass) {
524  render_passes_by_id[render_pass->id] = render_pass.get();
525  render_passes.push_back(render_pass.Pass());
526}
527
528DrawMode LayerTreeHostImpl::GetDrawMode() const {
529  if (resourceless_software_draw_) {
530    return DRAW_MODE_RESOURCELESS_SOFTWARE;
531  } else if (output_surface_->context_provider()) {
532    return DRAW_MODE_HARDWARE;
533  } else {
534    DCHECK_EQ(!output_surface_->software_device(),
535              output_surface_->capabilities().delegated_rendering &&
536                  !output_surface_->capabilities().deferred_gl_initialization)
537        << output_surface_->capabilities().delegated_rendering << " "
538        << output_surface_->capabilities().deferred_gl_initialization;
539    return DRAW_MODE_SOFTWARE;
540  }
541}
542
543static void AppendQuadsForLayer(
544    RenderPass* target_render_pass,
545    LayerImpl* layer,
546    const OcclusionTracker<LayerImpl>& occlusion_tracker,
547    AppendQuadsData* append_quads_data) {
548  layer->AppendQuads(target_render_pass, occlusion_tracker, append_quads_data);
549}
550
551static void AppendQuadsForRenderSurfaceLayer(
552    RenderPass* target_render_pass,
553    LayerImpl* layer,
554    const RenderPass* contributing_render_pass,
555    const OcclusionTracker<LayerImpl>& occlusion_tracker,
556    AppendQuadsData* append_quads_data) {
557  bool is_replica = false;
558  layer->render_surface()->AppendQuads(target_render_pass,
559                                       occlusion_tracker,
560                                       append_quads_data,
561                                       is_replica,
562                                       contributing_render_pass->id);
563
564  // Add replica after the surface so that it appears below the surface.
565  if (layer->has_replica()) {
566    is_replica = true;
567    layer->render_surface()->AppendQuads(target_render_pass,
568                                         occlusion_tracker,
569                                         append_quads_data,
570                                         is_replica,
571                                         contributing_render_pass->id);
572  }
573}
574
575static void AppendQuadsToFillScreen(
576    ResourceProvider::ResourceId overhang_resource_id,
577    const gfx::SizeF& overhang_resource_scaled_size,
578    const gfx::Rect& root_scroll_layer_rect,
579    RenderPass* target_render_pass,
580    LayerImpl* root_layer,
581    SkColor screen_background_color,
582    const OcclusionTracker<LayerImpl>& occlusion_tracker) {
583  if (!root_layer || !SkColorGetA(screen_background_color))
584    return;
585
586  Region fill_region = occlusion_tracker.ComputeVisibleRegionInScreen();
587  if (fill_region.IsEmpty())
588    return;
589
590  // Divide the fill region into the part to be filled with the overhang
591  // resource and the part to be filled with the background color.
592  Region screen_background_color_region = fill_region;
593  Region overhang_region;
594  if (overhang_resource_id) {
595    overhang_region = fill_region;
596    overhang_region.Subtract(root_scroll_layer_rect);
597    screen_background_color_region.Intersect(root_scroll_layer_rect);
598  }
599
600  // Manually create the quad state for the gutter quads, as the root layer
601  // doesn't have any bounds and so can't generate this itself.
602  // TODO(danakj): Make the gutter quads generated by the solid color layer
603  // (make it smarter about generating quads to fill unoccluded areas).
604
605  gfx::Rect root_target_rect = root_layer->render_surface()->content_rect();
606  float opacity = 1.f;
607  int sorting_context_id = 0;
608  SharedQuadState* shared_quad_state =
609      target_render_pass->CreateAndAppendSharedQuadState();
610  shared_quad_state->SetAll(gfx::Transform(),
611                            root_target_rect.size(),
612                            root_target_rect,
613                            root_target_rect,
614                            false,
615                            opacity,
616                            SkXfermode::kSrcOver_Mode,
617                            sorting_context_id);
618
619  for (Region::Iterator fill_rects(screen_background_color_region);
620       fill_rects.has_rect();
621       fill_rects.next()) {
622    gfx::Rect screen_space_rect = fill_rects.rect();
623    gfx::Rect visible_screen_space_rect = screen_space_rect;
624    // Skip the quad culler and just append the quads directly to avoid
625    // occlusion checks.
626    SolidColorDrawQuad* quad =
627        target_render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
628    quad->SetNew(shared_quad_state,
629                 screen_space_rect,
630                 visible_screen_space_rect,
631                 screen_background_color,
632                 false);
633  }
634  for (Region::Iterator fill_rects(overhang_region);
635       fill_rects.has_rect();
636       fill_rects.next()) {
637    DCHECK(overhang_resource_id);
638    gfx::Rect screen_space_rect = fill_rects.rect();
639    gfx::Rect opaque_screen_space_rect = screen_space_rect;
640    gfx::Rect visible_screen_space_rect = screen_space_rect;
641    TextureDrawQuad* tex_quad =
642        target_render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
643    const float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f};
644    tex_quad->SetNew(
645        shared_quad_state,
646        screen_space_rect,
647        opaque_screen_space_rect,
648        visible_screen_space_rect,
649        overhang_resource_id,
650        false,
651        gfx::PointF(
652            screen_space_rect.x() / overhang_resource_scaled_size.width(),
653            screen_space_rect.y() / overhang_resource_scaled_size.height()),
654        gfx::PointF(
655            screen_space_rect.right() / overhang_resource_scaled_size.width(),
656            screen_space_rect.bottom() /
657                overhang_resource_scaled_size.height()),
658        screen_background_color,
659        vertex_opacity,
660        false);
661  }
662}
663
664DrawResult LayerTreeHostImpl::CalculateRenderPasses(
665    FrameData* frame) {
666  DCHECK(frame->render_passes.empty());
667  DCHECK(CanDraw());
668  DCHECK(active_tree_->root_layer());
669
670  TrackDamageForAllSurfaces(active_tree_->root_layer(),
671                            *frame->render_surface_layer_list);
672
673  // If the root render surface has no visible damage, then don't generate a
674  // frame at all.
675  RenderSurfaceImpl* root_surface =
676      active_tree_->root_layer()->render_surface();
677  bool root_surface_has_no_visible_damage =
678      !root_surface->damage_tracker()->current_damage_rect().Intersects(
679          root_surface->content_rect());
680  bool root_surface_has_contributing_layers =
681      !root_surface->layer_list().empty();
682  bool hud_wants_to_draw_ = active_tree_->hud_layer() &&
683                            active_tree_->hud_layer()->IsAnimatingHUDContents();
684  if (root_surface_has_contributing_layers &&
685      root_surface_has_no_visible_damage &&
686      active_tree_->LayersWithCopyOutputRequest().empty() &&
687      !hud_wants_to_draw_) {
688    TRACE_EVENT0("cc",
689                 "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
690    frame->has_no_damage = true;
691    DCHECK(!output_surface_->capabilities()
692               .draw_and_swap_full_viewport_every_frame);
693    return DRAW_SUCCESS;
694  }
695
696  TRACE_EVENT1("cc",
697               "LayerTreeHostImpl::CalculateRenderPasses",
698               "render_surface_layer_list.size()",
699               static_cast<uint64>(frame->render_surface_layer_list->size()));
700
701  // Create the render passes in dependency order.
702  for (int surface_index = frame->render_surface_layer_list->size() - 1;
703       surface_index >= 0;
704       --surface_index) {
705    LayerImpl* render_surface_layer =
706        (*frame->render_surface_layer_list)[surface_index];
707    RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
708
709    bool should_draw_into_render_pass =
710        render_surface_layer->parent() == NULL ||
711        render_surface->contributes_to_drawn_surface() ||
712        render_surface_layer->HasCopyRequest();
713    if (should_draw_into_render_pass)
714      render_surface_layer->render_surface()->AppendRenderPasses(frame);
715  }
716
717  // When we are displaying the HUD, change the root damage rect to cover the
718  // entire root surface. This will disable partial-swap/scissor optimizations
719  // that would prevent the HUD from updating, since the HUD does not cause
720  // damage itself, to prevent it from messing with damage visualizations. Since
721  // damage visualizations are done off the LayerImpls and RenderSurfaceImpls,
722  // changing the RenderPass does not affect them.
723  if (active_tree_->hud_layer()) {
724    RenderPass* root_pass = frame->render_passes.back();
725    root_pass->damage_rect = root_pass->output_rect;
726  }
727
728  OcclusionTracker<LayerImpl> occlusion_tracker(
729      active_tree_->root_layer()->render_surface()->content_rect());
730  occlusion_tracker.set_minimum_tracking_size(
731      settings_.minimum_occlusion_tracking_size);
732
733  if (debug_state_.show_occluding_rects) {
734    occlusion_tracker.set_occluding_screen_space_rects_container(
735        &frame->occluding_screen_space_rects);
736  }
737  if (debug_state_.show_non_occluding_rects) {
738    occlusion_tracker.set_non_occluding_screen_space_rects_container(
739        &frame->non_occluding_screen_space_rects);
740  }
741
742  // Add quads to the Render passes in front-to-back order to allow for testing
743  // occlusion and performing culling during the tree walk.
744  typedef LayerIterator<LayerImpl> LayerIteratorType;
745
746  // Typically when we are missing a texture and use a checkerboard quad, we
747  // still draw the frame. However when the layer being checkerboarded is moving
748  // due to an impl-animation, we drop the frame to avoid flashing due to the
749  // texture suddenly appearing in the future.
750  DrawResult draw_result = DRAW_SUCCESS;
751  // When we have a copy request for a layer, we need to draw no matter
752  // what, as the layer may disappear after this frame.
753  bool have_copy_request = false;
754
755  int layers_drawn = 0;
756
757  const DrawMode draw_mode = GetDrawMode();
758
759  int num_missing_tiles = 0;
760  int num_incomplete_tiles = 0;
761
762  LayerIteratorType end =
763      LayerIteratorType::End(frame->render_surface_layer_list);
764  for (LayerIteratorType it =
765           LayerIteratorType::Begin(frame->render_surface_layer_list);
766       it != end;
767       ++it) {
768    RenderPassId target_render_pass_id =
769        it.target_render_surface_layer()->render_surface()->GetRenderPassId();
770    RenderPass* target_render_pass =
771        frame->render_passes_by_id[target_render_pass_id];
772
773    occlusion_tracker.EnterLayer(it);
774
775    AppendQuadsData append_quads_data(target_render_pass_id);
776
777    if (it.represents_target_render_surface()) {
778      if (it->HasCopyRequest()) {
779        have_copy_request = true;
780        it->TakeCopyRequestsAndTransformToTarget(
781            &target_render_pass->copy_requests);
782      }
783    } else if (it.represents_contributing_render_surface() &&
784               it->render_surface()->contributes_to_drawn_surface()) {
785      RenderPassId contributing_render_pass_id =
786          it->render_surface()->GetRenderPassId();
787      RenderPass* contributing_render_pass =
788          frame->render_passes_by_id[contributing_render_pass_id];
789      AppendQuadsForRenderSurfaceLayer(target_render_pass,
790                                       *it,
791                                       contributing_render_pass,
792                                       occlusion_tracker,
793                                       &append_quads_data);
794    } else if (it.represents_itself() &&
795               !it->visible_content_rect().IsEmpty()) {
796      bool occluded =
797          occlusion_tracker.GetCurrentOcclusionForLayer(it->draw_transform())
798              .IsOccluded(it->visible_content_rect());
799      if (!occluded && it->WillDraw(draw_mode, resource_provider_.get())) {
800        DCHECK_EQ(active_tree_, it->layer_tree_impl());
801
802        frame->will_draw_layers.push_back(*it);
803
804        if (it->HasContributingDelegatedRenderPasses()) {
805          RenderPassId contributing_render_pass_id =
806              it->FirstContributingRenderPassId();
807          while (frame->render_passes_by_id.find(contributing_render_pass_id) !=
808                 frame->render_passes_by_id.end()) {
809            RenderPass* render_pass =
810                frame->render_passes_by_id[contributing_render_pass_id];
811
812            AppendQuadsData append_quads_data(render_pass->id);
813            AppendQuadsForLayer(render_pass,
814                                *it,
815                                occlusion_tracker,
816                                &append_quads_data);
817
818            contributing_render_pass_id =
819                it->NextContributingRenderPassId(contributing_render_pass_id);
820          }
821        }
822
823        AppendQuadsForLayer(target_render_pass,
824                            *it,
825                            occlusion_tracker,
826                            &append_quads_data);
827      }
828
829      ++layers_drawn;
830    }
831
832    rendering_stats_instrumentation_->AddVisibleContentArea(
833        append_quads_data.visible_content_area);
834    rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
835        append_quads_data.approximated_visible_content_area);
836
837    num_missing_tiles += append_quads_data.num_missing_tiles;
838    num_incomplete_tiles += append_quads_data.num_incomplete_tiles;
839
840    if (append_quads_data.num_missing_tiles) {
841      bool layer_has_animating_transform =
842          it->screen_space_transform_is_animating() ||
843          it->draw_transform_is_animating();
844      if (layer_has_animating_transform)
845        draw_result = DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
846    }
847
848    if (append_quads_data.num_incomplete_tiles ||
849        append_quads_data.num_missing_tiles) {
850      frame->contains_incomplete_tile = true;
851      if (active_tree()->RequiresHighResToDraw())
852        draw_result = DRAW_ABORTED_MISSING_HIGH_RES_CONTENT;
853    }
854
855    occlusion_tracker.LeaveLayer(it);
856  }
857
858  if (have_copy_request ||
859      output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
860    draw_result = DRAW_SUCCESS;
861
862#if DCHECK_IS_ON
863  for (size_t i = 0; i < frame->render_passes.size(); ++i) {
864    for (QuadList::Iterator iter = frame->render_passes[i]->quad_list.begin();
865         iter != frame->render_passes[i]->quad_list.end();
866         ++iter)
867      DCHECK(iter->shared_quad_state);
868    DCHECK(frame->render_passes_by_id.find(frame->render_passes[i]->id)
869           != frame->render_passes_by_id.end());
870  }
871#endif
872  DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
873
874  if (!active_tree_->has_transparent_background()) {
875    frame->render_passes.back()->has_transparent_background = false;
876    AppendQuadsToFillScreen(
877        ResourceIdForUIResource(overhang_ui_resource_id_),
878        gfx::ScaleSize(overhang_ui_resource_size_, device_scale_factor_),
879        active_tree_->RootScrollLayerDeviceViewportBounds(),
880        frame->render_passes.back(),
881        active_tree_->root_layer(),
882        active_tree_->background_color(),
883        occlusion_tracker);
884  }
885
886  RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
887  renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
888
889  // Any copy requests left in the tree are not going to get serviced, and
890  // should be aborted.
891  ScopedPtrVector<CopyOutputRequest> requests_to_abort;
892  while (!active_tree_->LayersWithCopyOutputRequest().empty()) {
893    LayerImpl* layer = active_tree_->LayersWithCopyOutputRequest().back();
894    layer->TakeCopyRequestsAndTransformToTarget(&requests_to_abort);
895  }
896  for (size_t i = 0; i < requests_to_abort.size(); ++i)
897    requests_to_abort[i]->SendEmptyResult();
898
899  // If we're making a frame to draw, it better have at least one render pass.
900  DCHECK(!frame->render_passes.empty());
901
902  if (active_tree_->has_ever_been_drawn()) {
903    UMA_HISTOGRAM_COUNTS_100(
904        "Compositing.RenderPass.AppendQuadData.NumMissingTiles",
905        num_missing_tiles);
906    UMA_HISTOGRAM_COUNTS_100(
907        "Compositing.RenderPass.AppendQuadData.NumIncompleteTiles",
908        num_incomplete_tiles);
909  }
910
911  // Should only have one render pass in resourceless software mode.
912  DCHECK(draw_mode != DRAW_MODE_RESOURCELESS_SOFTWARE ||
913         frame->render_passes.size() == 1u)
914      << frame->render_passes.size();
915
916  return draw_result;
917}
918
919void LayerTreeHostImpl::MainThreadHasStoppedFlinging() {
920  if (input_handler_client_)
921    input_handler_client_->MainThreadHasStoppedFlinging();
922}
923
924void LayerTreeHostImpl::UpdateBackgroundAnimateTicking(
925    bool should_background_tick) {
926  DCHECK(proxy_->IsImplThread());
927  if (should_background_tick)
928    DCHECK(active_tree_->root_layer());
929
930  bool enabled = should_background_tick && needs_animate_layers();
931
932  // Lazily create the time_source adapter so that we can vary the interval for
933  // testing.
934  if (!time_source_client_adapter_) {
935    time_source_client_adapter_ = LayerTreeHostImplTimeSourceAdapter::Create(
936        this,
937        DelayBasedTimeSource::Create(
938            LowFrequencyAnimationInterval(),
939            proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
940                                    : proxy_->MainThreadTaskRunner()));
941  }
942
943  time_source_client_adapter_->SetActive(enabled);
944}
945
946void LayerTreeHostImpl::DidAnimateScrollOffset() {
947  client_->SetNeedsCommitOnImplThread();
948  client_->RenewTreePriority();
949}
950
951void LayerTreeHostImpl::SetViewportDamage(const gfx::Rect& damage_rect) {
952  viewport_damage_rect_.Union(damage_rect);
953}
954
955static inline RenderPass* FindRenderPassById(
956    RenderPassId render_pass_id,
957    const LayerTreeHostImpl::FrameData& frame) {
958  RenderPassIdHashMap::const_iterator it =
959      frame.render_passes_by_id.find(render_pass_id);
960  return it != frame.render_passes_by_id.end() ? it->second : NULL;
961}
962
963static void RemoveRenderPassesRecursive(RenderPassId remove_render_pass_id,
964                                        LayerTreeHostImpl::FrameData* frame) {
965  RenderPass* remove_render_pass =
966      FindRenderPassById(remove_render_pass_id, *frame);
967  // The pass was already removed by another quad - probably the original, and
968  // we are the replica.
969  if (!remove_render_pass)
970    return;
971  RenderPassList& render_passes = frame->render_passes;
972  RenderPassList::iterator to_remove = std::find(render_passes.begin(),
973                                                 render_passes.end(),
974                                                 remove_render_pass);
975
976  DCHECK(to_remove != render_passes.end());
977
978  scoped_ptr<RenderPass> removed_pass = render_passes.take(to_remove);
979  frame->render_passes.erase(to_remove);
980  frame->render_passes_by_id.erase(remove_render_pass_id);
981
982  // Now follow up for all RenderPass quads and remove their RenderPasses
983  // recursively.
984  const QuadList& quad_list = removed_pass->quad_list;
985  QuadList::ConstBackToFrontIterator quad_list_iterator =
986      quad_list.BackToFrontBegin();
987  for (; quad_list_iterator != quad_list.BackToFrontEnd();
988       ++quad_list_iterator) {
989    const DrawQuad* current_quad = &*quad_list_iterator;
990    if (current_quad->material != DrawQuad::RENDER_PASS)
991      continue;
992
993    RenderPassId next_remove_render_pass_id =
994        RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id;
995    RemoveRenderPassesRecursive(next_remove_render_pass_id, frame);
996  }
997}
998
999bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::ShouldRemoveRenderPass(
1000    const RenderPassDrawQuad& quad, const FrameData& frame) const {
1001  const RenderPass* render_pass =
1002      FindRenderPassById(quad.render_pass_id, frame);
1003  if (!render_pass)
1004    return false;
1005
1006  // If any quad or RenderPass draws into this RenderPass, then keep it.
1007  const QuadList& quad_list = render_pass->quad_list;
1008  for (QuadList::ConstBackToFrontIterator quad_list_iterator =
1009           quad_list.BackToFrontBegin();
1010       quad_list_iterator != quad_list.BackToFrontEnd();
1011       ++quad_list_iterator) {
1012    const DrawQuad* current_quad = &*quad_list_iterator;
1013
1014    if (current_quad->material != DrawQuad::RENDER_PASS)
1015      return false;
1016
1017    const RenderPass* contributing_pass = FindRenderPassById(
1018        RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id, frame);
1019    if (contributing_pass)
1020      return false;
1021  }
1022  return true;
1023}
1024
1025// Defined for linking tests.
1026template CC_EXPORT void LayerTreeHostImpl::RemoveRenderPasses<
1027  LayerTreeHostImpl::CullRenderPassesWithNoQuads>(
1028      CullRenderPassesWithNoQuads culler, FrameData*);
1029
1030// static
1031template <typename RenderPassCuller>
1032void LayerTreeHostImpl::RemoveRenderPasses(RenderPassCuller culler,
1033                                           FrameData* frame) {
1034  for (size_t it = culler.RenderPassListBegin(frame->render_passes);
1035       it != culler.RenderPassListEnd(frame->render_passes);
1036       it = culler.RenderPassListNext(it)) {
1037    const RenderPass* current_pass = frame->render_passes[it];
1038    const QuadList& quad_list = current_pass->quad_list;
1039    QuadList::ConstBackToFrontIterator quad_list_iterator =
1040        quad_list.BackToFrontBegin();
1041
1042    for (; quad_list_iterator != quad_list.BackToFrontEnd();
1043         ++quad_list_iterator) {
1044      const DrawQuad* current_quad = &*quad_list_iterator;
1045
1046      if (current_quad->material != DrawQuad::RENDER_PASS)
1047        continue;
1048
1049      const RenderPassDrawQuad* render_pass_quad =
1050          RenderPassDrawQuad::MaterialCast(current_quad);
1051      if (!culler.ShouldRemoveRenderPass(*render_pass_quad, *frame))
1052        continue;
1053
1054      // We are changing the vector in the middle of iteration. Because we
1055      // delete render passes that draw into the current pass, we are
1056      // guaranteed that any data from the iterator to the end will not
1057      // change. So, capture the iterator position from the end of the
1058      // list, and restore it after the change.
1059      size_t position_from_end = frame->render_passes.size() - it;
1060      RemoveRenderPassesRecursive(render_pass_quad->render_pass_id, frame);
1061      it = frame->render_passes.size() - position_from_end;
1062      DCHECK_GE(frame->render_passes.size(), position_from_end);
1063    }
1064  }
1065}
1066
1067DrawResult LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
1068  TRACE_EVENT1("cc",
1069               "LayerTreeHostImpl::PrepareToDraw",
1070               "SourceFrameNumber",
1071               active_tree_->source_frame_number());
1072
1073  if (need_to_update_visible_tiles_before_draw_ &&
1074      tile_manager_ && tile_manager_->UpdateVisibleTiles()) {
1075    DidInitializeVisibleTile();
1076  }
1077  need_to_update_visible_tiles_before_draw_ = true;
1078
1079  UMA_HISTOGRAM_CUSTOM_COUNTS(
1080      "Compositing.NumActiveLayers", active_tree_->NumLayers(), 1, 400, 20);
1081
1082  bool ok = active_tree_->UpdateDrawProperties();
1083  DCHECK(ok) << "UpdateDrawProperties failed during draw";
1084
1085  frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
1086  frame->render_passes.clear();
1087  frame->render_passes_by_id.clear();
1088  frame->will_draw_layers.clear();
1089  frame->contains_incomplete_tile = false;
1090  frame->has_no_damage = false;
1091
1092  if (active_tree_->root_layer()) {
1093    gfx::Rect device_viewport_damage_rect = viewport_damage_rect_;
1094    viewport_damage_rect_ = gfx::Rect();
1095
1096    active_tree_->root_layer()->render_surface()->damage_tracker()->
1097        AddDamageNextUpdate(device_viewport_damage_rect);
1098  }
1099
1100  DrawResult draw_result = CalculateRenderPasses(frame);
1101  if (draw_result != DRAW_SUCCESS) {
1102    DCHECK(!output_surface_->capabilities()
1103               .draw_and_swap_full_viewport_every_frame);
1104    return draw_result;
1105  }
1106
1107  // If we return DRAW_SUCCESS, then we expect DrawLayers() to be called before
1108  // this function is called again.
1109  return draw_result;
1110}
1111
1112void LayerTreeHostImpl::EvictTexturesForTesting() {
1113  EnforceManagedMemoryPolicy(ManagedMemoryPolicy(0));
1114}
1115
1116void LayerTreeHostImpl::BlockNotifyReadyToActivateForTesting(bool block) {
1117  NOTREACHED();
1118}
1119
1120void LayerTreeHostImpl::DidInitializeVisibleTileForTesting() {
1121  // Add arbitrary damage, to trigger prepare-to-draws.
1122  // Here, setting damage as viewport size, used only for testing.
1123  SetFullRootLayerDamage();
1124  DidInitializeVisibleTile();
1125}
1126
1127void LayerTreeHostImpl::ResetTreesForTesting() {
1128  if (active_tree_)
1129    active_tree_->DetachLayerTree();
1130  active_tree_ = LayerTreeImpl::create(this);
1131  if (pending_tree_)
1132    pending_tree_->DetachLayerTree();
1133  pending_tree_.reset();
1134  if (recycle_tree_)
1135    recycle_tree_->DetachLayerTree();
1136  recycle_tree_.reset();
1137}
1138
1139void LayerTreeHostImpl::ResetRecycleTreeForTesting() {
1140  if (recycle_tree_)
1141    recycle_tree_->DetachLayerTree();
1142  recycle_tree_.reset();
1143}
1144
1145void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
1146    const ManagedMemoryPolicy& policy) {
1147
1148  bool evicted_resources = client_->ReduceContentsTextureMemoryOnImplThread(
1149      visible_ ? policy.bytes_limit_when_visible : 0,
1150      ManagedMemoryPolicy::PriorityCutoffToValue(
1151          visible_ ? policy.priority_cutoff_when_visible
1152                   : gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING));
1153  if (evicted_resources) {
1154    active_tree_->SetContentsTexturesPurged();
1155    if (pending_tree_)
1156      pending_tree_->SetContentsTexturesPurged();
1157    client_->SetNeedsCommitOnImplThread();
1158    client_->OnCanDrawStateChanged(CanDraw());
1159    client_->RenewTreePriority();
1160  }
1161
1162  UpdateTileManagerMemoryPolicy(policy);
1163}
1164
1165void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy(
1166    const ManagedMemoryPolicy& policy) {
1167  if (!tile_manager_)
1168    return;
1169
1170  global_tile_state_.hard_memory_limit_in_bytes = 0;
1171  global_tile_state_.soft_memory_limit_in_bytes = 0;
1172  if (visible_ && policy.bytes_limit_when_visible > 0) {
1173    global_tile_state_.hard_memory_limit_in_bytes =
1174        policy.bytes_limit_when_visible;
1175    global_tile_state_.soft_memory_limit_in_bytes =
1176        (static_cast<int64>(global_tile_state_.hard_memory_limit_in_bytes) *
1177         settings_.max_memory_for_prepaint_percentage) /
1178        100;
1179  }
1180  global_tile_state_.memory_limit_policy =
1181      ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
1182          visible_ ?
1183          policy.priority_cutoff_when_visible :
1184          gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING);
1185  global_tile_state_.num_resources_limit = policy.num_resources_limit;
1186
1187  // TODO(reveman): We should avoid keeping around unused resources if
1188  // possible. crbug.com/224475
1189  // Unused limit is calculated from soft-limit, as hard-limit may
1190  // be very high and shouldn't typically be exceeded.
1191  size_t unused_memory_limit_in_bytes = static_cast<size_t>(
1192      (static_cast<int64>(global_tile_state_.soft_memory_limit_in_bytes) *
1193       settings_.max_unused_resource_memory_percentage) /
1194      100);
1195
1196  DCHECK(resource_pool_);
1197  resource_pool_->CheckBusyResources();
1198  // Soft limit is used for resource pool such that memory returns to soft
1199  // limit after going over.
1200  resource_pool_->SetResourceUsageLimits(
1201      global_tile_state_.soft_memory_limit_in_bytes,
1202      unused_memory_limit_in_bytes,
1203      global_tile_state_.num_resources_limit);
1204
1205  // Release all staging resources when invisible.
1206  if (staging_resource_pool_) {
1207    staging_resource_pool_->CheckBusyResources();
1208    staging_resource_pool_->SetResourceUsageLimits(
1209        std::numeric_limits<size_t>::max(),
1210        std::numeric_limits<size_t>::max(),
1211        visible_ ? GetMaxStagingResourceCount() : 0);
1212  }
1213
1214  DidModifyTilePriorities();
1215}
1216
1217void LayerTreeHostImpl::DidModifyTilePriorities() {
1218  DCHECK(settings_.impl_side_painting);
1219  // Mark priorities as dirty and schedule a ManageTiles().
1220  tile_priorities_dirty_ = true;
1221  client_->SetNeedsManageTilesOnImplThread();
1222}
1223
1224void LayerTreeHostImpl::DidInitializeVisibleTile() {
1225  if (client_ && !client_->IsInsideDraw())
1226    client_->DidInitializeVisibleTileOnImplThread();
1227}
1228
1229void LayerTreeHostImpl::GetPictureLayerImplPairs(
1230    std::vector<PictureLayerImpl::Pair>* layer_pairs) const {
1231  DCHECK(layer_pairs->empty());
1232  for (std::vector<PictureLayerImpl*>::const_iterator it =
1233           picture_layers_.begin();
1234       it != picture_layers_.end();
1235       ++it) {
1236    PictureLayerImpl* layer = *it;
1237
1238    // TODO(vmpstr): Iterators and should handle this instead. crbug.com/381704
1239    if (!layer->HasValidTilePriorities())
1240      continue;
1241
1242    PictureLayerImpl* twin_layer = layer->GetTwinLayer();
1243
1244    // Ignore the twin layer when tile priorities are invalid.
1245    // TODO(vmpstr): Iterators should handle this instead. crbug.com/381704
1246    if (twin_layer && !twin_layer->HasValidTilePriorities())
1247      twin_layer = NULL;
1248
1249    // If the current tree is ACTIVE_TREE, then always generate a layer_pair.
1250    // If current tree is PENDING_TREE, then only generate a layer_pair if
1251    // there is no twin layer.
1252    if (layer->GetTree() == ACTIVE_TREE) {
1253      DCHECK(!twin_layer || twin_layer->GetTree() == PENDING_TREE);
1254      layer_pairs->push_back(PictureLayerImpl::Pair(layer, twin_layer));
1255    } else if (!twin_layer) {
1256      layer_pairs->push_back(PictureLayerImpl::Pair(NULL, layer));
1257    }
1258  }
1259}
1260
1261void LayerTreeHostImpl::BuildRasterQueue(RasterTilePriorityQueue* queue,
1262                                         TreePriority tree_priority) {
1263  picture_layer_pairs_.clear();
1264  GetPictureLayerImplPairs(&picture_layer_pairs_);
1265  queue->Build(picture_layer_pairs_, tree_priority);
1266}
1267
1268void LayerTreeHostImpl::BuildEvictionQueue(EvictionTilePriorityQueue* queue,
1269                                           TreePriority tree_priority) {
1270  picture_layer_pairs_.clear();
1271  GetPictureLayerImplPairs(&picture_layer_pairs_);
1272  queue->Build(picture_layer_pairs_, tree_priority);
1273}
1274
1275const std::vector<PictureLayerImpl*>& LayerTreeHostImpl::GetPictureLayers()
1276    const {
1277  return picture_layers_;
1278}
1279
1280void LayerTreeHostImpl::NotifyReadyToActivate() {
1281  client_->NotifyReadyToActivate();
1282}
1283
1284void LayerTreeHostImpl::NotifyTileStateChanged(const Tile* tile) {
1285  TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileStateChanged");
1286
1287  if (active_tree_) {
1288    LayerImpl* layer_impl =
1289        active_tree_->FindActiveTreeLayerById(tile->layer_id());
1290    if (layer_impl)
1291      layer_impl->NotifyTileStateChanged(tile);
1292  }
1293
1294  if (pending_tree_) {
1295    LayerImpl* layer_impl =
1296        pending_tree_->FindPendingTreeLayerById(tile->layer_id());
1297    if (layer_impl)
1298      layer_impl->NotifyTileStateChanged(tile);
1299  }
1300}
1301
1302void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
1303  SetManagedMemoryPolicy(policy, zero_budget_);
1304}
1305
1306void LayerTreeHostImpl::SetTreeActivationCallback(
1307    const base::Closure& callback) {
1308  DCHECK(proxy_->IsImplThread());
1309  DCHECK(settings_.impl_side_painting || callback.is_null());
1310  tree_activation_callback_ = callback;
1311}
1312
1313void LayerTreeHostImpl::SetManagedMemoryPolicy(
1314    const ManagedMemoryPolicy& policy, bool zero_budget) {
1315  if (cached_managed_memory_policy_ == policy && zero_budget_ == zero_budget)
1316    return;
1317
1318  ManagedMemoryPolicy old_policy = ActualManagedMemoryPolicy();
1319
1320  cached_managed_memory_policy_ = policy;
1321  zero_budget_ = zero_budget;
1322  ManagedMemoryPolicy actual_policy = ActualManagedMemoryPolicy();
1323
1324  if (old_policy == actual_policy)
1325    return;
1326
1327  if (!proxy_->HasImplThread()) {
1328    // In single-thread mode, this can be called on the main thread by
1329    // GLRenderer::OnMemoryAllocationChanged.
1330    DebugScopedSetImplThread impl_thread(proxy_);
1331    EnforceManagedMemoryPolicy(actual_policy);
1332  } else {
1333    DCHECK(proxy_->IsImplThread());
1334    EnforceManagedMemoryPolicy(actual_policy);
1335  }
1336
1337  // If there is already enough memory to draw everything imaginable and the
1338  // new memory limit does not change this, then do not re-commit. Don't bother
1339  // skipping commits if this is not visible (commits don't happen when not
1340  // visible, there will almost always be a commit when this becomes visible).
1341  bool needs_commit = true;
1342  if (visible() &&
1343      actual_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
1344      old_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
1345      actual_policy.priority_cutoff_when_visible ==
1346          old_policy.priority_cutoff_when_visible) {
1347    needs_commit = false;
1348  }
1349
1350  if (needs_commit)
1351    client_->SetNeedsCommitOnImplThread();
1352}
1353
1354void LayerTreeHostImpl::SetExternalDrawConstraints(
1355    const gfx::Transform& transform,
1356    const gfx::Rect& viewport,
1357    const gfx::Rect& clip,
1358    const gfx::Rect& viewport_rect_for_tile_priority,
1359    const gfx::Transform& transform_for_tile_priority,
1360    bool resourceless_software_draw) {
1361  gfx::Rect viewport_rect_for_tile_priority_in_view_space;
1362  if (!resourceless_software_draw) {
1363    gfx::Transform screen_to_view(gfx::Transform::kSkipInitialization);
1364    if (transform_for_tile_priority.GetInverse(&screen_to_view)) {
1365      // Convert from screen space to view space.
1366      viewport_rect_for_tile_priority_in_view_space =
1367          gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
1368              screen_to_view, viewport_rect_for_tile_priority));
1369    }
1370  }
1371
1372  if (external_transform_ != transform || external_viewport_ != viewport ||
1373      resourceless_software_draw_ != resourceless_software_draw ||
1374      viewport_rect_for_tile_priority_ !=
1375          viewport_rect_for_tile_priority_in_view_space) {
1376    active_tree_->set_needs_update_draw_properties();
1377  }
1378
1379  external_transform_ = transform;
1380  external_viewport_ = viewport;
1381  external_clip_ = clip;
1382  viewport_rect_for_tile_priority_ =
1383      viewport_rect_for_tile_priority_in_view_space;
1384  resourceless_software_draw_ = resourceless_software_draw;
1385}
1386
1387void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
1388  if (damage_rect.IsEmpty())
1389    return;
1390  NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1391  client_->SetNeedsRedrawRectOnImplThread(damage_rect);
1392}
1393
1394void LayerTreeHostImpl::BeginFrame(const BeginFrameArgs& args) {
1395  client_->BeginFrame(args);
1396}
1397
1398void LayerTreeHostImpl::DidSwapBuffers() {
1399  client_->DidSwapBuffersOnImplThread();
1400}
1401
1402void LayerTreeHostImpl::DidSwapBuffersComplete() {
1403  client_->DidSwapBuffersCompleteOnImplThread();
1404}
1405
1406void LayerTreeHostImpl::ReclaimResources(const CompositorFrameAck* ack) {
1407  // TODO(piman): We may need to do some validation on this ack before
1408  // processing it.
1409  if (renderer_)
1410    renderer_->ReceiveSwapBuffersAck(*ack);
1411
1412  // In OOM, we now might be able to release more resources that were held
1413  // because they were exported.
1414  if (tile_manager_) {
1415    DCHECK(resource_pool_);
1416
1417    resource_pool_->CheckBusyResources();
1418    resource_pool_->ReduceResourceUsage();
1419  }
1420  // If we're not visible, we likely released resources, so we want to
1421  // aggressively flush here to make sure those DeleteTextures make it to the
1422  // GPU process to free up the memory.
1423  if (output_surface_->context_provider() && !visible_) {
1424    output_surface_->context_provider()->ContextGL()->ShallowFlushCHROMIUM();
1425  }
1426}
1427
1428void LayerTreeHostImpl::OnCanDrawStateChangedForTree() {
1429  client_->OnCanDrawStateChanged(CanDraw());
1430}
1431
1432CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
1433  CompositorFrameMetadata metadata;
1434  metadata.device_scale_factor = device_scale_factor_;
1435  metadata.page_scale_factor = active_tree_->total_page_scale_factor();
1436  metadata.scrollable_viewport_size = active_tree_->ScrollableViewportSize();
1437  metadata.root_layer_size = active_tree_->ScrollableSize();
1438  metadata.min_page_scale_factor = active_tree_->min_page_scale_factor();
1439  metadata.max_page_scale_factor = active_tree_->max_page_scale_factor();
1440  if (top_controls_manager_) {
1441    metadata.location_bar_offset =
1442        gfx::Vector2dF(0.f, top_controls_manager_->ControlsTopOffset());
1443    metadata.location_bar_content_translation =
1444        gfx::Vector2dF(0.f, top_controls_manager_->ContentTopOffset());
1445  }
1446
1447  active_tree_->GetViewportSelection(&metadata.selection_start,
1448                                     &metadata.selection_end);
1449
1450  if (!InnerViewportScrollLayer())
1451    return metadata;
1452
1453  metadata.root_scroll_offset = active_tree_->TotalScrollOffset();
1454
1455  return metadata;
1456}
1457
1458static void LayerTreeHostImplDidBeginTracingCallback(LayerImpl* layer) {
1459  layer->DidBeginTracing();
1460}
1461
1462void LayerTreeHostImpl::DrawLayers(FrameData* frame,
1463                                   base::TimeTicks frame_begin_time) {
1464  TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
1465  DCHECK(CanDraw());
1466
1467  if (frame->has_no_damage) {
1468    TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
1469    DCHECK(!output_surface_->capabilities()
1470               .draw_and_swap_full_viewport_every_frame);
1471    return;
1472  }
1473
1474  DCHECK(!frame->render_passes.empty());
1475
1476  fps_counter_->SaveTimeStamp(frame_begin_time,
1477                              !output_surface_->context_provider());
1478  bool on_main_thread = false;
1479  rendering_stats_instrumentation_->IncrementFrameCount(
1480      1, on_main_thread);
1481
1482  if (tile_manager_) {
1483    memory_history_->SaveEntry(
1484        tile_manager_->memory_stats_from_last_assign());
1485  }
1486
1487  if (debug_state_.ShowHudRects()) {
1488    debug_rect_history_->SaveDebugRectsForCurrentFrame(
1489        active_tree_->root_layer(),
1490        active_tree_->hud_layer(),
1491        *frame->render_surface_layer_list,
1492        frame->occluding_screen_space_rects,
1493        frame->non_occluding_screen_space_rects,
1494        debug_state_);
1495  }
1496
1497  if (!settings_.impl_side_painting && debug_state_.continuous_painting) {
1498    const RenderingStats& stats =
1499        rendering_stats_instrumentation_->GetRenderingStats();
1500    paint_time_counter_->SavePaintTime(stats.main_stats.paint_time);
1501  }
1502
1503  bool is_new_trace;
1504  TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
1505  if (is_new_trace) {
1506    if (pending_tree_) {
1507      LayerTreeHostCommon::CallFunctionForSubtree(
1508          pending_tree_->root_layer(),
1509          base::Bind(&LayerTreeHostImplDidBeginTracingCallback));
1510    }
1511    LayerTreeHostCommon::CallFunctionForSubtree(
1512        active_tree_->root_layer(),
1513        base::Bind(&LayerTreeHostImplDidBeginTracingCallback));
1514  }
1515
1516  {
1517    TRACE_EVENT0("cc", "DrawLayers.FrameViewerTracing");
1518    TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
1519       TRACE_DISABLED_BY_DEFAULT("cc.debug") ","
1520       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads") ","
1521       TRACE_DISABLED_BY_DEFAULT("devtools.timeline.layers"),
1522       "cc::LayerTreeHostImpl",
1523       id_,
1524       AsValueWithFrame(frame));
1525  }
1526
1527  const DrawMode draw_mode = GetDrawMode();
1528
1529  // Because the contents of the HUD depend on everything else in the frame, the
1530  // contents of its texture are updated as the last thing before the frame is
1531  // drawn.
1532  if (active_tree_->hud_layer()) {
1533    TRACE_EVENT0("cc", "DrawLayers.UpdateHudTexture");
1534    active_tree_->hud_layer()->UpdateHudTexture(draw_mode,
1535                                                resource_provider_.get());
1536  }
1537
1538  if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE) {
1539    bool disable_picture_quad_image_filtering =
1540        IsActivelyScrolling() || needs_animate_layers();
1541
1542    scoped_ptr<SoftwareRenderer> temp_software_renderer =
1543        SoftwareRenderer::Create(this, &settings_, output_surface_.get(), NULL);
1544    temp_software_renderer->DrawFrame(&frame->render_passes,
1545                                      device_scale_factor_,
1546                                      DeviceViewport(),
1547                                      DeviceClip(),
1548                                      disable_picture_quad_image_filtering);
1549  } else {
1550    renderer_->DrawFrame(&frame->render_passes,
1551                         device_scale_factor_,
1552                         DeviceViewport(),
1553                         DeviceClip(),
1554                         false);
1555  }
1556  // The render passes should be consumed by the renderer.
1557  DCHECK(frame->render_passes.empty());
1558  frame->render_passes_by_id.clear();
1559
1560  // The next frame should start by assuming nothing has changed, and changes
1561  // are noted as they occur.
1562  // TODO(boliu): If we did a temporary software renderer frame, propogate the
1563  // damage forward to the next frame.
1564  for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
1565    (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
1566        DidDrawDamagedArea();
1567  }
1568  active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
1569
1570  active_tree_->set_has_ever_been_drawn(true);
1571  devtools_instrumentation::DidDrawFrame(id_);
1572  benchmark_instrumentation::IssueImplThreadRenderingStatsEvent(
1573      rendering_stats_instrumentation_->impl_thread_rendering_stats());
1574  rendering_stats_instrumentation_->AccumulateAndClearImplThreadStats();
1575}
1576
1577void LayerTreeHostImpl::DidDrawAllLayers(const FrameData& frame) {
1578  for (size_t i = 0; i < frame.will_draw_layers.size(); ++i)
1579    frame.will_draw_layers[i]->DidDraw(resource_provider_.get());
1580
1581  // Once all layers have been drawn, pending texture uploads should no
1582  // longer block future uploads.
1583  resource_provider_->MarkPendingUploadsAsNonBlocking();
1584}
1585
1586void LayerTreeHostImpl::FinishAllRendering() {
1587  if (renderer_)
1588    renderer_->Finish();
1589}
1590
1591void LayerTreeHostImpl::SetUseGpuRasterization(bool use_gpu) {
1592  if (use_gpu == use_gpu_rasterization_)
1593    return;
1594
1595  use_gpu_rasterization_ = use_gpu;
1596  ReleaseTreeResources();
1597
1598  // Replace existing tile manager with another one that uses appropriate
1599  // rasterizer.
1600  if (tile_manager_) {
1601    DestroyTileManager();
1602    CreateAndSetTileManager();
1603  }
1604
1605  // We have released tilings for both active and pending tree.
1606  // We would not have any content to draw until the pending tree is activated.
1607  // Prevent the active tree from drawing until activation.
1608  active_tree_->SetRequiresHighResToDraw();
1609}
1610
1611const RendererCapabilitiesImpl&
1612LayerTreeHostImpl::GetRendererCapabilities() const {
1613  return renderer_->Capabilities();
1614}
1615
1616bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
1617  active_tree()->ResetRequiresHighResToDraw();
1618  if (frame.has_no_damage) {
1619    active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
1620    return false;
1621  }
1622  CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
1623  active_tree()->FinishSwapPromises(&metadata);
1624  for (size_t i = 0; i < metadata.latency_info.size(); i++) {
1625    TRACE_EVENT_FLOW_STEP0(
1626        "input",
1627        "LatencyInfo.Flow",
1628        TRACE_ID_DONT_MANGLE(metadata.latency_info[i].trace_id),
1629        "SwapBuffers");
1630  }
1631  renderer_->SwapBuffers(metadata);
1632  return true;
1633}
1634
1635void LayerTreeHostImpl::SetNeedsBeginFrame(bool enable) {
1636  if (output_surface_)
1637    output_surface_->SetNeedsBeginFrame(enable);
1638  else
1639    DCHECK(!enable);
1640}
1641
1642void LayerTreeHostImpl::WillBeginImplFrame(const BeginFrameArgs& args) {
1643  // Sample the frame time now. This time will be used for updating animations
1644  // when we draw.
1645  UpdateCurrentBeginFrameArgs(args);
1646  // Cache the begin impl frame interval
1647  begin_impl_frame_interval_ = args.interval;
1648}
1649
1650void LayerTreeHostImpl::UpdateInnerViewportContainerSize() {
1651  LayerImpl* container_layer = active_tree_->InnerViewportContainerLayer();
1652  if (!container_layer)
1653    return;
1654
1655  if (top_controls_manager_) {
1656    container_layer->SetBoundsDelta(
1657        gfx::Vector2dF(0, active_tree_->top_controls_layout_height() -
1658            active_tree_->total_top_controls_content_offset()));
1659  }
1660}
1661
1662void LayerTreeHostImpl::SetTopControlsLayoutHeight(float height) {
1663  if (active_tree_->top_controls_layout_height() == height)
1664    return;
1665
1666  active_tree_->set_top_controls_layout_height(height);
1667  UpdateInnerViewportContainerSize();
1668  SetFullRootLayerDamage();
1669}
1670
1671void LayerTreeHostImpl::DidLoseOutputSurface() {
1672  if (resource_provider_)
1673    resource_provider_->DidLoseOutputSurface();
1674  client_->DidLoseOutputSurfaceOnImplThread();
1675}
1676
1677bool LayerTreeHostImpl::HaveRootScrollLayer() const {
1678  return !!InnerViewportScrollLayer();
1679}
1680
1681LayerImpl* LayerTreeHostImpl::RootLayer() const {
1682  return active_tree_->root_layer();
1683}
1684
1685LayerImpl* LayerTreeHostImpl::InnerViewportScrollLayer() const {
1686  return active_tree_->InnerViewportScrollLayer();
1687}
1688
1689LayerImpl* LayerTreeHostImpl::OuterViewportScrollLayer() const {
1690  return active_tree_->OuterViewportScrollLayer();
1691}
1692
1693LayerImpl* LayerTreeHostImpl::CurrentlyScrollingLayer() const {
1694  return active_tree_->CurrentlyScrollingLayer();
1695}
1696
1697bool LayerTreeHostImpl::IsActivelyScrolling() const {
1698  return (did_lock_scrolling_layer_ && CurrentlyScrollingLayer()) ||
1699         (InnerViewportScrollLayer() &&
1700          InnerViewportScrollLayer()->IsExternalFlingActive()) ||
1701         (OuterViewportScrollLayer() &&
1702          OuterViewportScrollLayer()->IsExternalFlingActive());
1703}
1704
1705// Content layers can be either directly scrollable or contained in an outer
1706// scrolling layer which applies the scroll transform. Given a content layer,
1707// this function returns the associated scroll layer if any.
1708static LayerImpl* FindScrollLayerForContentLayer(LayerImpl* layer_impl) {
1709  if (!layer_impl)
1710    return NULL;
1711
1712  if (layer_impl->scrollable())
1713    return layer_impl;
1714
1715  if (layer_impl->DrawsContent() &&
1716      layer_impl->parent() &&
1717      layer_impl->parent()->scrollable())
1718    return layer_impl->parent();
1719
1720  return NULL;
1721}
1722
1723void LayerTreeHostImpl::CreatePendingTree() {
1724  CHECK(!pending_tree_);
1725  if (recycle_tree_)
1726    recycle_tree_.swap(pending_tree_);
1727  else
1728    pending_tree_ = LayerTreeImpl::create(this);
1729
1730  // Update the delta from the active tree, which may have
1731  // adjusted its delta prior to the pending tree being created.
1732  DCHECK_EQ(1.f, pending_tree_->sent_page_scale_delta());
1733  DCHECK_EQ(0.f, pending_tree_->sent_top_controls_delta());
1734  pending_tree_->SetPageScaleDelta(active_tree_->page_scale_delta() /
1735                                   active_tree_->sent_page_scale_delta());
1736  pending_tree_->set_top_controls_delta(
1737      active_tree_->top_controls_delta() -
1738      active_tree_->sent_top_controls_delta());
1739
1740  client_->OnCanDrawStateChanged(CanDraw());
1741  TRACE_EVENT_ASYNC_BEGIN0("cc", "PendingTree:waiting", pending_tree_.get());
1742}
1743
1744void LayerTreeHostImpl::UpdateVisibleTiles() {
1745  if (tile_manager_ && tile_manager_->UpdateVisibleTiles())
1746    DidInitializeVisibleTile();
1747  need_to_update_visible_tiles_before_draw_ = false;
1748}
1749
1750void LayerTreeHostImpl::ActivateSyncTree() {
1751  need_to_update_visible_tiles_before_draw_ = true;
1752
1753  if (pending_tree_) {
1754    TRACE_EVENT_ASYNC_END0("cc", "PendingTree:waiting", pending_tree_.get());
1755
1756    active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
1757    active_tree_->PushPersistedState(pending_tree_.get());
1758    // Process any requests in the UI resource queue.  The request queue is
1759    // given in LayerTreeHost::FinishCommitOnImplThread.  This must take place
1760    // before the swap.
1761    pending_tree_->ProcessUIResourceRequestQueue();
1762
1763    if (pending_tree_->needs_full_tree_sync()) {
1764      active_tree_->SetRootLayer(
1765          TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
1766                                             active_tree_->DetachLayerTree(),
1767                                             active_tree_.get()));
1768    }
1769    TreeSynchronizer::PushProperties(pending_tree_->root_layer(),
1770                                     active_tree_->root_layer());
1771    pending_tree_->PushPropertiesTo(active_tree_.get());
1772
1773    // Now that we've synced everything from the pending tree to the active
1774    // tree, rename the pending tree the recycle tree so we can reuse it on the
1775    // next sync.
1776    DCHECK(!recycle_tree_);
1777    pending_tree_.swap(recycle_tree_);
1778
1779    active_tree_->SetRootLayerScrollOffsetDelegate(
1780        root_layer_scroll_offset_delegate_);
1781
1782    if (top_controls_manager_) {
1783      top_controls_manager_->SetControlsTopOffset(
1784          active_tree_->total_top_controls_content_offset() -
1785          top_controls_manager_->top_controls_height());
1786    }
1787
1788    UpdateInnerViewportContainerSize();
1789  } else {
1790    active_tree_->ProcessUIResourceRequestQueue();
1791  }
1792
1793  active_tree_->DidBecomeActive();
1794  ActivateAnimations();
1795  if (settings_.impl_side_painting)
1796    client_->RenewTreePriority();
1797
1798  client_->OnCanDrawStateChanged(CanDraw());
1799  client_->DidActivateSyncTree();
1800  if (!tree_activation_callback_.is_null())
1801    tree_activation_callback_.Run();
1802
1803  if (debug_state_.continuous_painting) {
1804    const RenderingStats& stats =
1805        rendering_stats_instrumentation_->GetRenderingStats();
1806    paint_time_counter_->SavePaintTime(stats.main_stats.paint_time +
1807                                       stats.main_stats.record_time +
1808                                       stats.impl_stats.rasterize_time);
1809  }
1810
1811  if (time_source_client_adapter_ && time_source_client_adapter_->Active())
1812    DCHECK(active_tree_->root_layer());
1813
1814  scoped_ptr<PageScaleAnimation> page_scale_animation =
1815      active_tree_->TakePageScaleAnimation();
1816  if (page_scale_animation) {
1817    page_scale_animation_ = page_scale_animation.Pass();
1818    SetNeedsAnimate();
1819    client_->SetNeedsCommitOnImplThread();
1820    client_->RenewTreePriority();
1821  }
1822}
1823
1824void LayerTreeHostImpl::SetVisible(bool visible) {
1825  DCHECK(proxy_->IsImplThread());
1826
1827  if (visible_ == visible)
1828    return;
1829  visible_ = visible;
1830  DidVisibilityChange(this, visible_);
1831  EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
1832
1833  // If we just became visible, we have to ensure that we draw high res tiles,
1834  // to prevent checkerboard/low res flashes.
1835  if (visible_)
1836    active_tree()->SetRequiresHighResToDraw();
1837  else
1838    EvictAllUIResources();
1839
1840  // Evict tiles immediately if invisible since this tab may never get another
1841  // draw or timer tick.
1842  if (!visible_)
1843    ManageTiles();
1844
1845  if (!renderer_)
1846    return;
1847
1848  renderer_->SetVisible(visible);
1849}
1850
1851void LayerTreeHostImpl::SetNeedsAnimate() {
1852  NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1853  client_->SetNeedsAnimateOnImplThread();
1854}
1855
1856void LayerTreeHostImpl::SetNeedsRedraw() {
1857  NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1858  client_->SetNeedsRedrawOnImplThread();
1859}
1860
1861ManagedMemoryPolicy LayerTreeHostImpl::ActualManagedMemoryPolicy() const {
1862  ManagedMemoryPolicy actual = cached_managed_memory_policy_;
1863  if (debug_state_.rasterize_only_visible_content) {
1864    actual.priority_cutoff_when_visible =
1865        gpu::MemoryAllocation::CUTOFF_ALLOW_REQUIRED_ONLY;
1866  } else if (use_gpu_rasterization()) {
1867    actual.priority_cutoff_when_visible =
1868        gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
1869  }
1870
1871  if (zero_budget_) {
1872    actual.bytes_limit_when_visible = 0;
1873  }
1874
1875  return actual;
1876}
1877
1878size_t LayerTreeHostImpl::memory_allocation_limit_bytes() const {
1879  return ActualManagedMemoryPolicy().bytes_limit_when_visible;
1880}
1881
1882int LayerTreeHostImpl::memory_allocation_priority_cutoff() const {
1883  return ManagedMemoryPolicy::PriorityCutoffToValue(
1884      ActualManagedMemoryPolicy().priority_cutoff_when_visible);
1885}
1886
1887void LayerTreeHostImpl::ReleaseTreeResources() {
1888  active_tree_->ReleaseResources();
1889  if (pending_tree_)
1890    pending_tree_->ReleaseResources();
1891  if (recycle_tree_)
1892    recycle_tree_->ReleaseResources();
1893
1894  EvictAllUIResources();
1895}
1896
1897void LayerTreeHostImpl::CreateAndSetRenderer() {
1898  DCHECK(!renderer_);
1899  DCHECK(output_surface_);
1900  DCHECK(resource_provider_);
1901
1902  if (output_surface_->capabilities().delegated_rendering) {
1903    renderer_ = DelegatingRenderer::Create(
1904        this, &settings_, output_surface_.get(), resource_provider_.get());
1905  } else if (output_surface_->context_provider()) {
1906    renderer_ = GLRenderer::Create(this,
1907                                   &settings_,
1908                                   output_surface_.get(),
1909                                   resource_provider_.get(),
1910                                   texture_mailbox_deleter_.get(),
1911                                   settings_.highp_threshold_min);
1912  } else if (output_surface_->software_device()) {
1913    renderer_ = SoftwareRenderer::Create(
1914        this, &settings_, output_surface_.get(), resource_provider_.get());
1915  }
1916  DCHECK(renderer_);
1917
1918  renderer_->SetVisible(visible_);
1919  SetFullRootLayerDamage();
1920
1921  // See note in LayerTreeImpl::UpdateDrawProperties.  Renderer needs to be
1922  // initialized to get max texture size.  Also, after releasing resources,
1923  // trees need another update to generate new ones.
1924  active_tree_->set_needs_update_draw_properties();
1925  if (pending_tree_)
1926    pending_tree_->set_needs_update_draw_properties();
1927  client_->UpdateRendererCapabilitiesOnImplThread();
1928}
1929
1930void LayerTreeHostImpl::CreateAndSetTileManager() {
1931  DCHECK(!tile_manager_);
1932  DCHECK(settings_.impl_side_painting);
1933  DCHECK(output_surface_);
1934  DCHECK(resource_provider_);
1935  DCHECK(proxy_->ImplThreadTaskRunner());
1936
1937  ContextProvider* context_provider = output_surface_->context_provider();
1938  if (!context_provider) {
1939    resource_pool_ =
1940        ResourcePool::Create(resource_provider_.get(),
1941                             GL_TEXTURE_2D,
1942                             resource_provider_->best_texture_format());
1943
1944    raster_worker_pool_ =
1945        BitmapRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
1946                                       RasterWorkerPool::GetTaskGraphRunner(),
1947                                       resource_provider_.get());
1948  } else if (use_gpu_rasterization_) {
1949    resource_pool_ =
1950        ResourcePool::Create(resource_provider_.get(),
1951                             GL_TEXTURE_2D,
1952                             resource_provider_->best_texture_format());
1953
1954    raster_worker_pool_ =
1955        GpuRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
1956                                    context_provider,
1957                                    resource_provider_.get());
1958  } else if (UseZeroCopyRasterizer()) {
1959    resource_pool_ = ResourcePool::Create(
1960        resource_provider_.get(),
1961        GetMapImageTextureTarget(context_provider->ContextCapabilities()),
1962        resource_provider_->best_texture_format());
1963
1964    raster_worker_pool_ =
1965        ZeroCopyRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
1966                                         RasterWorkerPool::GetTaskGraphRunner(),
1967                                         resource_provider_.get());
1968  } else if (UseOneCopyRasterizer()) {
1969    // We need to create a staging resource pool when using copy rasterizer.
1970    staging_resource_pool_ = ResourcePool::Create(
1971        resource_provider_.get(),
1972        GetMapImageTextureTarget(context_provider->ContextCapabilities()),
1973        resource_provider_->best_texture_format());
1974    resource_pool_ =
1975        ResourcePool::Create(resource_provider_.get(),
1976                             GL_TEXTURE_2D,
1977                             resource_provider_->best_texture_format());
1978
1979    raster_worker_pool_ =
1980        OneCopyRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
1981                                        RasterWorkerPool::GetTaskGraphRunner(),
1982                                        context_provider,
1983                                        resource_provider_.get(),
1984                                        staging_resource_pool_.get());
1985  } else {
1986    resource_pool_ = ResourcePool::Create(
1987        resource_provider_.get(),
1988        GL_TEXTURE_2D,
1989        resource_provider_->memory_efficient_texture_format());
1990
1991    raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
1992        proxy_->ImplThreadTaskRunner(),
1993        RasterWorkerPool::GetTaskGraphRunner(),
1994        context_provider,
1995        resource_provider_.get(),
1996        GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
1997                                       settings_.refresh_rate));
1998  }
1999
2000  tile_manager_ =
2001      TileManager::Create(this,
2002                          proxy_->ImplThreadTaskRunner(),
2003                          resource_pool_.get(),
2004                          raster_worker_pool_->AsRasterizer(),
2005                          rendering_stats_instrumentation_);
2006
2007  UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
2008  need_to_update_visible_tiles_before_draw_ = false;
2009}
2010
2011void LayerTreeHostImpl::DestroyTileManager() {
2012  tile_manager_.reset();
2013  resource_pool_.reset();
2014  staging_resource_pool_.reset();
2015  raster_worker_pool_.reset();
2016}
2017
2018bool LayerTreeHostImpl::UsePendingTreeForSync() const {
2019  // In impl-side painting, synchronize to the pending tree so that it has
2020  // time to raster before being displayed.
2021  return settings_.impl_side_painting;
2022}
2023
2024bool LayerTreeHostImpl::UseZeroCopyRasterizer() const {
2025  return settings_.use_zero_copy && GetRendererCapabilities().using_map_image;
2026}
2027
2028bool LayerTreeHostImpl::UseOneCopyRasterizer() const {
2029  // Sync query support is required by one-copy rasterizer.
2030  return settings_.use_one_copy && GetRendererCapabilities().using_map_image &&
2031         resource_provider_->use_sync_query();
2032}
2033
2034void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
2035  SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
2036}
2037
2038bool LayerTreeHostImpl::InitializeRenderer(
2039    scoped_ptr<OutputSurface> output_surface) {
2040  TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
2041
2042  // Since we will create a new resource provider, we cannot continue to use
2043  // the old resources (i.e. render_surfaces and texture IDs). Clear them
2044  // before we destroy the old resource provider.
2045  ReleaseTreeResources();
2046
2047  // Note: order is important here.
2048  renderer_.reset();
2049  DestroyTileManager();
2050  resource_provider_.reset();
2051  output_surface_.reset();
2052
2053  if (!output_surface->BindToClient(this))
2054    return false;
2055
2056  output_surface_ = output_surface.Pass();
2057  resource_provider_ =
2058      ResourceProvider::Create(output_surface_.get(),
2059                               shared_bitmap_manager_,
2060                               proxy_->blocking_main_thread_task_runner(),
2061                               settings_.highp_threshold_min,
2062                               settings_.use_rgba_4444_textures,
2063                               settings_.texture_id_allocation_chunk_size,
2064                               settings_.use_distance_field_text);
2065
2066  if (output_surface_->capabilities().deferred_gl_initialization)
2067    EnforceZeroBudget(true);
2068
2069  CreateAndSetRenderer();
2070
2071  if (settings_.impl_side_painting)
2072    CreateAndSetTileManager();
2073
2074  // Initialize vsync parameters to sane values.
2075  const base::TimeDelta display_refresh_interval =
2076      base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond /
2077                                        settings_.refresh_rate);
2078  CommitVSyncParameters(base::TimeTicks(), display_refresh_interval);
2079
2080  // TODO(brianderson): Don't use a hard-coded parent draw time.
2081  base::TimeDelta parent_draw_time =
2082      (!settings_.begin_frame_scheduling_enabled &&
2083       output_surface_->capabilities().adjust_deadline_for_parent)
2084          ? BeginFrameArgs::DefaultEstimatedParentDrawTime()
2085          : base::TimeDelta();
2086  client_->SetEstimatedParentDrawTime(parent_draw_time);
2087
2088  int max_frames_pending = output_surface_->capabilities().max_frames_pending;
2089  if (max_frames_pending <= 0)
2090    max_frames_pending = OutputSurface::DEFAULT_MAX_FRAMES_PENDING;
2091  client_->SetMaxSwapsPendingOnImplThread(max_frames_pending);
2092  client_->OnCanDrawStateChanged(CanDraw());
2093
2094  // There will not be anything to draw here, so set high res
2095  // to avoid checkerboards, typically when we are recovering
2096  // from lost context.
2097  active_tree_->SetRequiresHighResToDraw();
2098
2099  return true;
2100}
2101
2102void LayerTreeHostImpl::CommitVSyncParameters(base::TimeTicks timebase,
2103                                              base::TimeDelta interval) {
2104  client_->CommitVSyncParameters(timebase, interval);
2105}
2106
2107void LayerTreeHostImpl::DeferredInitialize() {
2108  DCHECK(output_surface_->capabilities().deferred_gl_initialization);
2109  DCHECK(settings_.impl_side_painting);
2110  DCHECK(output_surface_->context_provider());
2111
2112  ReleaseTreeResources();
2113  renderer_.reset();
2114  DestroyTileManager();
2115
2116  resource_provider_->InitializeGL();
2117
2118  CreateAndSetRenderer();
2119  EnforceZeroBudget(false);
2120  CreateAndSetTileManager();
2121
2122  client_->SetNeedsCommitOnImplThread();
2123}
2124
2125void LayerTreeHostImpl::ReleaseGL() {
2126  DCHECK(output_surface_->capabilities().deferred_gl_initialization);
2127  DCHECK(settings_.impl_side_painting);
2128  DCHECK(output_surface_->context_provider());
2129
2130  ReleaseTreeResources();
2131  renderer_.reset();
2132  DestroyTileManager();
2133
2134  resource_provider_->InitializeSoftware();
2135  output_surface_->ReleaseContextProvider();
2136
2137  CreateAndSetRenderer();
2138  EnforceZeroBudget(true);
2139  CreateAndSetTileManager();
2140
2141  client_->SetNeedsCommitOnImplThread();
2142}
2143
2144void LayerTreeHostImpl::SetViewportSize(const gfx::Size& device_viewport_size) {
2145  if (device_viewport_size == device_viewport_size_)
2146    return;
2147
2148  if (pending_tree_)
2149    active_tree_->SetViewportSizeInvalid();
2150
2151  device_viewport_size_ = device_viewport_size;
2152
2153  UpdateInnerViewportContainerSize();
2154  client_->OnCanDrawStateChanged(CanDraw());
2155  SetFullRootLayerDamage();
2156  active_tree_->set_needs_update_draw_properties();
2157}
2158
2159void LayerTreeHostImpl::SetOverhangUIResource(
2160    UIResourceId overhang_ui_resource_id,
2161    const gfx::Size& overhang_ui_resource_size) {
2162  overhang_ui_resource_id_ = overhang_ui_resource_id;
2163  overhang_ui_resource_size_ = overhang_ui_resource_size;
2164}
2165
2166void LayerTreeHostImpl::SetDeviceScaleFactor(float device_scale_factor) {
2167  if (device_scale_factor == device_scale_factor_)
2168    return;
2169  device_scale_factor_ = device_scale_factor;
2170
2171  SetFullRootLayerDamage();
2172}
2173
2174const gfx::Rect LayerTreeHostImpl::ViewportRectForTilePriority() const {
2175  if (viewport_rect_for_tile_priority_.IsEmpty())
2176    return DeviceViewport();
2177
2178  return viewport_rect_for_tile_priority_;
2179}
2180
2181gfx::Size LayerTreeHostImpl::DrawViewportSize() const {
2182  return DeviceViewport().size();
2183}
2184
2185gfx::Rect LayerTreeHostImpl::DeviceViewport() const {
2186  if (external_viewport_.IsEmpty())
2187    return gfx::Rect(device_viewport_size_);
2188
2189  return external_viewport_;
2190}
2191
2192gfx::Rect LayerTreeHostImpl::DeviceClip() const {
2193  if (external_clip_.IsEmpty())
2194    return DeviceViewport();
2195
2196  return external_clip_;
2197}
2198
2199const gfx::Transform& LayerTreeHostImpl::DrawTransform() const {
2200  return external_transform_;
2201}
2202
2203void LayerTreeHostImpl::DidChangeTopControlsPosition() {
2204  UpdateInnerViewportContainerSize();
2205  SetNeedsRedraw();
2206  SetNeedsAnimate();
2207  active_tree_->set_needs_update_draw_properties();
2208  SetFullRootLayerDamage();
2209}
2210
2211void LayerTreeHostImpl::SetControlsTopOffset(float offset) {
2212  float current_top_offset = active_tree_->top_controls_content_offset() -
2213      top_controls_manager_->top_controls_height();
2214  active_tree_->set_top_controls_delta(offset - current_top_offset);
2215}
2216
2217float LayerTreeHostImpl::ControlsTopOffset() const {
2218  return active_tree_->total_top_controls_content_offset() -
2219      top_controls_manager_->top_controls_height();
2220}
2221
2222void LayerTreeHostImpl::BindToClient(InputHandlerClient* client) {
2223  DCHECK(input_handler_client_ == NULL);
2224  input_handler_client_ = client;
2225}
2226
2227static LayerImpl* NextScrollLayer(LayerImpl* layer) {
2228  if (LayerImpl* scroll_parent = layer->scroll_parent())
2229    return scroll_parent;
2230  return layer->parent();
2231}
2232
2233LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
2234    const gfx::PointF& device_viewport_point,
2235    InputHandler::ScrollInputType type,
2236    LayerImpl* layer_impl,
2237    bool* scroll_on_main_thread,
2238    bool* optional_has_ancestor_scroll_handler) const {
2239  DCHECK(scroll_on_main_thread);
2240
2241  // Walk up the hierarchy and look for a scrollable layer.
2242  LayerImpl* potentially_scrolling_layer_impl = NULL;
2243  for (; layer_impl; layer_impl = NextScrollLayer(layer_impl)) {
2244    // The content layer can also block attempts to scroll outside the main
2245    // thread.
2246    ScrollStatus status = layer_impl->TryScroll(device_viewport_point, type);
2247    if (status == ScrollOnMainThread) {
2248      *scroll_on_main_thread = true;
2249      return NULL;
2250    }
2251
2252    LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
2253    if (!scroll_layer_impl)
2254      continue;
2255
2256    status = scroll_layer_impl->TryScroll(device_viewport_point, type);
2257    // If any layer wants to divert the scroll event to the main thread, abort.
2258    if (status == ScrollOnMainThread) {
2259      *scroll_on_main_thread = true;
2260      return NULL;
2261    }
2262
2263    if (optional_has_ancestor_scroll_handler &&
2264        scroll_layer_impl->have_scroll_event_handlers())
2265      *optional_has_ancestor_scroll_handler = true;
2266
2267    if (status == ScrollStarted && !potentially_scrolling_layer_impl)
2268      potentially_scrolling_layer_impl = scroll_layer_impl;
2269  }
2270
2271  // Falling back to the root scroll layer ensures generation of root overscroll
2272  // notifications while preventing scroll updates from being unintentionally
2273  // forwarded to the main thread.
2274  if (!potentially_scrolling_layer_impl)
2275    potentially_scrolling_layer_impl = OuterViewportScrollLayer()
2276                                           ? OuterViewportScrollLayer()
2277                                           : InnerViewportScrollLayer();
2278
2279  return potentially_scrolling_layer_impl;
2280}
2281
2282// Similar to LayerImpl::HasAncestor, but walks up the scroll parents.
2283static bool HasScrollAncestor(LayerImpl* child, LayerImpl* scroll_ancestor) {
2284  DCHECK(scroll_ancestor);
2285  for (LayerImpl* ancestor = child; ancestor;
2286       ancestor = NextScrollLayer(ancestor)) {
2287    if (ancestor->scrollable())
2288      return ancestor == scroll_ancestor;
2289  }
2290  return false;
2291}
2292
2293InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
2294    const gfx::Point& viewport_point,
2295    InputHandler::ScrollInputType type) {
2296  TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
2297
2298  if (top_controls_manager_)
2299    top_controls_manager_->ScrollBegin();
2300
2301  DCHECK(!CurrentlyScrollingLayer());
2302  ClearCurrentlyScrollingLayer();
2303
2304  gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
2305                                                      device_scale_factor_);
2306  LayerImpl* layer_impl =
2307      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
2308
2309  if (layer_impl) {
2310    LayerImpl* scroll_layer_impl =
2311        active_tree_->FindFirstScrollingLayerThatIsHitByPoint(
2312            device_viewport_point);
2313    if (scroll_layer_impl && !HasScrollAncestor(layer_impl, scroll_layer_impl))
2314      return ScrollUnknown;
2315  }
2316
2317  bool scroll_on_main_thread = false;
2318  LayerImpl* scrolling_layer_impl =
2319      FindScrollLayerForDeviceViewportPoint(device_viewport_point,
2320                                            type,
2321                                            layer_impl,
2322                                            &scroll_on_main_thread,
2323                                            &scroll_affects_scroll_handler_);
2324
2325  if (scroll_on_main_thread) {
2326    UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
2327    return ScrollOnMainThread;
2328  }
2329
2330  if (scrolling_layer_impl) {
2331    active_tree_->SetCurrentlyScrollingLayer(scrolling_layer_impl);
2332    should_bubble_scrolls_ = (type != NonBubblingGesture);
2333    wheel_scrolling_ = (type == Wheel);
2334    client_->RenewTreePriority();
2335    UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
2336    return ScrollStarted;
2337  }
2338  return ScrollIgnored;
2339}
2340
2341InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
2342    const gfx::Point& viewport_point,
2343    const gfx::Vector2dF& scroll_delta) {
2344  if (LayerImpl* layer_impl = CurrentlyScrollingLayer()) {
2345    Animation* animation =
2346        layer_impl->layer_animation_controller()->GetAnimation(
2347            Animation::ScrollOffset);
2348    if (!animation)
2349      return ScrollIgnored;
2350
2351    ScrollOffsetAnimationCurve* curve =
2352        animation->curve()->ToScrollOffsetAnimationCurve();
2353
2354    gfx::Vector2dF new_target = curve->target_value() + scroll_delta;
2355    new_target.SetToMax(gfx::Vector2dF());
2356    new_target.SetToMin(layer_impl->MaxScrollOffset());
2357
2358    curve->UpdateTarget(animation->TrimTimeToCurrentIteration(
2359                            CurrentBeginFrameArgs().frame_time),
2360                        new_target);
2361
2362    return ScrollStarted;
2363  }
2364  // ScrollAnimated is only used for wheel scrolls. We use the same bubbling
2365  // behavior as ScrollBy to determine which layer to animate, but we do not
2366  // do the Android-specific things in ScrollBy like showing top controls.
2367  InputHandler::ScrollStatus scroll_status = ScrollBegin(viewport_point, Wheel);
2368  if (scroll_status == ScrollStarted) {
2369    gfx::Vector2dF pending_delta = scroll_delta;
2370    for (LayerImpl* layer_impl = CurrentlyScrollingLayer(); layer_impl;
2371         layer_impl = layer_impl->parent()) {
2372      if (!layer_impl->scrollable())
2373        continue;
2374
2375      gfx::Vector2dF current_offset = layer_impl->TotalScrollOffset();
2376      gfx::Vector2dF target_offset = current_offset + pending_delta;
2377      target_offset.SetToMax(gfx::Vector2dF());
2378      target_offset.SetToMin(layer_impl->MaxScrollOffset());
2379      gfx::Vector2dF actual_delta = target_offset - current_offset;
2380
2381      const float kEpsilon = 0.1f;
2382      bool can_layer_scroll = (std::abs(actual_delta.x()) > kEpsilon ||
2383                               std::abs(actual_delta.y()) > kEpsilon);
2384
2385      if (!can_layer_scroll) {
2386        layer_impl->ScrollBy(actual_delta);
2387        pending_delta -= actual_delta;
2388        continue;
2389      }
2390
2391      active_tree_->SetCurrentlyScrollingLayer(layer_impl);
2392
2393      scoped_ptr<ScrollOffsetAnimationCurve> curve =
2394          ScrollOffsetAnimationCurve::Create(target_offset,
2395                                             EaseInOutTimingFunction::Create());
2396      curve->SetInitialValue(current_offset);
2397
2398      scoped_ptr<Animation> animation =
2399          Animation::Create(curve.PassAs<AnimationCurve>(),
2400                            AnimationIdProvider::NextAnimationId(),
2401                            AnimationIdProvider::NextGroupId(),
2402                            Animation::ScrollOffset);
2403      animation->set_is_impl_only(true);
2404
2405      layer_impl->layer_animation_controller()->AddAnimation(animation.Pass());
2406
2407      SetNeedsAnimate();
2408      return ScrollStarted;
2409    }
2410  }
2411  ScrollEnd();
2412  return scroll_status;
2413}
2414
2415gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
2416    LayerImpl* layer_impl,
2417    float scale_from_viewport_to_screen_space,
2418    const gfx::PointF& viewport_point,
2419    const gfx::Vector2dF& viewport_delta) {
2420  // Layers with non-invertible screen space transforms should not have passed
2421  // the scroll hit test in the first place.
2422  DCHECK(layer_impl->screen_space_transform().IsInvertible());
2423  gfx::Transform inverse_screen_space_transform(
2424      gfx::Transform::kSkipInitialization);
2425  bool did_invert = layer_impl->screen_space_transform().GetInverse(
2426      &inverse_screen_space_transform);
2427  // TODO(shawnsingh): With the advent of impl-side crolling for non-root
2428  // layers, we may need to explicitly handle uninvertible transforms here.
2429  DCHECK(did_invert);
2430
2431  gfx::PointF screen_space_point =
2432      gfx::ScalePoint(viewport_point, scale_from_viewport_to_screen_space);
2433
2434  gfx::Vector2dF screen_space_delta = viewport_delta;
2435  screen_space_delta.Scale(scale_from_viewport_to_screen_space);
2436
2437  // First project the scroll start and end points to local layer space to find
2438  // the scroll delta in layer coordinates.
2439  bool start_clipped, end_clipped;
2440  gfx::PointF screen_space_end_point = screen_space_point + screen_space_delta;
2441  gfx::PointF local_start_point =
2442      MathUtil::ProjectPoint(inverse_screen_space_transform,
2443                             screen_space_point,
2444                             &start_clipped);
2445  gfx::PointF local_end_point =
2446      MathUtil::ProjectPoint(inverse_screen_space_transform,
2447                             screen_space_end_point,
2448                             &end_clipped);
2449
2450  // In general scroll point coordinates should not get clipped.
2451  DCHECK(!start_clipped);
2452  DCHECK(!end_clipped);
2453  if (start_clipped || end_clipped)
2454    return gfx::Vector2dF();
2455
2456  // local_start_point and local_end_point are in content space but we want to
2457  // move them to layer space for scrolling.
2458  float width_scale = 1.f / layer_impl->contents_scale_x();
2459  float height_scale = 1.f / layer_impl->contents_scale_y();
2460  local_start_point.Scale(width_scale, height_scale);
2461  local_end_point.Scale(width_scale, height_scale);
2462
2463  // Apply the scroll delta.
2464  gfx::Vector2dF previous_delta = layer_impl->ScrollDelta();
2465  layer_impl->ScrollBy(local_end_point - local_start_point);
2466
2467  // Get the end point in the layer's content space so we can apply its
2468  // ScreenSpaceTransform.
2469  gfx::PointF actual_local_end_point = local_start_point +
2470                                       layer_impl->ScrollDelta() -
2471                                       previous_delta;
2472  gfx::PointF actual_local_content_end_point =
2473      gfx::ScalePoint(actual_local_end_point,
2474                      1.f / width_scale,
2475                      1.f / height_scale);
2476
2477  // Calculate the applied scroll delta in viewport space coordinates.
2478  gfx::PointF actual_screen_space_end_point =
2479      MathUtil::MapPoint(layer_impl->screen_space_transform(),
2480                         actual_local_content_end_point,
2481                         &end_clipped);
2482  DCHECK(!end_clipped);
2483  if (end_clipped)
2484    return gfx::Vector2dF();
2485  gfx::PointF actual_viewport_end_point =
2486      gfx::ScalePoint(actual_screen_space_end_point,
2487                      1.f / scale_from_viewport_to_screen_space);
2488  return actual_viewport_end_point - viewport_point;
2489}
2490
2491static gfx::Vector2dF ScrollLayerWithLocalDelta(LayerImpl* layer_impl,
2492    const gfx::Vector2dF& local_delta) {
2493  gfx::Vector2dF previous_delta(layer_impl->ScrollDelta());
2494  layer_impl->ScrollBy(local_delta);
2495  return layer_impl->ScrollDelta() - previous_delta;
2496}
2497
2498bool LayerTreeHostImpl::ScrollBy(const gfx::Point& viewport_point,
2499                                 const gfx::Vector2dF& scroll_delta) {
2500  TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
2501  if (!CurrentlyScrollingLayer())
2502    return false;
2503
2504  gfx::Vector2dF pending_delta = scroll_delta;
2505  gfx::Vector2dF unused_root_delta;
2506  bool did_scroll_x = false;
2507  bool did_scroll_y = false;
2508  bool did_scroll_top_controls = false;
2509  // TODO(wjmaclean) Should we guard against CurrentlyScrollingLayer() == 0
2510  // here?
2511  bool consume_by_top_controls =
2512      top_controls_manager_ &&
2513      (((CurrentlyScrollingLayer() == InnerViewportScrollLayer() ||
2514         CurrentlyScrollingLayer() == OuterViewportScrollLayer()) &&
2515        InnerViewportScrollLayer()->MaxScrollOffset().y() > 0) ||
2516       scroll_delta.y() < 0);
2517
2518  for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
2519       layer_impl;
2520       layer_impl = layer_impl->parent()) {
2521    if (!layer_impl->scrollable())
2522      continue;
2523
2524    if (layer_impl == InnerViewportScrollLayer()) {
2525      // Only allow bubble scrolling when the scroll is in the direction to make
2526      // the top controls visible.
2527      gfx::Vector2dF applied_delta;
2528      gfx::Vector2dF excess_delta;
2529      if (consume_by_top_controls) {
2530        excess_delta = top_controls_manager_->ScrollBy(pending_delta);
2531        applied_delta = pending_delta - excess_delta;
2532        pending_delta = excess_delta;
2533        // Force updating of vertical adjust values if needed.
2534        if (applied_delta.y() != 0) {
2535          did_scroll_top_controls = true;
2536          layer_impl->ScrollbarParametersDidChange();
2537        }
2538      }
2539      // Track root layer deltas for reporting overscroll.
2540      unused_root_delta = pending_delta;
2541    }
2542
2543    gfx::Vector2dF applied_delta;
2544    // Gesture events need to be transformed from viewport coordinates to local
2545    // layer coordinates so that the scrolling contents exactly follow the
2546    // user's finger. In contrast, wheel events represent a fixed amount of
2547    // scrolling so we can just apply them directly.
2548    if (!wheel_scrolling_) {
2549      float scale_from_viewport_to_screen_space = device_scale_factor_;
2550      applied_delta =
2551          ScrollLayerWithViewportSpaceDelta(layer_impl,
2552                                            scale_from_viewport_to_screen_space,
2553                                            viewport_point, pending_delta);
2554    } else {
2555      applied_delta = ScrollLayerWithLocalDelta(layer_impl, pending_delta);
2556    }
2557
2558    const float kEpsilon = 0.1f;
2559    if (layer_impl == InnerViewportScrollLayer()) {
2560      unused_root_delta.Subtract(applied_delta);
2561      if (std::abs(unused_root_delta.x()) < kEpsilon)
2562        unused_root_delta.set_x(0.0f);
2563      if (std::abs(unused_root_delta.y()) < kEpsilon)
2564        unused_root_delta.set_y(0.0f);
2565      // Disable overscroll on axes which is impossible to scroll.
2566      if (settings_.report_overscroll_only_for_scrollable_axes) {
2567        if (std::abs(active_tree_->TotalMaxScrollOffset().x()) <= kEpsilon)
2568          unused_root_delta.set_x(0.0f);
2569        if (std::abs(active_tree_->TotalMaxScrollOffset().y()) <= kEpsilon)
2570          unused_root_delta.set_y(0.0f);
2571      }
2572    }
2573
2574    // If the layer wasn't able to move, try the next one in the hierarchy.
2575    bool did_move_layer_x = std::abs(applied_delta.x()) > kEpsilon;
2576    bool did_move_layer_y = std::abs(applied_delta.y()) > kEpsilon;
2577    did_scroll_x |= did_move_layer_x;
2578    did_scroll_y |= did_move_layer_y;
2579    if (!did_move_layer_x && !did_move_layer_y) {
2580      // Scrolls should always bubble between the outer and inner viewports
2581      if (should_bubble_scrolls_ || !did_lock_scrolling_layer_ ||
2582          layer_impl == OuterViewportScrollLayer())
2583        continue;
2584      else
2585        break;
2586    }
2587
2588    did_lock_scrolling_layer_ = true;
2589    if (!should_bubble_scrolls_) {
2590      active_tree_->SetCurrentlyScrollingLayer(layer_impl);
2591      break;
2592    }
2593
2594    // If the applied delta is within 45 degrees of the input delta, bail out to
2595    // make it easier to scroll just one layer in one direction without
2596    // affecting any of its parents.
2597    float angle_threshold = 45;
2598    if (MathUtil::SmallestAngleBetweenVectors(
2599            applied_delta, pending_delta) < angle_threshold) {
2600      pending_delta = gfx::Vector2d();
2601      break;
2602    }
2603
2604    // Allow further movement only on an axis perpendicular to the direction in
2605    // which the layer moved.
2606    gfx::Vector2dF perpendicular_axis(-applied_delta.y(), applied_delta.x());
2607    pending_delta = MathUtil::ProjectVector(pending_delta, perpendicular_axis);
2608
2609    if (gfx::ToRoundedVector2d(pending_delta).IsZero())
2610      break;
2611  }
2612
2613  bool did_scroll_content = did_scroll_x || did_scroll_y;
2614  if (did_scroll_content) {
2615    // If we are scrolling with an active scroll handler, forward latency
2616    // tracking information to the main thread so the delay introduced by the
2617    // handler is accounted for.
2618    if (scroll_affects_scroll_handler())
2619      NotifySwapPromiseMonitorsOfForwardingToMainThread();
2620    client_->SetNeedsCommitOnImplThread();
2621    SetNeedsRedraw();
2622    client_->RenewTreePriority();
2623  }
2624
2625  // Scrolling along an axis resets accumulated root overscroll for that axis.
2626  if (did_scroll_x)
2627    accumulated_root_overscroll_.set_x(0);
2628  if (did_scroll_y)
2629    accumulated_root_overscroll_.set_y(0);
2630
2631  accumulated_root_overscroll_ += unused_root_delta;
2632  bool did_overscroll = !unused_root_delta.IsZero();
2633  if (did_overscroll && input_handler_client_) {
2634    input_handler_client_->DidOverscroll(
2635        viewport_point, accumulated_root_overscroll_, unused_root_delta);
2636  }
2637
2638  return did_scroll_content || did_scroll_top_controls;
2639}
2640
2641// This implements scrolling by page as described here:
2642// http://msdn.microsoft.com/en-us/library/windows/desktop/ms645601(v=vs.85).aspx#_win32_The_Mouse_Wheel
2643// for events with WHEEL_PAGESCROLL set.
2644bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point& viewport_point,
2645                                               ScrollDirection direction) {
2646  DCHECK(wheel_scrolling_);
2647
2648  for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
2649       layer_impl;
2650       layer_impl = layer_impl->parent()) {
2651    if (!layer_impl->scrollable())
2652      continue;
2653
2654    if (!layer_impl->HasScrollbar(VERTICAL))
2655      continue;
2656
2657    float height = layer_impl->clip_height();
2658
2659    // These magical values match WebKit and are designed to scroll nearly the
2660    // entire visible content height but leave a bit of overlap.
2661    float page = std::max(height * 0.875f, 1.f);
2662    if (direction == SCROLL_BACKWARD)
2663      page = -page;
2664
2665    gfx::Vector2dF delta = gfx::Vector2dF(0.f, page);
2666
2667    gfx::Vector2dF applied_delta = ScrollLayerWithLocalDelta(layer_impl, delta);
2668
2669    if (!applied_delta.IsZero()) {
2670      client_->SetNeedsCommitOnImplThread();
2671      SetNeedsRedraw();
2672      client_->RenewTreePriority();
2673      return true;
2674    }
2675
2676    active_tree_->SetCurrentlyScrollingLayer(layer_impl);
2677  }
2678
2679  return false;
2680}
2681
2682void LayerTreeHostImpl::SetRootLayerScrollOffsetDelegate(
2683      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
2684  root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
2685  active_tree_->SetRootLayerScrollOffsetDelegate(
2686      root_layer_scroll_offset_delegate_);
2687}
2688
2689void LayerTreeHostImpl::OnRootLayerDelegatedScrollOffsetChanged() {
2690  DCHECK(root_layer_scroll_offset_delegate_ != NULL);
2691  client_->SetNeedsCommitOnImplThread();
2692  active_tree_->set_needs_update_draw_properties();
2693}
2694
2695void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
2696  active_tree_->ClearCurrentlyScrollingLayer();
2697  did_lock_scrolling_layer_ = false;
2698  scroll_affects_scroll_handler_ = false;
2699  accumulated_root_overscroll_ = gfx::Vector2dF();
2700}
2701
2702void LayerTreeHostImpl::ScrollEnd() {
2703  if (top_controls_manager_)
2704    top_controls_manager_->ScrollEnd();
2705  ClearCurrentlyScrollingLayer();
2706}
2707
2708InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
2709  if (!active_tree_->CurrentlyScrollingLayer())
2710    return ScrollIgnored;
2711
2712  if (settings_.ignore_root_layer_flings &&
2713      (active_tree_->CurrentlyScrollingLayer() == InnerViewportScrollLayer() ||
2714       active_tree_->CurrentlyScrollingLayer() == OuterViewportScrollLayer())) {
2715    ClearCurrentlyScrollingLayer();
2716    return ScrollIgnored;
2717  }
2718
2719  if (!wheel_scrolling_) {
2720    // Allow the fling to lock to the first layer that moves after the initial
2721    // fling |ScrollBy()| event.
2722    did_lock_scrolling_layer_ = false;
2723    should_bubble_scrolls_ = false;
2724  }
2725
2726  return ScrollStarted;
2727}
2728
2729float LayerTreeHostImpl::DeviceSpaceDistanceToLayer(
2730    const gfx::PointF& device_viewport_point,
2731    LayerImpl* layer_impl) {
2732  if (!layer_impl)
2733    return std::numeric_limits<float>::max();
2734
2735  gfx::Rect layer_impl_bounds(
2736      layer_impl->content_bounds());
2737
2738  gfx::RectF device_viewport_layer_impl_bounds = MathUtil::MapClippedRect(
2739      layer_impl->screen_space_transform(),
2740      layer_impl_bounds);
2741
2742  return device_viewport_layer_impl_bounds.ManhattanDistanceToPoint(
2743      device_viewport_point);
2744}
2745
2746void LayerTreeHostImpl::MouseMoveAt(const gfx::Point& viewport_point) {
2747  gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
2748                                                      device_scale_factor_);
2749  LayerImpl* layer_impl =
2750      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
2751  if (HandleMouseOverScrollbar(layer_impl, device_viewport_point))
2752    return;
2753
2754  if (scroll_layer_id_when_mouse_over_scrollbar_) {
2755    LayerImpl* scroll_layer_impl = active_tree_->LayerById(
2756        scroll_layer_id_when_mouse_over_scrollbar_);
2757
2758    // The check for a null scroll_layer_impl below was added to see if it will
2759    // eliminate the crashes described in http://crbug.com/326635.
2760    // TODO(wjmaclean) Add a unit test if this fixes the crashes.
2761    ScrollbarAnimationController* animation_controller =
2762        scroll_layer_impl ? scroll_layer_impl->scrollbar_animation_controller()
2763                          : NULL;
2764    if (animation_controller)
2765      animation_controller->DidMouseMoveOffScrollbar();
2766    scroll_layer_id_when_mouse_over_scrollbar_ = 0;
2767  }
2768
2769  bool scroll_on_main_thread = false;
2770  LayerImpl* scroll_layer_impl =
2771      FindScrollLayerForDeviceViewportPoint(device_viewport_point,
2772                                            InputHandler::Gesture,
2773                                            layer_impl,
2774                                            &scroll_on_main_thread,
2775                                            NULL);
2776  if (scroll_on_main_thread || !scroll_layer_impl)
2777    return;
2778
2779  ScrollbarAnimationController* animation_controller =
2780      scroll_layer_impl->scrollbar_animation_controller();
2781  if (!animation_controller)
2782    return;
2783
2784  // TODO(wjmaclean) Is it ok to choose distance from more than two scrollbars?
2785  float distance_to_scrollbar = std::numeric_limits<float>::max();
2786  for (LayerImpl::ScrollbarSet::iterator it =
2787           scroll_layer_impl->scrollbars()->begin();
2788       it != scroll_layer_impl->scrollbars()->end();
2789       ++it)
2790    distance_to_scrollbar =
2791        std::min(distance_to_scrollbar,
2792                 DeviceSpaceDistanceToLayer(device_viewport_point, *it));
2793
2794  animation_controller->DidMouseMoveNear(distance_to_scrollbar /
2795                                         device_scale_factor_);
2796}
2797
2798bool LayerTreeHostImpl::HandleMouseOverScrollbar(LayerImpl* layer_impl,
2799    const gfx::PointF& device_viewport_point) {
2800  if (layer_impl && layer_impl->ToScrollbarLayer()) {
2801    int scroll_layer_id = layer_impl->ToScrollbarLayer()->ScrollLayerId();
2802    layer_impl = active_tree_->LayerById(scroll_layer_id);
2803    if (layer_impl && layer_impl->scrollbar_animation_controller()) {
2804      scroll_layer_id_when_mouse_over_scrollbar_ = scroll_layer_id;
2805      layer_impl->scrollbar_animation_controller()->DidMouseMoveNear(0);
2806    } else {
2807      scroll_layer_id_when_mouse_over_scrollbar_ = 0;
2808    }
2809
2810    return true;
2811  }
2812
2813  return false;
2814}
2815
2816void LayerTreeHostImpl::PinchGestureBegin() {
2817  pinch_gesture_active_ = true;
2818  previous_pinch_anchor_ = gfx::Point();
2819  client_->RenewTreePriority();
2820  pinch_gesture_end_should_clear_scrolling_layer_ = !CurrentlyScrollingLayer();
2821  if (active_tree_->OuterViewportScrollLayer()) {
2822    active_tree_->SetCurrentlyScrollingLayer(
2823        active_tree_->OuterViewportScrollLayer());
2824  } else {
2825    active_tree_->SetCurrentlyScrollingLayer(
2826        active_tree_->InnerViewportScrollLayer());
2827  }
2828  if (top_controls_manager_)
2829    top_controls_manager_->PinchBegin();
2830}
2831
2832void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
2833                                           const gfx::Point& anchor) {
2834  if (!InnerViewportScrollLayer())
2835    return;
2836
2837  TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
2838
2839  // For a moment the scroll offset ends up being outside of the max range. This
2840  // confuses the delegate so we switch it off till after we're done processing
2841  // the pinch update.
2842  active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
2843
2844  // Keep the center-of-pinch anchor specified by (x, y) in a stable
2845  // position over the course of the magnify.
2846  float page_scale_delta = active_tree_->page_scale_delta();
2847  gfx::PointF previous_scale_anchor =
2848      gfx::ScalePoint(anchor, 1.f / page_scale_delta);
2849  active_tree_->SetPageScaleDelta(page_scale_delta * magnify_delta);
2850  page_scale_delta = active_tree_->page_scale_delta();
2851  gfx::PointF new_scale_anchor =
2852      gfx::ScalePoint(anchor, 1.f / page_scale_delta);
2853  gfx::Vector2dF move = previous_scale_anchor - new_scale_anchor;
2854
2855  previous_pinch_anchor_ = anchor;
2856
2857  move.Scale(1 / active_tree_->page_scale_factor());
2858  // If clamping the inner viewport scroll offset causes a change, it should
2859  // be accounted for from the intended move.
2860  move -= InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
2861
2862  // We manually manage the bubbling behaviour here as it is different to that
2863  // implemented in LayerTreeHostImpl::ScrollBy(). Specifically:
2864  // 1) we want to explicit limit the bubbling to the outer/inner viewports,
2865  // 2) we don't want the directional limitations on the unused parts that
2866  //    ScrollBy() implements, and
2867  // 3) pinching should not engage the top controls manager.
2868  gfx::Vector2dF unused = OuterViewportScrollLayer()
2869                              ? OuterViewportScrollLayer()->ScrollBy(move)
2870                              : move;
2871
2872  if (!unused.IsZero()) {
2873    InnerViewportScrollLayer()->ScrollBy(unused);
2874    InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
2875  }
2876
2877  active_tree_->SetRootLayerScrollOffsetDelegate(
2878      root_layer_scroll_offset_delegate_);
2879
2880  client_->SetNeedsCommitOnImplThread();
2881  SetNeedsRedraw();
2882  client_->RenewTreePriority();
2883}
2884
2885void LayerTreeHostImpl::PinchGestureEnd() {
2886  pinch_gesture_active_ = false;
2887  if (pinch_gesture_end_should_clear_scrolling_layer_) {
2888    pinch_gesture_end_should_clear_scrolling_layer_ = false;
2889    ClearCurrentlyScrollingLayer();
2890  }
2891  if (top_controls_manager_)
2892    top_controls_manager_->PinchEnd();
2893  client_->SetNeedsCommitOnImplThread();
2894  // When a pinch ends, we may be displaying content cached at incorrect scales,
2895  // so updating draw properties and drawing will ensure we are using the right
2896  // scales that we want when we're not inside a pinch.
2897  active_tree_->set_needs_update_draw_properties();
2898  SetNeedsRedraw();
2899  // TODO(danakj): Don't set root damage. Just updating draw properties and
2900  // getting new tiles rastered should be enough! crbug.com/427423
2901  SetFullRootLayerDamage();
2902}
2903
2904static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
2905                                LayerImpl* layer_impl) {
2906  if (!layer_impl)
2907    return;
2908
2909  gfx::Vector2d scroll_delta =
2910      gfx::ToFlooredVector2d(layer_impl->ScrollDelta());
2911  if (!scroll_delta.IsZero()) {
2912    LayerTreeHostCommon::ScrollUpdateInfo scroll;
2913    scroll.layer_id = layer_impl->id();
2914    scroll.scroll_delta = scroll_delta;
2915    scroll_info->scrolls.push_back(scroll);
2916    layer_impl->SetSentScrollDelta(scroll_delta);
2917  }
2918
2919  for (size_t i = 0; i < layer_impl->children().size(); ++i)
2920    CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
2921}
2922
2923scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
2924  scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
2925
2926  CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
2927  scroll_info->page_scale_delta = active_tree_->page_scale_delta();
2928  active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
2929  scroll_info->swap_promises.swap(swap_promises_for_main_thread_scroll_update_);
2930  scroll_info->top_controls_delta = active_tree()->top_controls_delta();
2931  active_tree_->set_sent_top_controls_delta(scroll_info->top_controls_delta);
2932
2933  return scroll_info.Pass();
2934}
2935
2936void LayerTreeHostImpl::SetFullRootLayerDamage() {
2937  SetViewportDamage(gfx::Rect(DrawViewportSize()));
2938}
2939
2940void LayerTreeHostImpl::ScrollViewportBy(gfx::Vector2dF scroll_delta) {
2941  DCHECK(InnerViewportScrollLayer());
2942  LayerImpl* scroll_layer = OuterViewportScrollLayer()
2943                                ? OuterViewportScrollLayer()
2944                                : InnerViewportScrollLayer();
2945
2946  gfx::Vector2dF unused_delta = scroll_layer->ScrollBy(scroll_delta);
2947
2948  if (!unused_delta.IsZero() && (scroll_layer == OuterViewportScrollLayer()))
2949    InnerViewportScrollLayer()->ScrollBy(unused_delta);
2950}
2951
2952void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks monotonic_time) {
2953  if (!page_scale_animation_)
2954    return;
2955
2956  gfx::Vector2dF scroll_total = active_tree_->TotalScrollOffset();
2957
2958  if (!page_scale_animation_->IsAnimationStarted())
2959    page_scale_animation_->StartAnimation(monotonic_time);
2960
2961  active_tree_->SetPageScaleDelta(
2962      page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
2963      active_tree_->page_scale_factor());
2964  gfx::Vector2dF next_scroll =
2965      page_scale_animation_->ScrollOffsetAtTime(monotonic_time);
2966
2967  ScrollViewportBy(next_scroll - scroll_total);
2968  SetNeedsRedraw();
2969
2970  if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
2971    page_scale_animation_.reset();
2972    client_->SetNeedsCommitOnImplThread();
2973    client_->RenewTreePriority();
2974  } else {
2975    SetNeedsAnimate();
2976  }
2977}
2978
2979void LayerTreeHostImpl::AnimateTopControls(base::TimeTicks time) {
2980  if (!top_controls_manager_ || !top_controls_manager_->animation())
2981    return;
2982
2983  gfx::Vector2dF scroll = top_controls_manager_->Animate(time);
2984
2985  if (top_controls_manager_->animation())
2986    SetNeedsAnimate();
2987
2988  if (active_tree_->TotalScrollOffset().y() == 0.f)
2989    return;
2990
2991  if (scroll.IsZero())
2992    return;
2993
2994  ScrollViewportBy(gfx::ScaleVector2d(
2995      scroll, 1.f / active_tree_->total_page_scale_factor()));
2996  SetNeedsRedraw();
2997  client_->SetNeedsCommitOnImplThread();
2998  client_->RenewTreePriority();
2999}
3000
3001void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time) {
3002  if (!settings_.accelerated_animation_enabled ||
3003      !needs_animate_layers() ||
3004      !active_tree_->root_layer())
3005    return;
3006
3007  TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateLayers");
3008  AnimationRegistrar::AnimationControllerMap copy =
3009      animation_registrar_->active_animation_controllers();
3010  for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
3011       iter != copy.end();
3012       ++iter)
3013    (*iter).second->Animate(monotonic_time);
3014
3015  SetNeedsAnimate();
3016}
3017
3018void LayerTreeHostImpl::UpdateAnimationState(bool start_ready_animations) {
3019  if (!settings_.accelerated_animation_enabled ||
3020      !needs_animate_layers() ||
3021      !active_tree_->root_layer())
3022    return;
3023
3024  TRACE_EVENT0("cc", "LayerTreeHostImpl::UpdateAnimationState");
3025  scoped_ptr<AnimationEventsVector> events =
3026      make_scoped_ptr(new AnimationEventsVector);
3027  AnimationRegistrar::AnimationControllerMap copy =
3028      animation_registrar_->active_animation_controllers();
3029  for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
3030       iter != copy.end();
3031       ++iter)
3032    (*iter).second->UpdateState(start_ready_animations, events.get());
3033
3034  if (!events->empty()) {
3035    client_->PostAnimationEventsToMainThreadOnImplThread(events.Pass());
3036  }
3037
3038  SetNeedsAnimate();
3039}
3040
3041void LayerTreeHostImpl::ActivateAnimations() {
3042  if (!settings_.accelerated_animation_enabled || !needs_animate_layers() ||
3043      !active_tree_->root_layer())
3044    return;
3045
3046  TRACE_EVENT0("cc", "LayerTreeHostImpl::ActivateAnimations");
3047  AnimationRegistrar::AnimationControllerMap copy =
3048      animation_registrar_->active_animation_controllers();
3049  for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
3050       iter != copy.end();
3051       ++iter)
3052    (*iter).second->ActivateAnimations();
3053}
3054
3055base::TimeDelta LayerTreeHostImpl::LowFrequencyAnimationInterval() const {
3056  return base::TimeDelta::FromSeconds(1);
3057}
3058
3059std::string LayerTreeHostImpl::LayerTreeAsJson() const {
3060  std::string str;
3061  if (active_tree_->root_layer()) {
3062    scoped_ptr<base::Value> json(active_tree_->root_layer()->LayerTreeAsJson());
3063    base::JSONWriter::WriteWithOptions(
3064        json.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
3065  }
3066  return str;
3067}
3068
3069int LayerTreeHostImpl::SourceAnimationFrameNumber() const {
3070  return fps_counter_->current_frame_number();
3071}
3072
3073void LayerTreeHostImpl::AnimateScrollbars(base::TimeTicks time) {
3074  AnimateScrollbarsRecursive(active_tree_->root_layer(), time);
3075}
3076
3077void LayerTreeHostImpl::AnimateScrollbarsRecursive(LayerImpl* layer,
3078                                                   base::TimeTicks time) {
3079  if (!layer)
3080    return;
3081
3082  ScrollbarAnimationController* scrollbar_controller =
3083      layer->scrollbar_animation_controller();
3084  if (scrollbar_controller)
3085    scrollbar_controller->Animate(time);
3086
3087  for (size_t i = 0; i < layer->children().size(); ++i)
3088    AnimateScrollbarsRecursive(layer->children()[i], time);
3089}
3090
3091void LayerTreeHostImpl::PostDelayedScrollbarFade(
3092    const base::Closure& start_fade,
3093    base::TimeDelta delay) {
3094  client_->PostDelayedScrollbarFadeOnImplThread(start_fade, delay);
3095}
3096
3097void LayerTreeHostImpl::SetNeedsScrollbarAnimationFrame() {
3098  TRACE_EVENT_INSTANT0(
3099      "cc",
3100      "LayerTreeHostImpl::SetNeedsRedraw due to scrollbar fade",
3101      TRACE_EVENT_SCOPE_THREAD);
3102  SetNeedsAnimate();
3103}
3104
3105void LayerTreeHostImpl::SetTreePriority(TreePriority priority) {
3106  if (!tile_manager_)
3107    return;
3108
3109  if (global_tile_state_.tree_priority == priority)
3110    return;
3111  global_tile_state_.tree_priority = priority;
3112  DidModifyTilePriorities();
3113}
3114
3115void LayerTreeHostImpl::UpdateCurrentBeginFrameArgs(
3116    const BeginFrameArgs& args) {
3117  DCHECK(!current_begin_frame_args_.IsValid());
3118  current_begin_frame_args_ = args;
3119  // TODO(skyostil): Stop overriding the frame time once the usage of frame
3120  // timing is unified.
3121  current_begin_frame_args_.frame_time = gfx::FrameTime::Now();
3122}
3123
3124void LayerTreeHostImpl::ResetCurrentBeginFrameArgsForNextFrame() {
3125  current_begin_frame_args_ = BeginFrameArgs();
3126}
3127
3128BeginFrameArgs LayerTreeHostImpl::CurrentBeginFrameArgs() const {
3129  // Try to use the current frame time to keep animations non-jittery.  But if
3130  // we're not in a frame (because this is during an input event or a delayed
3131  // task), fall back to physical time.  This should still be monotonic.
3132  if (current_begin_frame_args_.IsValid())
3133    return current_begin_frame_args_;
3134  return BeginFrameArgs::Create(gfx::FrameTime::Now(),
3135                                base::TimeTicks(),
3136                                BeginFrameArgs::DefaultInterval());
3137}
3138
3139scoped_refptr<base::debug::ConvertableToTraceFormat>
3140LayerTreeHostImpl::AsValue() const {
3141  return AsValueWithFrame(NULL);
3142}
3143
3144scoped_refptr<base::debug::ConvertableToTraceFormat>
3145LayerTreeHostImpl::AsValueWithFrame(FrameData* frame) const {
3146  scoped_refptr<base::debug::TracedValue> state =
3147      new base::debug::TracedValue();
3148  AsValueWithFrameInto(frame, state.get());
3149  return state;
3150}
3151
3152void LayerTreeHostImpl::AsValueWithFrameInto(
3153    FrameData* frame,
3154    base::debug::TracedValue* state) const {
3155  if (this->pending_tree_) {
3156    state->BeginDictionary("activation_state");
3157    ActivationStateAsValueInto(state);
3158    state->EndDictionary();
3159  }
3160  state->BeginDictionary("device_viewport_size");
3161  MathUtil::AddToTracedValue(device_viewport_size_, state);
3162  state->EndDictionary();
3163
3164  std::set<const Tile*> tiles;
3165  active_tree_->GetAllTilesForTracing(&tiles);
3166  if (pending_tree_)
3167    pending_tree_->GetAllTilesForTracing(&tiles);
3168
3169  state->BeginArray("active_tiles");
3170  for (std::set<const Tile*>::const_iterator it = tiles.begin();
3171       it != tiles.end();
3172       ++it) {
3173    const Tile* tile = *it;
3174
3175    state->BeginDictionary();
3176    tile->AsValueInto(state);
3177    state->EndDictionary();
3178  }
3179  state->EndArray();
3180
3181  if (tile_manager_) {
3182    state->BeginDictionary("tile_manager_basic_state");
3183    tile_manager_->BasicStateAsValueInto(state);
3184    state->EndDictionary();
3185  }
3186  state->BeginDictionary("active_tree");
3187  active_tree_->AsValueInto(state);
3188  state->EndDictionary();
3189  if (pending_tree_) {
3190    state->BeginDictionary("pending_tree");
3191    pending_tree_->AsValueInto(state);
3192    state->EndDictionary();
3193  }
3194  if (frame) {
3195    state->BeginDictionary("frame");
3196    frame->AsValueInto(state);
3197    state->EndDictionary();
3198  }
3199}
3200
3201scoped_refptr<base::debug::ConvertableToTraceFormat>
3202LayerTreeHostImpl::ActivationStateAsValue() const {
3203  scoped_refptr<base::debug::TracedValue> state =
3204      new base::debug::TracedValue();
3205  ActivationStateAsValueInto(state.get());
3206  return state;
3207}
3208
3209void LayerTreeHostImpl::ActivationStateAsValueInto(
3210    base::debug::TracedValue* state) const {
3211  TracedValue::SetIDRef(this, state, "lthi");
3212  if (tile_manager_) {
3213    state->BeginDictionary("tile_manager");
3214    tile_manager_->BasicStateAsValueInto(state);
3215    state->EndDictionary();
3216  }
3217}
3218
3219void LayerTreeHostImpl::SetDebugState(
3220    const LayerTreeDebugState& new_debug_state) {
3221  if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
3222    return;
3223  if (debug_state_.continuous_painting != new_debug_state.continuous_painting)
3224    paint_time_counter_->ClearHistory();
3225
3226  debug_state_ = new_debug_state;
3227  UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
3228  SetFullRootLayerDamage();
3229}
3230
3231void LayerTreeHostImpl::CreateUIResource(UIResourceId uid,
3232                                         const UIResourceBitmap& bitmap) {
3233  DCHECK_GT(uid, 0);
3234
3235  GLint wrap_mode = 0;
3236  switch (bitmap.GetWrapMode()) {
3237    case UIResourceBitmap::CLAMP_TO_EDGE:
3238      wrap_mode = GL_CLAMP_TO_EDGE;
3239      break;
3240    case UIResourceBitmap::REPEAT:
3241      wrap_mode = GL_REPEAT;
3242      break;
3243  }
3244
3245  // Allow for multiple creation requests with the same UIResourceId.  The
3246  // previous resource is simply deleted.
3247  ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
3248  if (id)
3249    DeleteUIResource(uid);
3250
3251  ResourceFormat format = resource_provider_->best_texture_format();
3252  switch (bitmap.GetFormat()) {
3253    case UIResourceBitmap::RGBA8:
3254      break;
3255    case UIResourceBitmap::ALPHA_8:
3256      format = ALPHA_8;
3257      break;
3258    case UIResourceBitmap::ETC1:
3259      format = ETC1;
3260      break;
3261  }
3262  id =
3263      resource_provider_->CreateResource(bitmap.GetSize(),
3264                                         wrap_mode,
3265                                         ResourceProvider::TextureHintImmutable,
3266                                         format);
3267
3268  UIResourceData data;
3269  data.resource_id = id;
3270  data.size = bitmap.GetSize();
3271  data.opaque = bitmap.GetOpaque();
3272
3273  ui_resource_map_[uid] = data;
3274
3275  AutoLockUIResourceBitmap bitmap_lock(bitmap);
3276  resource_provider_->SetPixels(id,
3277                                bitmap_lock.GetPixels(),
3278                                gfx::Rect(bitmap.GetSize()),
3279                                gfx::Rect(bitmap.GetSize()),
3280                                gfx::Vector2d(0, 0));
3281  MarkUIResourceNotEvicted(uid);
3282}
3283
3284void LayerTreeHostImpl::DeleteUIResource(UIResourceId uid) {
3285  ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
3286  if (id) {
3287    resource_provider_->DeleteResource(id);
3288    ui_resource_map_.erase(uid);
3289  }
3290  MarkUIResourceNotEvicted(uid);
3291}
3292
3293void LayerTreeHostImpl::EvictAllUIResources() {
3294  if (ui_resource_map_.empty())
3295    return;
3296
3297  for (UIResourceMap::const_iterator iter = ui_resource_map_.begin();
3298      iter != ui_resource_map_.end();
3299      ++iter) {
3300    evicted_ui_resources_.insert(iter->first);
3301    resource_provider_->DeleteResource(iter->second.resource_id);
3302  }
3303  ui_resource_map_.clear();
3304
3305  client_->SetNeedsCommitOnImplThread();
3306  client_->OnCanDrawStateChanged(CanDraw());
3307  client_->RenewTreePriority();
3308}
3309
3310ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
3311    UIResourceId uid) const {
3312  UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
3313  if (iter != ui_resource_map_.end())
3314    return iter->second.resource_id;
3315  return 0;
3316}
3317
3318bool LayerTreeHostImpl::IsUIResourceOpaque(UIResourceId uid) const {
3319  UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
3320  DCHECK(iter != ui_resource_map_.end());
3321  return iter->second.opaque;
3322}
3323
3324bool LayerTreeHostImpl::EvictedUIResourcesExist() const {
3325  return !evicted_ui_resources_.empty();
3326}
3327
3328void LayerTreeHostImpl::MarkUIResourceNotEvicted(UIResourceId uid) {
3329  std::set<UIResourceId>::iterator found_in_evicted =
3330      evicted_ui_resources_.find(uid);
3331  if (found_in_evicted == evicted_ui_resources_.end())
3332    return;
3333  evicted_ui_resources_.erase(found_in_evicted);
3334  if (evicted_ui_resources_.empty())
3335    client_->OnCanDrawStateChanged(CanDraw());
3336}
3337
3338void LayerTreeHostImpl::ScheduleMicroBenchmark(
3339    scoped_ptr<MicroBenchmarkImpl> benchmark) {
3340  micro_benchmark_controller_.ScheduleRun(benchmark.Pass());
3341}
3342
3343void LayerTreeHostImpl::InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
3344  swap_promise_monitor_.insert(monitor);
3345}
3346
3347void LayerTreeHostImpl::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
3348  swap_promise_monitor_.erase(monitor);
3349}
3350
3351void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
3352  std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
3353  for (; it != swap_promise_monitor_.end(); it++)
3354    (*it)->OnSetNeedsRedrawOnImpl();
3355}
3356
3357void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfForwardingToMainThread() {
3358  std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
3359  for (; it != swap_promise_monitor_.end(); it++)
3360    (*it)->OnForwardScrollUpdateToMainThreadOnImpl();
3361}
3362
3363void LayerTreeHostImpl::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
3364  DCHECK(std::find(picture_layers_.begin(), picture_layers_.end(), layer) ==
3365         picture_layers_.end());
3366  picture_layers_.push_back(layer);
3367}
3368
3369void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
3370  std::vector<PictureLayerImpl*>::iterator it =
3371      std::find(picture_layers_.begin(), picture_layers_.end(), layer);
3372  DCHECK(it != picture_layers_.end());
3373  picture_layers_.erase(it);
3374}
3375
3376}  // namespace cc
3377