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