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