src/cc/trees/layer_tree_host_impl.cc

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