src/cc/trees/layer_tree_host_impl.cc

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