src/cc/trees/layer_tree_host_impl.cc

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