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