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