cc/trees/layer_tree_host.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.h"
   6
   7 #include <algorithm>
   8 #include <stack>
   9 #include <string>
  10
  11 #include "base/atomic_sequence_num.h"
  12 #include "base/bind.h"
  13 #include "base/command_line.h"
  14 #include "base/message_loop/message_loop.h"
  15 #include "base/metrics/histogram.h"
  16 #include "base/stl_util.h"
  17 #include "base/strings/string_number_conversions.h"
  18 #include "base/trace_event/trace_event.h"
  19 #include "base/trace_event/trace_event_argument.h"
  20 #include "cc/animation/animation_registrar.h"
  21 #include "cc/animation/layer_animation_controller.h"
  22 #include "cc/base/math_util.h"
  23 #include "cc/debug/devtools_instrumentation.h"
  24 #include "cc/debug/frame_viewer_instrumentation.h"
  25 #include "cc/debug/rendering_stats_instrumentation.h"
  26 #include "cc/input/layer_selection_bound.h"
  27 #include "cc/input/page_scale_animation.h"
  28 #include "cc/input/top_controls_manager.h"
  29 #include "cc/layers/heads_up_display_layer.h"
  30 #include "cc/layers/heads_up_display_layer_impl.h"
  31 #include "cc/layers/layer.h"
  32 #include "cc/layers/layer_iterator.h"
  33 #include "cc/layers/painted_scrollbar_layer.h"
  34 #include "cc/layers/render_surface.h"
  35 #include "cc/resources/prioritized_resource_manager.h"
  36 #include "cc/resources/ui_resource_request.h"
  37 #include "cc/scheduler/begin_frame_source.h"
  38 #include "cc/trees/layer_tree_host_client.h"
  39 #include "cc/trees/layer_tree_host_common.h"
  40 #include "cc/trees/layer_tree_host_impl.h"
  41 #include "cc/trees/layer_tree_impl.h"
  42 #include "cc/trees/occlusion_tracker.h"
  43 #include "cc/trees/single_thread_proxy.h"
  44 #include "cc/trees/thread_proxy.h"
  45 #include "cc/trees/tree_synchronizer.h"
  46 #include "ui/gfx/geometry/size_conversions.h"
  47 #include "ui/gfx/geometry/vector2d_conversions.h"
  48
  49 namespace {
  50 static base::StaticAtomicSequenceNumber s_layer_tree_host_sequence_number;
  51 }
  52
  53 namespace cc {
  54
  55 scoped_ptr<LayerTreeHost> LayerTreeHost::CreateThreaded(
  56     LayerTreeHostClient* client,
  57     SharedBitmapManager* shared_bitmap_manager,
  58     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
  59     TaskGraphRunner* task_graph_runner,
  60     const LayerTreeSettings& settings,
  61     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
  62     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
  63     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
  64   DCHECK(main_task_runner.get());
  65   DCHECK(impl_task_runner.get());
  66   scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(
  67       client, shared_bitmap_manager, gpu_memory_buffer_manager,
  68       task_graph_runner, settings));
  69   layer_tree_host->InitializeThreaded(main_task_runner,
  70                                       impl_task_runner,
  71                                       external_begin_frame_source.Pass());
  72   return layer_tree_host.Pass();
  73 }
  74
  75 scoped_ptr<LayerTreeHost> LayerTreeHost::CreateSingleThreaded(
  76     LayerTreeHostClient* client,
  77     LayerTreeHostSingleThreadClient* single_thread_client,
  78     SharedBitmapManager* shared_bitmap_manager,
  79     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
  80     TaskGraphRunner* task_graph_runner,
  81     const LayerTreeSettings& settings,
  82     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
  83     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
  84   scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(
  85       client, shared_bitmap_manager, gpu_memory_buffer_manager,
  86       task_graph_runner, settings));
  87   layer_tree_host->InitializeSingleThreaded(single_thread_client,
  88                                             main_task_runner,
  89                                             external_begin_frame_source.Pass());
  90   return layer_tree_host.Pass();
  91 }
  92
  93 LayerTreeHost::LayerTreeHost(
  94     LayerTreeHostClient* client,
  95     SharedBitmapManager* shared_bitmap_manager,
  96     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
  97     TaskGraphRunner* task_graph_runner,
  98     const LayerTreeSettings& settings)
  99     : micro_benchmark_controller_(this),
 100       next_ui_resource_id_(1),
 101       inside_begin_main_frame_(false),
 102       needs_full_tree_sync_(true),
 103       client_(client),
 104       source_frame_number_(0),
 105       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
 106       output_surface_lost_(true),
 107       settings_(settings),
 108       debug_state_(settings.initial_debug_state),
 109       top_controls_shrink_blink_size_(false),
 110       top_controls_height_(0.f),
 111       top_controls_shown_ratio_(0.f),
 112       device_scale_factor_(1.f),
 113       visible_(true),
 114       page_scale_factor_(1.f),
 115       min_page_scale_factor_(1.f),
 116       max_page_scale_factor_(1.f),
 117       has_gpu_rasterization_trigger_(false),
 118       content_is_suitable_for_gpu_rasterization_(true),
 119       gpu_rasterization_histogram_recorded_(false),
 120       background_color_(SK_ColorWHITE),
 121       has_transparent_background_(false),
 122       partial_texture_update_requests_(0),
 123       did_complete_scale_animation_(false),
 124       in_paint_layer_contents_(false),
 125       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
 126       next_commit_forces_redraw_(false),
 127       shared_bitmap_manager_(shared_bitmap_manager),
 128       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
 129       task_graph_runner_(task_graph_runner),
 130       surface_id_namespace_(0u),
 131       next_surface_sequence_(1u) {
 132   if (settings_.accelerated_animation_enabled)
 133     animation_registrar_ = AnimationRegistrar::Create();
 134   rendering_stats_instrumentation_->set_record_rendering_stats(
 135       debug_state_.RecordRenderingStats());
 136 }
 137
 138 void LayerTreeHost::InitializeThreaded(
 139     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
 140     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
 141     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
 142   InitializeProxy(ThreadProxy::Create(this,
 143                                       main_task_runner,
 144                                       impl_task_runner,
 145                                       external_begin_frame_source.Pass()));
 146 }
 147
 148 void LayerTreeHost::InitializeSingleThreaded(
 149     LayerTreeHostSingleThreadClient* single_thread_client,
 150     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
 151     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
 152   InitializeProxy(
 153       SingleThreadProxy::Create(this,
 154                                 single_thread_client,
 155                                 main_task_runner,
 156                                 external_begin_frame_source.Pass()));
 157 }
 158
 159 void LayerTreeHost::InitializeForTesting(scoped_ptr<Proxy> proxy_for_testing) {
 160   InitializeProxy(proxy_for_testing.Pass());
 161 }
 162
 163 void LayerTreeHost::InitializeProxy(scoped_ptr<Proxy> proxy) {
 164   TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
 165
 166   proxy_ = proxy.Pass();
 167   proxy_->Start();
 168   if (settings_.accelerated_animation_enabled) {
 169     animation_registrar_->set_supports_scroll_animations(
 170         proxy_->SupportsImplScrolling());
 171   }
 172 }
 173
 174 LayerTreeHost::~LayerTreeHost() {
 175   TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
 176
 177   if (root_layer_.get())
 178     root_layer_->SetLayerTreeHost(NULL);
 179
 180   DCHECK(swap_promise_monitor_.empty());
 181
 182   BreakSwapPromises(SwapPromise::COMMIT_FAILS);
 183
 184   if (proxy_) {
 185     DCHECK(proxy_->IsMainThread());
 186     proxy_->Stop();
 187   }
 188
 189   // We must clear any pointers into the layer tree prior to destroying it.
 190   RegisterViewportLayers(NULL, NULL, NULL, NULL);
 191
 192   if (root_layer_.get()) {
 193     // The layer tree must be destroyed before the layer tree host. We've
 194     // made a contract with our animation controllers that the registrar
 195     // will outlive them, and we must make good.
 196     root_layer_ = NULL;
 197   }
 198 }
 199
 200 void LayerTreeHost::SetLayerTreeHostClientReady() {
 201   proxy_->SetLayerTreeHostClientReady();
 202 }
 203
 204 void LayerTreeHost::DeleteContentsTexturesOnImplThread(
 205     ResourceProvider* resource_provider) {
 206   DCHECK(proxy_->IsImplThread());
 207   if (contents_texture_manager_)
 208     contents_texture_manager_->ClearAllMemory(resource_provider);
 209 }
 210
 211 void LayerTreeHost::WillBeginMainFrame() {
 212   devtools_instrumentation::WillBeginMainThreadFrame(id(),
 213                                                      source_frame_number());
 214   client_->WillBeginMainFrame();
 215 }
 216
 217 void LayerTreeHost::DidBeginMainFrame() {
 218   client_->DidBeginMainFrame();
 219 }
 220
 221 void LayerTreeHost::BeginMainFrameNotExpectedSoon() {
 222   client_->BeginMainFrameNotExpectedSoon();
 223 }
 224
 225 void LayerTreeHost::BeginMainFrame(const BeginFrameArgs& args) {
 226   inside_begin_main_frame_ = true;
 227   client_->BeginMainFrame(args);
 228   inside_begin_main_frame_ = false;
 229 }
 230
 231 void LayerTreeHost::DidStopFlinging() {
 232   proxy_->MainThreadHasStoppedFlinging();
 233 }
 234
 235 void LayerTreeHost::Layout() {
 236   client_->Layout();
 237 }
 238
 239 void LayerTreeHost::BeginCommitOnImplThread(LayerTreeHostImpl* host_impl) {
 240   DCHECK(proxy_->IsImplThread());
 241   TRACE_EVENT0("cc", "LayerTreeHost::CommitTo");
 242 }
 243
 244 // This function commits the LayerTreeHost to an impl tree. When modifying
 245 // this function, keep in mind that the function *runs* on the impl thread! Any
 246 // code that is logically a main thread operation, e.g. deletion of a Layer,
 247 // should be delayed until the LayerTreeHost::CommitComplete, which will run
 248 // after the commit, but on the main thread.
 249 void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
 250   DCHECK(proxy_->IsImplThread());
 251
 252   // If there are linked evicted backings, these backings' resources may be put
 253   // into the impl tree, so we can't draw yet. Determine this before clearing
 254   // all evicted backings.
 255   bool new_impl_tree_has_no_evicted_resources = false;
 256   if (contents_texture_manager_) {
 257     new_impl_tree_has_no_evicted_resources =
 258         !contents_texture_manager_->LinkedEvictedBackingsExist();
 259
 260     // If the memory limit has been increased since this now-finishing
 261     // commit began, and the extra now-available memory would have been used,
 262     // then request another commit.
 263     if (contents_texture_manager_->MaxMemoryLimitBytes() <
 264             host_impl->memory_allocation_limit_bytes() &&
 265         contents_texture_manager_->MaxMemoryLimitBytes() <
 266             contents_texture_manager_->MaxMemoryNeededBytes()) {
 267       host_impl->SetNeedsCommit();
 268     }
 269
 270     host_impl->set_max_memory_needed_bytes(
 271         contents_texture_manager_->MaxMemoryNeededBytes());
 272
 273     contents_texture_manager_->UpdateBackingsState(
 274         host_impl->resource_provider());
 275     contents_texture_manager_->ReduceMemory(host_impl->resource_provider());
 276   }
 277
 278   bool is_new_trace;
 279   TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
 280   if (is_new_trace &&
 281       frame_viewer_instrumentation::IsTracingLayerTreeSnapshots() &&
 282       root_layer()) {
 283     LayerTreeHostCommon::CallFunctionForSubtree(
 284         root_layer(), [](Layer* layer) { layer->DidBeginTracing(); });
 285   }
 286
 287   LayerTreeImpl* sync_tree = host_impl->sync_tree();
 288
 289   if (next_commit_forces_redraw_) {
 290     sync_tree->ForceRedrawNextActivation();
 291     next_commit_forces_redraw_ = false;
 292   }
 293
 294   sync_tree->set_source_frame_number(source_frame_number());
 295
 296   if (needs_full_tree_sync_) {
 297     sync_tree->SetRootLayer(TreeSynchronizer::SynchronizeTrees(
 298         root_layer(), sync_tree->DetachLayerTree(), sync_tree));
 299   }
 300   sync_tree->set_needs_full_tree_sync(needs_full_tree_sync_);
 301   needs_full_tree_sync_ = false;
 302
 303   if (hud_layer_.get()) {
 304     LayerImpl* hud_impl = LayerTreeHostCommon::FindLayerInSubtree(
 305         sync_tree->root_layer(), hud_layer_->id());
 306     sync_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
 307   } else {
 308     sync_tree->set_hud_layer(NULL);
 309   }
 310
 311   sync_tree->set_background_color(background_color_);
 312   sync_tree->set_has_transparent_background(has_transparent_background_);
 313
 314   if (page_scale_layer_.get() && inner_viewport_scroll_layer_.get()) {
 315     sync_tree->SetViewportLayersFromIds(
 316         overscroll_elasticity_layer_.get() ? overscroll_elasticity_layer_->id()
 317                                            : Layer::INVALID_ID,
 318         page_scale_layer_->id(), inner_viewport_scroll_layer_->id(),
 319         outer_viewport_scroll_layer_.get() ? outer_viewport_scroll_layer_->id()
 320                                            : Layer::INVALID_ID);
 321     DCHECK(inner_viewport_scroll_layer_->IsContainerForFixedPositionLayers());
 322   } else {
 323     sync_tree->ClearViewportLayers();
 324   }
 325
 326   sync_tree->RegisterSelection(selection_start_, selection_end_);
 327
 328   sync_tree->PushPageScaleFromMainThread(
 329       page_scale_factor_, min_page_scale_factor_, max_page_scale_factor_);
 330   sync_tree->elastic_overscroll()->PushFromMainThread(elastic_overscroll_);
 331   if (sync_tree->IsActiveTree())
 332     sync_tree->elastic_overscroll()->PushPendingToActive();
 333
 334   sync_tree->PassSwapPromises(&swap_promise_list_);
 335
 336   sync_tree->set_top_controls_shrink_blink_size(
 337       top_controls_shrink_blink_size_);
 338   sync_tree->set_top_controls_height(top_controls_height_);
 339   sync_tree->PushTopControlsFromMainThread(top_controls_shown_ratio_);
 340
 341   host_impl->SetUseGpuRasterization(UseGpuRasterization());
 342   host_impl->set_gpu_rasterization_status(GetGpuRasterizationStatus());
 343   RecordGpuRasterizationHistogram();
 344
 345   host_impl->SetViewportSize(device_viewport_size_);
 346   host_impl->SetDeviceScaleFactor(device_scale_factor_);
 347   host_impl->SetDebugState(debug_state_);
 348   if (pending_page_scale_animation_) {
 349     sync_tree->SetPendingPageScaleAnimation(
 350         pending_page_scale_animation_.Pass());
 351   }
 352
 353   if (!ui_resource_request_queue_.empty()) {
 354     sync_tree->set_ui_resource_request_queue(ui_resource_request_queue_);
 355     ui_resource_request_queue_.clear();
 356   }
 357
 358   DCHECK(!sync_tree->ViewportSizeInvalid());
 359
 360   if (new_impl_tree_has_no_evicted_resources) {
 361     if (sync_tree->ContentsTexturesPurged())
 362       sync_tree->ResetContentsTexturesPurged();
 363   }
 364
 365   sync_tree->set_has_ever_been_drawn(false);
 366
 367   {
 368     TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
 369     TreeSynchronizer::PushProperties(root_layer(), sync_tree->root_layer());
 370   }
 371
 372   micro_benchmark_controller_.ScheduleImplBenchmarks(host_impl);
 373 }
 374
 375 void LayerTreeHost::WillCommit() {
 376   client_->WillCommit();
 377 }
 378
 379 void LayerTreeHost::UpdateHudLayer() {
 380   if (debug_state_.ShowHudInfo()) {
 381     if (!hud_layer_.get())
 382       hud_layer_ = HeadsUpDisplayLayer::Create();
 383
 384     if (root_layer_.get() && !hud_layer_->parent())
 385       root_layer_->AddChild(hud_layer_);
 386   } else if (hud_layer_.get()) {
 387     hud_layer_->RemoveFromParent();
 388     hud_layer_ = NULL;
 389   }
 390 }
 391
 392 void LayerTreeHost::CommitComplete() {
 393   source_frame_number_++;
 394   client_->DidCommit();
 395   if (did_complete_scale_animation_) {
 396     client_->DidCompletePageScaleAnimation();
 397     did_complete_scale_animation_ = false;
 398   }
 399 }
 400
 401 void LayerTreeHost::SetOutputSurface(scoped_ptr<OutputSurface> surface) {
 402   TRACE_EVENT0("cc", "LayerTreeHost::SetOutputSurface");
 403   DCHECK(output_surface_lost_);
 404   DCHECK(surface);
 405
 406   proxy_->SetOutputSurface(surface.Pass());
 407 }
 408
 409 void LayerTreeHost::RequestNewOutputSurface() {
 410   client_->RequestNewOutputSurface();
 411 }
 412
 413 void LayerTreeHost::DidInitializeOutputSurface() {
 414   output_surface_lost_ = false;
 415
 416   if (!contents_texture_manager_ && !settings_.impl_side_painting) {
 417     contents_texture_manager_ =
 418         PrioritizedResourceManager::Create(proxy_.get());
 419     surface_memory_placeholder_ =
 420         contents_texture_manager_->CreateTexture(gfx::Size(), RGBA_8888);
 421   }
 422
 423   if (root_layer()) {
 424     LayerTreeHostCommon::CallFunctionForSubtree(
 425         root_layer(), [](Layer* layer) { layer->OnOutputSurfaceCreated(); });
 426   }
 427
 428   client_->DidInitializeOutputSurface();
 429 }
 430
 431 void LayerTreeHost::DidFailToInitializeOutputSurface() {
 432   DCHECK(output_surface_lost_);
 433   client_->DidFailToInitializeOutputSurface();
 434 }
 435
 436 scoped_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
 437     LayerTreeHostImplClient* client) {
 438   DCHECK(proxy_->IsImplThread());
 439   scoped_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
 440       settings_, client, proxy_.get(), rendering_stats_instrumentation_.get(),
 441       shared_bitmap_manager_, gpu_memory_buffer_manager_, task_graph_runner_,
 442       id_);
 443   host_impl->SetUseGpuRasterization(UseGpuRasterization());
 444   shared_bitmap_manager_ = NULL;
 445   gpu_memory_buffer_manager_ = NULL;
 446   task_graph_runner_ = NULL;
 447   top_controls_manager_weak_ptr_ =
 448       host_impl->top_controls_manager()->AsWeakPtr();
 449   input_handler_weak_ptr_ = host_impl->AsWeakPtr();
 450   return host_impl.Pass();
 451 }
 452
 453 void LayerTreeHost::DidLoseOutputSurface() {
 454   TRACE_EVENT0("cc", "LayerTreeHost::DidLoseOutputSurface");
 455   DCHECK(proxy_->IsMainThread());
 456
 457   if (output_surface_lost_)
 458     return;
 459
 460   output_surface_lost_ = true;
 461   SetNeedsCommit();
 462 }
 463
 464 void LayerTreeHost::FinishAllRendering() {
 465   proxy_->FinishAllRendering();
 466 }
 467
 468 void LayerTreeHost::SetDeferCommits(bool defer_commits) {
 469   proxy_->SetDeferCommits(defer_commits);
 470 }
 471
 472 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
 473   std::stack<Layer*> layer_stack;
 474   layer_stack.push(root_layer());
 475   while (!layer_stack.empty()) {
 476     Layer* current_layer = layer_stack.top();
 477     layer_stack.pop();
 478     current_layer->SetNeedsDisplay();
 479     for (unsigned int i = 0; i < current_layer->children().size(); i++) {
 480       layer_stack.push(current_layer->child_at(i));
 481     }
 482   }
 483 }
 484
 485 const RendererCapabilities& LayerTreeHost::GetRendererCapabilities() const {
 486   return proxy_->GetRendererCapabilities();
 487 }
 488
 489 void LayerTreeHost::SetNeedsAnimate() {
 490   proxy_->SetNeedsAnimate();
 491   NotifySwapPromiseMonitorsOfSetNeedsCommit();
 492 }
 493
 494 void LayerTreeHost::SetNeedsUpdateLayers() {
 495   proxy_->SetNeedsUpdateLayers();
 496   NotifySwapPromiseMonitorsOfSetNeedsCommit();
 497 }
 498
 499 void LayerTreeHost::SetNeedsCommit() {
 500   if (!prepaint_callback_.IsCancelled()) {
 501     TRACE_EVENT_INSTANT0("cc",
 502                          "LayerTreeHost::SetNeedsCommit::cancel prepaint",
 503                          TRACE_EVENT_SCOPE_THREAD);
 504     prepaint_callback_.Cancel();
 505   }
 506   proxy_->SetNeedsCommit();
 507   NotifySwapPromiseMonitorsOfSetNeedsCommit();
 508 }
 509
 510 void LayerTreeHost::SetNeedsFullTreeSync() {
 511   needs_full_tree_sync_ = true;
 512   SetNeedsCommit();
 513 }
 514
 515 void LayerTreeHost::SetNeedsRedraw() {
 516   SetNeedsRedrawRect(gfx::Rect(device_viewport_size_));
 517 }
 518
 519 void LayerTreeHost::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
 520   proxy_->SetNeedsRedraw(damage_rect);
 521 }
 522
 523 bool LayerTreeHost::CommitRequested() const {
 524   return proxy_->CommitRequested();
 525 }
 526
 527 bool LayerTreeHost::BeginMainFrameRequested() const {
 528   return proxy_->BeginMainFrameRequested();
 529 }
 530
 531
 532 void LayerTreeHost::SetNextCommitWaitsForActivation() {
 533   proxy_->SetNextCommitWaitsForActivation();
 534 }
 535
 536 void LayerTreeHost::SetNextCommitForcesRedraw() {
 537   next_commit_forces_redraw_ = true;
 538 }
 539
 540 void LayerTreeHost::SetAnimationEvents(
 541     scoped_ptr<AnimationEventsVector> events) {
 542   DCHECK(proxy_->IsMainThread());
 543   animation_registrar_->SetAnimationEvents(events.Pass());
 544 }
 545
 546 void LayerTreeHost::SetRootLayer(scoped_refptr<Layer> root_layer) {
 547   if (root_layer_.get() == root_layer.get())
 548     return;
 549
 550   if (root_layer_.get())
 551     root_layer_->SetLayerTreeHost(NULL);
 552   root_layer_ = root_layer;
 553   if (root_layer_.get()) {
 554     DCHECK(!root_layer_->parent());
 555     root_layer_->SetLayerTreeHost(this);
 556   }
 557
 558   if (hud_layer_.get())
 559     hud_layer_->RemoveFromParent();
 560
 561   // Reset gpu rasterization flag.
 562   // This flag is sticky until a new tree comes along.
 563   content_is_suitable_for_gpu_rasterization_ = true;
 564   gpu_rasterization_histogram_recorded_ = false;
 565
 566   SetNeedsFullTreeSync();
 567 }
 568
 569 void LayerTreeHost::SetDebugState(const LayerTreeDebugState& debug_state) {
 570   LayerTreeDebugState new_debug_state =
 571       LayerTreeDebugState::Unite(settings_.initial_debug_state, debug_state);
 572
 573   if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
 574     return;
 575
 576   debug_state_ = new_debug_state;
 577
 578   rendering_stats_instrumentation_->set_record_rendering_stats(
 579       debug_state_.RecordRenderingStats());
 580
 581   SetNeedsCommit();
 582   proxy_->SetDebugState(debug_state);
 583 }
 584
 585 bool LayerTreeHost::UseGpuRasterization() const {
 586   if (settings_.gpu_rasterization_forced) {
 587     return true;
 588   } else if (settings_.gpu_rasterization_enabled) {
 589     return has_gpu_rasterization_trigger_ &&
 590            content_is_suitable_for_gpu_rasterization_;
 591   } else {
 592     return false;
 593   }
 594 }
 595
 596 GpuRasterizationStatus LayerTreeHost::GetGpuRasterizationStatus() const {
 597   if (settings_.gpu_rasterization_forced) {
 598     return GpuRasterizationStatus::ON_FORCED;
 599   } else if (settings_.gpu_rasterization_enabled) {
 600     if (!has_gpu_rasterization_trigger_) {
 601       return GpuRasterizationStatus::OFF_VIEWPORT;
 602     } else if (!content_is_suitable_for_gpu_rasterization_) {
 603       return GpuRasterizationStatus::OFF_CONTENT;
 604     } else {
 605       return GpuRasterizationStatus::ON;
 606     }
 607   }
 608   return GpuRasterizationStatus::OFF_DEVICE;
 609 }
 610
 611 void LayerTreeHost::SetHasGpuRasterizationTrigger(bool has_trigger) {
 612   if (has_trigger == has_gpu_rasterization_trigger_)
 613     return;
 614
 615   has_gpu_rasterization_trigger_ = has_trigger;
 616   TRACE_EVENT_INSTANT1("cc",
 617                        "LayerTreeHost::SetHasGpuRasterizationTrigger",
 618                        TRACE_EVENT_SCOPE_THREAD,
 619                        "has_trigger",
 620                        has_gpu_rasterization_trigger_);
 621 }
 622
 623 void LayerTreeHost::SetViewportSize(const gfx::Size& device_viewport_size) {
 624   if (device_viewport_size == device_viewport_size_)
 625     return;
 626
 627   device_viewport_size_ = device_viewport_size;
 628
 629   SetNeedsCommit();
 630 }
 631
 632 void LayerTreeHost::SetTopControlsHeight(float height, bool shrink) {
 633   if (top_controls_height_ == height &&
 634       top_controls_shrink_blink_size_ == shrink)
 635     return;
 636
 637   top_controls_height_ = height;
 638   top_controls_shrink_blink_size_ = shrink;
 639   SetNeedsCommit();
 640 }
 641
 642 void LayerTreeHost::SetTopControlsShownRatio(float ratio) {
 643   if (top_controls_shown_ratio_ == ratio)
 644     return;
 645
 646   top_controls_shown_ratio_ = ratio;
 647   SetNeedsCommit();
 648 }
 649
 650 void LayerTreeHost::ApplyPageScaleDeltaFromImplSide(float page_scale_delta) {
 651   DCHECK(CommitRequested());
 652   page_scale_factor_ *= page_scale_delta;
 653 }
 654
 655 void LayerTreeHost::SetPageScaleFactorAndLimits(float page_scale_factor,
 656                                                 float min_page_scale_factor,
 657                                                 float max_page_scale_factor) {
 658   if (page_scale_factor == page_scale_factor_ &&
 659       min_page_scale_factor == min_page_scale_factor_ &&
 660       max_page_scale_factor == max_page_scale_factor_)
 661     return;
 662
 663   page_scale_factor_ = page_scale_factor;
 664   min_page_scale_factor_ = min_page_scale_factor;
 665   max_page_scale_factor_ = max_page_scale_factor;
 666   SetNeedsCommit();
 667 }
 668
 669 void LayerTreeHost::SetVisible(bool visible) {
 670   if (visible_ == visible)
 671     return;
 672   visible_ = visible;
 673   if (!visible)
 674     ReduceMemoryUsage();
 675   proxy_->SetVisible(visible);
 676 }
 677
 678 void LayerTreeHost::SetThrottleFrameProduction(bool throttle) {
 679   proxy_->SetThrottleFrameProduction(throttle);
 680 }
 681
 682 void LayerTreeHost::StartPageScaleAnimation(const gfx::Vector2d& target_offset,
 683                                             bool use_anchor,
 684                                             float scale,
 685                                             base::TimeDelta duration) {
 686   pending_page_scale_animation_.reset(
 687       new PendingPageScaleAnimation(
 688           target_offset,
 689           use_anchor,
 690           scale,
 691           duration));
 692
 693   SetNeedsCommit();
 694 }
 695
 696 void LayerTreeHost::NotifyInputThrottledUntilCommit() {
 697   proxy_->NotifyInputThrottledUntilCommit();
 698 }
 699
 700 void LayerTreeHost::Composite(base::TimeTicks frame_begin_time) {
 701   DCHECK(!proxy_->HasImplThread());
 702   // This function is only valid when not using the scheduler.
 703   DCHECK(!settings_.single_thread_proxy_scheduler);
 704   SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
 705
 706   SetLayerTreeHostClientReady();
 707   proxy->CompositeImmediately(frame_begin_time);
 708 }
 709
 710 bool LayerTreeHost::UpdateLayers(ResourceUpdateQueue* queue) {
 711   DCHECK(!output_surface_lost_);
 712
 713   if (!root_layer())
 714     return false;
 715
 716   DCHECK(!root_layer()->parent());
 717
 718   bool result = UpdateLayers(root_layer(), queue);
 719
 720   micro_benchmark_controller_.DidUpdateLayers();
 721
 722   return result || next_commit_forces_redraw_;
 723 }
 724
 725 void LayerTreeHost::DidCompletePageScaleAnimation() {
 726   did_complete_scale_animation_ = true;
 727 }
 728
 729 static Layer* FindFirstScrollableLayer(Layer* layer) {
 730   if (!layer)
 731     return NULL;
 732
 733   if (layer->scrollable())
 734     return layer;
 735
 736   for (size_t i = 0; i < layer->children().size(); ++i) {
 737     Layer* found = FindFirstScrollableLayer(layer->children()[i].get());
 738     if (found)
 739       return found;
 740   }
 741
 742   return NULL;
 743 }
 744
 745 void LayerTreeHost::RecordGpuRasterizationHistogram() {
 746   // Gpu rasterization is only supported when impl-side painting is enabled.
 747   if (gpu_rasterization_histogram_recorded_ || !settings_.impl_side_painting)
 748     return;
 749
 750   // Record how widely gpu rasterization is enabled.
 751   // This number takes device/gpu whitelisting/backlisting into account.
 752   // Note that we do not consider the forced gpu rasterization mode, which is
 753   // mostly used for debugging purposes.
 754   UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationEnabled",
 755                         settings_.gpu_rasterization_enabled);
 756   if (settings_.gpu_rasterization_enabled) {
 757     UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationTriggered",
 758                           has_gpu_rasterization_trigger_);
 759     UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationSuitableContent",
 760                           content_is_suitable_for_gpu_rasterization_);
 761     // Record how many pages actually get gpu rasterization when enabled.
 762     UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationUsed",
 763                           (has_gpu_rasterization_trigger_ &&
 764                            content_is_suitable_for_gpu_rasterization_));
 765   }
 766
 767   gpu_rasterization_histogram_recorded_ = true;
 768 }
 769
 770 bool LayerTreeHost::UsingSharedMemoryResources() {
 771   return GetRendererCapabilities().using_shared_memory_resources;
 772 }
 773
 774 bool LayerTreeHost::UpdateLayers(Layer* root_layer,
 775                                  ResourceUpdateQueue* queue) {
 776   TRACE_EVENT1("cc", "LayerTreeHost::UpdateLayers",
 777                "source_frame_number", source_frame_number());
 778
 779   RenderSurfaceLayerList update_list;
 780   {
 781     UpdateHudLayer();
 782
 783     Layer* root_scroll = FindFirstScrollableLayer(root_layer);
 784     Layer* page_scale_layer = page_scale_layer_.get();
 785     if (!page_scale_layer && root_scroll)
 786       page_scale_layer = root_scroll->parent();
 787
 788     if (hud_layer_.get()) {
 789       hud_layer_->PrepareForCalculateDrawProperties(
 790           device_viewport_size(), device_scale_factor_);
 791     }
 792
 793     TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::CalcDrawProps");
 794     bool can_render_to_separate_surface = true;
 795     // TODO(vmpstr): Passing 0 as the current render surface layer list id means
 796     // that we won't be able to detect if a layer is part of |update_list|.
 797     // Change this if this information is required.
 798     int render_surface_layer_list_id = 0;
 799     LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(
 800         root_layer, device_viewport_size(), gfx::Transform(),
 801         device_scale_factor_, page_scale_factor_, page_scale_layer,
 802         elastic_overscroll_, overscroll_elasticity_layer_.get(),
 803         GetRendererCapabilities().max_texture_size, settings_.can_use_lcd_text,
 804         settings_.layers_always_allowed_lcd_text,
 805         can_render_to_separate_surface,
 806         settings_.layer_transforms_should_scale_layer_contents,
 807         settings_.verify_property_trees, &update_list,
 808         render_surface_layer_list_id);
 809     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 810   }
 811
 812   // Reset partial texture update requests.
 813   partial_texture_update_requests_ = 0;
 814
 815   bool did_paint_content = false;
 816   bool need_more_updates = false;
 817   PaintLayerContents(
 818       update_list, queue, &did_paint_content, &need_more_updates);
 819   if (need_more_updates) {
 820     TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::posting prepaint task");
 821     prepaint_callback_.Reset(base::Bind(&LayerTreeHost::TriggerPrepaint,
 822                                         base::Unretained(this)));
 823     static base::TimeDelta prepaint_delay =
 824         base::TimeDelta::FromMilliseconds(100);
 825     base::MessageLoop::current()->PostDelayedTask(
 826         FROM_HERE, prepaint_callback_.callback(), prepaint_delay);
 827   }
 828
 829   return did_paint_content;
 830 }
 831
 832 void LayerTreeHost::TriggerPrepaint() {
 833   prepaint_callback_.Cancel();
 834   TRACE_EVENT0("cc", "LayerTreeHost::TriggerPrepaint");
 835   SetNeedsCommit();
 836 }
 837
 838 void LayerTreeHost::ReduceMemoryUsage() {
 839   if (!root_layer())
 840     return;
 841
 842   LayerTreeHostCommon::CallFunctionForSubtree(
 843       root_layer(), [](Layer* layer) { layer->ReduceMemoryUsage(); });
 844 }
 845
 846 void LayerTreeHost::SetPrioritiesForSurfaces(size_t surface_memory_bytes) {
 847   DCHECK(surface_memory_placeholder_);
 848
 849   // Surfaces have a place holder for their memory since they are managed
 850   // independantly but should still be tracked and reduce other memory usage.
 851   surface_memory_placeholder_->SetTextureManager(
 852       contents_texture_manager_.get());
 853   surface_memory_placeholder_->set_request_priority(
 854       PriorityCalculator::RenderSurfacePriority());
 855   surface_memory_placeholder_->SetToSelfManagedMemoryPlaceholder(
 856       surface_memory_bytes);
 857 }
 858
 859 void LayerTreeHost::SetPrioritiesForLayers(
 860     const RenderSurfaceLayerList& update_list) {
 861   PriorityCalculator calculator;
 862   typedef LayerIterator<Layer> LayerIteratorType;
 863   LayerIteratorType end = LayerIteratorType::End(&update_list);
 864   for (LayerIteratorType it = LayerIteratorType::Begin(&update_list);
 865        it != end;
 866        ++it) {
 867     if (it.represents_itself()) {
 868       it->SetTexturePriorities(calculator);
 869     } else if (it.represents_target_render_surface()) {
 870       if (it->mask_layer())
 871         it->mask_layer()->SetTexturePriorities(calculator);
 872       if (it->replica_layer() && it->replica_layer()->mask_layer())
 873         it->replica_layer()->mask_layer()->SetTexturePriorities(calculator);
 874     }
 875   }
 876 }
 877
 878 void LayerTreeHost::PrioritizeTextures(
 879     const RenderSurfaceLayerList& render_surface_layer_list) {
 880   if (!contents_texture_manager_)
 881     return;
 882
 883   contents_texture_manager_->ClearPriorities();
 884
 885   size_t memory_for_render_surfaces_metric =
 886       CalculateMemoryForRenderSurfaces(render_surface_layer_list);
 887
 888   SetPrioritiesForLayers(render_surface_layer_list);
 889   SetPrioritiesForSurfaces(memory_for_render_surfaces_metric);
 890
 891   contents_texture_manager_->PrioritizeTextures();
 892 }
 893
 894 size_t LayerTreeHost::CalculateMemoryForRenderSurfaces(
 895     const RenderSurfaceLayerList& update_list) {
 896   size_t readback_bytes = 0;
 897   size_t contents_texture_bytes = 0;
 898
 899   // Start iteration at 1 to skip the root surface as it does not have a texture
 900   // cost.
 901   for (size_t i = 1; i < update_list.size(); ++i) {
 902     Layer* render_surface_layer = update_list.at(i);
 903     RenderSurface* render_surface = render_surface_layer->render_surface();
 904
 905     size_t bytes =
 906         Resource::MemorySizeBytes(render_surface->content_rect().size(),
 907                                   RGBA_8888);
 908     contents_texture_bytes += bytes;
 909
 910     if (render_surface_layer->background_filters().IsEmpty() &&
 911         render_surface_layer->uses_default_blend_mode())
 912       continue;
 913
 914     if (!readback_bytes) {
 915       readback_bytes = Resource::MemorySizeBytes(device_viewport_size_,
 916                                                  RGBA_8888);
 917     }
 918   }
 919   return readback_bytes + contents_texture_bytes;
 920 }
 921
 922 void LayerTreeHost::PaintMasksForRenderSurface(Layer* render_surface_layer,
 923                                                ResourceUpdateQueue* queue,
 924                                                bool* did_paint_content,
 925                                                bool* need_more_updates) {
 926   // Note: Masks and replicas only exist for layers that own render surfaces. If
 927   // we reach this point in code, we already know that at least something will
 928   // be drawn into this render surface, so the mask and replica should be
 929   // painted.
 930
 931   Layer* mask_layer = render_surface_layer->mask_layer();
 932   if (mask_layer) {
 933     *did_paint_content |= mask_layer->Update(queue, NULL);
 934     *need_more_updates |= mask_layer->NeedMoreUpdates();
 935   }
 936
 937   Layer* replica_mask_layer =
 938       render_surface_layer->replica_layer() ?
 939       render_surface_layer->replica_layer()->mask_layer() : NULL;
 940   if (replica_mask_layer) {
 941     *did_paint_content |= replica_mask_layer->Update(queue, NULL);
 942     *need_more_updates |= replica_mask_layer->NeedMoreUpdates();
 943   }
 944 }
 945
 946 void LayerTreeHost::PaintLayerContents(
 947     const RenderSurfaceLayerList& render_surface_layer_list,
 948     ResourceUpdateQueue* queue,
 949     bool* did_paint_content,
 950     bool* need_more_updates) {
 951   OcclusionTracker<Layer> occlusion_tracker(
 952       root_layer_->render_surface()->content_rect());
 953   occlusion_tracker.set_minimum_tracking_size(
 954       settings_.minimum_occlusion_tracking_size);
 955
 956   PrioritizeTextures(render_surface_layer_list);
 957
 958   in_paint_layer_contents_ = true;
 959
 960   // Iterates front-to-back to allow for testing occlusion and performing
 961   // culling during the tree walk.
 962   typedef LayerIterator<Layer> LayerIteratorType;
 963   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list);
 964   for (LayerIteratorType it =
 965            LayerIteratorType::Begin(&render_surface_layer_list);
 966        it != end;
 967        ++it) {
 968     occlusion_tracker.EnterLayer(it);
 969
 970     if (it.represents_target_render_surface()) {
 971       PaintMasksForRenderSurface(
 972           *it, queue, did_paint_content, need_more_updates);
 973     } else if (it.represents_itself()) {
 974       DCHECK(!it->paint_properties().bounds.IsEmpty());
 975       *did_paint_content |= it->Update(queue, &occlusion_tracker);
 976       *need_more_updates |= it->NeedMoreUpdates();
 977       // Note the '&&' with previous is-suitable state.
 978       // This means that once the layer-tree becomes unsuitable for gpu
 979       // rasterization due to some content, it will continue to be unsuitable
 980       // even if that content is replaced by gpu-friendly content.
 981       // This is to avoid switching back-and-forth between gpu and sw
 982       // rasterization which may be both bad for performance and visually
 983       // jarring.
 984       content_is_suitable_for_gpu_rasterization_ &=
 985           it->IsSuitableForGpuRasterization();
 986     }
 987
 988     occlusion_tracker.LeaveLayer(it);
 989   }
 990
 991   in_paint_layer_contents_ = false;
 992 }
 993
 994 void LayerTreeHost::ApplyScrollAndScale(ScrollAndScaleSet* info) {
 995   ScopedPtrVector<SwapPromise>::iterator it = info->swap_promises.begin();
 996   for (; it != info->swap_promises.end(); ++it) {
 997     scoped_ptr<SwapPromise> swap_promise(info->swap_promises.take(it));
 998     TRACE_EVENT_FLOW_STEP0("input",
 999                            "LatencyInfo.Flow",
1000                            TRACE_ID_DONT_MANGLE(swap_promise->TraceId()),
1001                            "Main thread scroll update");
1002     QueueSwapPromise(swap_promise.Pass());
1003   }
1004
1005   gfx::Vector2dF inner_viewport_scroll_delta;
1006   gfx::Vector2dF outer_viewport_scroll_delta;
1007
1008   if (root_layer_.get()) {
1009     for (size_t i = 0; i < info->scrolls.size(); ++i) {
1010       Layer* layer = LayerTreeHostCommon::FindLayerInSubtree(
1011           root_layer_.get(), info->scrolls[i].layer_id);
1012       if (!layer)
1013         continue;
1014       if (layer == outer_viewport_scroll_layer_.get()) {
1015         outer_viewport_scroll_delta += info->scrolls[i].scroll_delta;
1016       } else if (layer == inner_viewport_scroll_layer_.get()) {
1017         inner_viewport_scroll_delta += info->scrolls[i].scroll_delta;
1018       } else {
1019         layer->SetScrollOffsetFromImplSide(
1020             gfx::ScrollOffsetWithDelta(layer->scroll_offset(),
1021                                        info->scrolls[i].scroll_delta));
1022       }
1023     }
1024   }
1025
1026   if (!inner_viewport_scroll_delta.IsZero() ||
1027       !outer_viewport_scroll_delta.IsZero() || info->page_scale_delta != 1.f ||
1028       !info->elastic_overscroll_delta.IsZero() || info->top_controls_delta) {
1029     // Preemptively apply the scroll offset and scale delta here before sending
1030     // it to the client.  If the client comes back and sets it to the same
1031     // value, then the layer can early out without needing a full commit.
1032     if (inner_viewport_scroll_layer_.get()) {
1033       inner_viewport_scroll_layer_->SetScrollOffsetFromImplSide(
1034           gfx::ScrollOffsetWithDelta(
1035               inner_viewport_scroll_layer_->scroll_offset(),
1036               inner_viewport_scroll_delta));
1037     }
1038
1039     if (outer_viewport_scroll_layer_.get()) {
1040       outer_viewport_scroll_layer_->SetScrollOffsetFromImplSide(
1041           gfx::ScrollOffsetWithDelta(
1042               outer_viewport_scroll_layer_->scroll_offset(),
1043               outer_viewport_scroll_delta));
1044     }
1045
1046     ApplyPageScaleDeltaFromImplSide(info->page_scale_delta);
1047     elastic_overscroll_ += info->elastic_overscroll_delta;
1048     if (!settings_.use_pinch_virtual_viewport) {
1049       // TODO(miletus): Make sure either this code path is totally gone,
1050       // or revisit the flooring here if the old pinch viewport code path
1051       // is causing problems with fractional scroll offset.
1052       client_->ApplyViewportDeltas(
1053           gfx::ToFlooredVector2d(inner_viewport_scroll_delta +
1054                                  outer_viewport_scroll_delta),
1055           info->page_scale_delta, info->top_controls_delta);
1056     } else {
1057       // TODO(ccameron): pass the elastic overscroll here so that input events
1058       // may be translated appropriately.
1059       client_->ApplyViewportDeltas(
1060           inner_viewport_scroll_delta, outer_viewport_scroll_delta,
1061           info->elastic_overscroll_delta, info->page_scale_delta,
1062           info->top_controls_delta);
1063     }
1064   }
1065 }
1066
1067 void LayerTreeHost::StartRateLimiter() {
1068   if (inside_begin_main_frame_)
1069     return;
1070
1071   if (!rate_limit_timer_.IsRunning()) {
1072     rate_limit_timer_.Start(FROM_HERE,
1073                             base::TimeDelta(),
1074                             this,
1075                             &LayerTreeHost::RateLimit);
1076   }
1077 }
1078
1079 void LayerTreeHost::StopRateLimiter() {
1080   rate_limit_timer_.Stop();
1081 }
1082
1083 void LayerTreeHost::RateLimit() {
1084   // Force a no-op command on the compositor context, so that any ratelimiting
1085   // commands will wait for the compositing context, and therefore for the
1086   // SwapBuffers.
1087   proxy_->ForceSerializeOnSwapBuffers();
1088   client_->RateLimitSharedMainThreadContext();
1089 }
1090
1091 bool LayerTreeHost::AlwaysUsePartialTextureUpdates() {
1092   if (!proxy_->GetRendererCapabilities().allow_partial_texture_updates)
1093     return false;
1094   return !proxy_->HasImplThread();
1095 }
1096
1097 size_t LayerTreeHost::MaxPartialTextureUpdates() const {
1098   size_t max_partial_texture_updates = 0;
1099   if (proxy_->GetRendererCapabilities().allow_partial_texture_updates &&
1100       !settings_.impl_side_painting) {
1101     max_partial_texture_updates =
1102         std::min(settings_.max_partial_texture_updates,
1103                  proxy_->MaxPartialTextureUpdates());
1104   }
1105   return max_partial_texture_updates;
1106 }
1107
1108 bool LayerTreeHost::RequestPartialTextureUpdate() {
1109   if (partial_texture_update_requests_ >= MaxPartialTextureUpdates())
1110     return false;
1111
1112   partial_texture_update_requests_++;
1113   return true;
1114 }
1115
1116 void LayerTreeHost::SetDeviceScaleFactor(float device_scale_factor) {
1117   if (device_scale_factor == device_scale_factor_)
1118     return;
1119   device_scale_factor_ = device_scale_factor;
1120
1121   SetNeedsCommit();
1122 }
1123
1124 void LayerTreeHost::UpdateTopControlsState(TopControlsState constraints,
1125                                            TopControlsState current,
1126                                            bool animate) {
1127   // Top controls are only used in threaded mode.
1128   proxy_->ImplThreadTaskRunner()->PostTask(
1129       FROM_HERE,
1130       base::Bind(&TopControlsManager::UpdateTopControlsState,
1131                  top_controls_manager_weak_ptr_,
1132                  constraints,
1133                  current,
1134                  animate));
1135 }
1136
1137 void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
1138   if (!settings_.accelerated_animation_enabled)
1139     return;
1140
1141   if (animation_registrar_->AnimateLayers(monotonic_time))
1142     animation_registrar_->UpdateAnimationState(true, NULL);
1143 }
1144
1145 UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
1146   DCHECK(client);
1147
1148   UIResourceId next_id = next_ui_resource_id_++;
1149   DCHECK(ui_resource_client_map_.find(next_id) ==
1150          ui_resource_client_map_.end());
1151
1152   bool resource_lost = false;
1153   UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, next_id,
1154                             client->GetBitmap(next_id, resource_lost));
1155   ui_resource_request_queue_.push_back(request);
1156
1157   UIResourceClientData data;
1158   data.client = client;
1159   data.size = request.GetBitmap().GetSize();
1160
1161   ui_resource_client_map_[request.GetId()] = data;
1162   return request.GetId();
1163 }
1164
1165 // Deletes a UI resource.  May safely be called more than once.
1166 void LayerTreeHost::DeleteUIResource(UIResourceId uid) {
1167   UIResourceClientMap::iterator iter = ui_resource_client_map_.find(uid);
1168   if (iter == ui_resource_client_map_.end())
1169     return;
1170
1171   UIResourceRequest request(UIResourceRequest::UI_RESOURCE_DELETE, uid);
1172   ui_resource_request_queue_.push_back(request);
1173   ui_resource_client_map_.erase(iter);
1174 }
1175
1176 void LayerTreeHost::RecreateUIResources() {
1177   for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
1178        iter != ui_resource_client_map_.end();
1179        ++iter) {
1180     UIResourceId uid = iter->first;
1181     const UIResourceClientData& data = iter->second;
1182     bool resource_lost = true;
1183     UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, uid,
1184                               data.client->GetBitmap(uid, resource_lost));
1185     ui_resource_request_queue_.push_back(request);
1186   }
1187 }
1188
1189 // Returns the size of a resource given its id.
1190 gfx::Size LayerTreeHost::GetUIResourceSize(UIResourceId uid) const {
1191   UIResourceClientMap::const_iterator iter = ui_resource_client_map_.find(uid);
1192   if (iter == ui_resource_client_map_.end())
1193     return gfx::Size();
1194
1195   const UIResourceClientData& data = iter->second;
1196   return data.size;
1197 }
1198
1199 void LayerTreeHost::RegisterViewportLayers(
1200     scoped_refptr<Layer> overscroll_elasticity_layer,
1201     scoped_refptr<Layer> page_scale_layer,
1202     scoped_refptr<Layer> inner_viewport_scroll_layer,
1203     scoped_refptr<Layer> outer_viewport_scroll_layer) {
1204   overscroll_elasticity_layer_ = overscroll_elasticity_layer;
1205   page_scale_layer_ = page_scale_layer;
1206   inner_viewport_scroll_layer_ = inner_viewport_scroll_layer;
1207   outer_viewport_scroll_layer_ = outer_viewport_scroll_layer;
1208 }
1209
1210 void LayerTreeHost::RegisterSelection(const LayerSelectionBound& start,
1211                                       const LayerSelectionBound& end) {
1212   if (selection_start_ == start && selection_end_ == end)
1213     return;
1214
1215   selection_start_ = start;
1216   selection_end_ = end;
1217   SetNeedsCommit();
1218 }
1219
1220 int LayerTreeHost::ScheduleMicroBenchmark(
1221     const std::string& benchmark_name,
1222     scoped_ptr<base::Value> value,
1223     const MicroBenchmark::DoneCallback& callback) {
1224   return micro_benchmark_controller_.ScheduleRun(
1225       benchmark_name, value.Pass(), callback);
1226 }
1227
1228 bool LayerTreeHost::SendMessageToMicroBenchmark(int id,
1229                                                 scoped_ptr<base::Value> value) {
1230   return micro_benchmark_controller_.SendMessage(id, value.Pass());
1231 }
1232
1233 void LayerTreeHost::InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
1234   swap_promise_monitor_.insert(monitor);
1235 }
1236
1237 void LayerTreeHost::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
1238   swap_promise_monitor_.erase(monitor);
1239 }
1240
1241 void LayerTreeHost::NotifySwapPromiseMonitorsOfSetNeedsCommit() {
1242   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
1243   for (; it != swap_promise_monitor_.end(); it++)
1244     (*it)->OnSetNeedsCommitOnMain();
1245 }
1246
1247 void LayerTreeHost::QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise) {
1248   DCHECK(swap_promise);
1249   swap_promise_list_.push_back(swap_promise.Pass());
1250 }
1251
1252 void LayerTreeHost::BreakSwapPromises(SwapPromise::DidNotSwapReason reason) {
1253   for (size_t i = 0; i < swap_promise_list_.size(); i++)
1254     swap_promise_list_[i]->DidNotSwap(reason);
1255   swap_promise_list_.clear();
1256 }
1257
1258 void LayerTreeHost::set_surface_id_namespace(uint32_t id_namespace) {
1259   surface_id_namespace_ = id_namespace;
1260 }
1261
1262 SurfaceSequence LayerTreeHost::CreateSurfaceSequence() {
1263   return SurfaceSequence(surface_id_namespace_, next_surface_sequence_++);
1264 }
1265
1266 void LayerTreeHost::SetChildrenNeedBeginFrames(
1267     bool children_need_begin_frames) const {
1268   proxy_->SetChildrenNeedBeginFrames(children_need_begin_frames);
1269 }
1270
1271 void LayerTreeHost::SendBeginFramesToChildren(
1272     const BeginFrameArgs& args) const {
1273   client_->SendBeginFramesToChildren(args);
1274 }
1275
1276 void LayerTreeHost::SetAuthoritativeVSyncInterval(
1277     const base::TimeDelta& interval) {
1278   proxy_->SetAuthoritativeVSyncInterval(interval);
1279 }
1280
1281 }  // namespace cc