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