cc/trees/layer_tree_impl.cc

   1 // Copyright 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/trees/layer_tree_impl.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "cc/animation/keyframed_animation_curve.h"
   9 #include "cc/animation/scrollbar_animation_controller.h"
  10 #include "cc/debug/traced_value.h"
  11 #include "cc/layers/heads_up_display_layer_impl.h"
  12 #include "cc/layers/layer.h"
  13 #include "cc/layers/render_surface_impl.h"
  14 #include "cc/layers/scrollbar_layer_impl_base.h"
  15 #include "cc/trees/layer_tree_host_common.h"
  16 #include "cc/trees/layer_tree_host_impl.h"
  17 #include "ui/gfx/size_conversions.h"
  18 #include "ui/gfx/vector2d_conversions.h"
  19
  20 namespace cc {
  21
  22 LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl)
  23     : layer_tree_host_impl_(layer_tree_host_impl),
  24       source_frame_number_(-1),
  25       hud_layer_(0),
  26       root_scroll_layer_(NULL),
  27       currently_scrolling_layer_(NULL),
  28       root_layer_scroll_offset_delegate_(NULL),
  29       background_color_(0),
  30       has_transparent_background_(false),
  31       page_scale_layer_(NULL),
  32       inner_viewport_scroll_layer_(NULL),
  33       outer_viewport_scroll_layer_(NULL),
  34       page_scale_factor_(1),
  35       page_scale_delta_(1),
  36       sent_page_scale_delta_(1),
  37       min_page_scale_factor_(0),
  38       max_page_scale_factor_(0),
  39       scrolling_layer_id_from_previous_tree_(0),
  40       contents_textures_purged_(false),
  41       viewport_size_invalid_(false),
  42       needs_update_draw_properties_(true),
  43       needs_full_tree_sync_(true) {
  44 }
  45
  46 LayerTreeImpl::~LayerTreeImpl() {
  47   // Need to explicitly clear the tree prior to destroying this so that
  48   // the LayerTreeImpl pointer is still valid in the LayerImpl dtor.
  49   root_layer_.reset();
  50 }
  51
  52 static LayerImpl* FindRootScrollLayerRecursive(LayerImpl* layer) {
  53   if (!layer)
  54     return NULL;
  55
  56   if (layer->scrollable())
  57     return layer;
  58
  59   for (size_t i = 0; i < layer->children().size(); ++i) {
  60     LayerImpl* found = FindRootScrollLayerRecursive(layer->children()[i]);
  61     if (found)
  62       return found;
  63   }
  64
  65   return NULL;
  66 }
  67
  68 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
  69   if (root_scroll_layer_)
  70     root_scroll_layer_->SetScrollOffsetDelegate(NULL);
  71   root_layer_ = layer.Pass();
  72   currently_scrolling_layer_ = NULL;
  73   root_scroll_layer_ = NULL;
  74
  75   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
  76 }
  77
  78 void LayerTreeImpl::FindRootScrollLayer() {
  79   root_scroll_layer_ = FindRootScrollLayerRecursive(root_layer_.get());
  80
  81   if (root_scroll_layer_) {
  82     UpdateMaxScrollOffset();
  83     root_scroll_layer_->SetScrollOffsetDelegate(
  84         root_layer_scroll_offset_delegate_);
  85   }
  86
  87   if (scrolling_layer_id_from_previous_tree_) {
  88     currently_scrolling_layer_ = LayerTreeHostCommon::FindLayerInSubtree(
  89         root_layer_.get(),
  90         scrolling_layer_id_from_previous_tree_);
  91   }
  92
  93   scrolling_layer_id_from_previous_tree_ = 0;
  94 }
  95
  96 scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() {
  97   // Clear all data structures that have direct references to the layer tree.
  98   scrolling_layer_id_from_previous_tree_ =
  99     currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
 100   if (root_scroll_layer_)
 101     root_scroll_layer_->SetScrollOffsetDelegate(NULL);
 102   root_scroll_layer_ = NULL;
 103   currently_scrolling_layer_ = NULL;
 104
 105   render_surface_layer_list_.clear();
 106   set_needs_update_draw_properties();
 107   return root_layer_.Pass();
 108 }
 109
 110 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
 111   // The request queue should have been processed and does not require a push.
 112   DCHECK_EQ(ui_resource_request_queue_.size(), 0u);
 113
 114   target_tree->SetLatencyInfo(latency_info_);
 115   latency_info_.Clear();
 116   target_tree->SetPageScaleFactorAndLimits(
 117       page_scale_factor(), min_page_scale_factor(), max_page_scale_factor());
 118   target_tree->SetPageScaleDelta(
 119       target_tree->page_scale_delta() / target_tree->sent_page_scale_delta());
 120   target_tree->set_sent_page_scale_delta(1);
 121
 122   if (settings().use_pinch_virtual_viewport) {
 123     target_tree->SetViewportLayersFromIds(
 124         page_scale_layer_->id(),
 125         inner_viewport_scroll_layer_->id(),
 126         outer_viewport_scroll_layer_ ? outer_viewport_scroll_layer_->id()
 127                                      : Layer::INVALID_ID);
 128   }
 129   // This should match the property synchronization in
 130   // LayerTreeHost::finishCommitOnImplThread().
 131   target_tree->set_source_frame_number(source_frame_number());
 132   target_tree->set_background_color(background_color());
 133   target_tree->set_has_transparent_background(has_transparent_background());
 134
 135   if (ContentsTexturesPurged())
 136     target_tree->SetContentsTexturesPurged();
 137   else
 138     target_tree->ResetContentsTexturesPurged();
 139
 140   if (ViewportSizeInvalid())
 141     target_tree->SetViewportSizeInvalid();
 142   else
 143     target_tree->ResetViewportSizeInvalid();
 144
 145   if (hud_layer())
 146     target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(
 147         LayerTreeHostCommon::FindLayerInSubtree(
 148             target_tree->root_layer(), hud_layer()->id())));
 149   else
 150     target_tree->set_hud_layer(NULL);
 151 }
 152
 153 LayerImpl* LayerTreeImpl::RootScrollLayer() const {
 154   return root_scroll_layer_;
 155 }
 156
 157 LayerImpl* LayerTreeImpl::RootContainerLayer() const {
 158   return root_scroll_layer_ ? root_scroll_layer_->parent() : NULL;
 159 }
 160
 161 LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() const {
 162   DCHECK(IsActiveTree());
 163   return currently_scrolling_layer_;
 164 }
 165
 166 void LayerTreeImpl::SetCurrentlyScrollingLayer(LayerImpl* layer) {
 167   if (currently_scrolling_layer_ == layer)
 168     return;
 169
 170   if (currently_scrolling_layer_ &&
 171       currently_scrolling_layer_->scrollbar_animation_controller())
 172     currently_scrolling_layer_->scrollbar_animation_controller()->
 173         DidScrollGestureEnd(CurrentPhysicalTimeTicks());
 174   currently_scrolling_layer_ = layer;
 175   if (layer && layer->scrollbar_animation_controller())
 176     layer->scrollbar_animation_controller()->DidScrollGestureBegin();
 177 }
 178
 179 void LayerTreeImpl::ClearCurrentlyScrollingLayer() {
 180   SetCurrentlyScrollingLayer(NULL);
 181   scrolling_layer_id_from_previous_tree_ = 0;
 182 }
 183
 184 void LayerTreeImpl::SetPageScaleFactorAndLimits(float page_scale_factor,
 185     float min_page_scale_factor, float max_page_scale_factor) {
 186   if (!page_scale_factor)
 187     return;
 188
 189   min_page_scale_factor_ = min_page_scale_factor;
 190   max_page_scale_factor_ = max_page_scale_factor;
 191   page_scale_factor_ = page_scale_factor;
 192 }
 193
 194 void LayerTreeImpl::SetPageScaleDelta(float delta) {
 195   // Clamp to the current min/max limits.
 196   float total = page_scale_factor_ * delta;
 197   if (min_page_scale_factor_ && total < min_page_scale_factor_)
 198     delta = min_page_scale_factor_ / page_scale_factor_;
 199   else if (max_page_scale_factor_ && total > max_page_scale_factor_)
 200     delta = max_page_scale_factor_ / page_scale_factor_;
 201
 202   if (delta == page_scale_delta_)
 203     return;
 204
 205   page_scale_delta_ = delta;
 206
 207   if (IsActiveTree()) {
 208     LayerTreeImpl* pending_tree = layer_tree_host_impl_->pending_tree();
 209     if (pending_tree) {
 210       DCHECK_EQ(1, pending_tree->sent_page_scale_delta());
 211       pending_tree->SetPageScaleDelta(
 212           page_scale_delta_ / sent_page_scale_delta_);
 213     }
 214   }
 215
 216   UpdateMaxScrollOffset();
 217   set_needs_update_draw_properties();
 218 }
 219
 220 gfx::SizeF LayerTreeImpl::ScrollableViewportSize() const {
 221   return gfx::ScaleSize(layer_tree_host_impl_->UnscaledScrollableViewportSize(),
 222                         1.0f / total_page_scale_factor());
 223 }
 224
 225 void LayerTreeImpl::UpdateMaxScrollOffset() {
 226   LayerImpl* root_scroll = RootScrollLayer();
 227   if (!root_scroll || !root_scroll->children().size())
 228     return;
 229
 230   gfx::Vector2dF max_scroll = gfx::Rect(ScrollableSize()).bottom_right() -
 231       gfx::RectF(ScrollableViewportSize()).bottom_right();
 232
 233   // The viewport may be larger than the contents in some cases, such as
 234   // having a vertical scrollbar but no horizontal overflow.
 235   max_scroll.SetToMax(gfx::Vector2dF());
 236
 237   root_scroll_layer_->SetMaxScrollOffset(gfx::ToFlooredVector2d(max_scroll));
 238 }
 239
 240 static void ApplySentScrollDeltasFromAbortedCommitTo(LayerImpl* layer) {
 241   layer->ApplySentScrollDeltasFromAbortedCommit();
 242 }
 243
 244 void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() {
 245   DCHECK(IsActiveTree());
 246
 247   page_scale_factor_ *= sent_page_scale_delta_;
 248   page_scale_delta_ /= sent_page_scale_delta_;
 249   sent_page_scale_delta_ = 1.f;
 250
 251   if (!root_layer())
 252     return;
 253
 254   LayerTreeHostCommon::CallFunctionForSubtree(
 255       root_layer(), base::Bind(&ApplySentScrollDeltasFromAbortedCommitTo));
 256 }
 257
 258 static void ApplyScrollDeltasSinceBeginFrameTo(LayerImpl* layer) {
 259   layer->ApplyScrollDeltasSinceBeginFrame();
 260 }
 261
 262 void LayerTreeImpl::ApplyScrollDeltasSinceBeginFrame() {
 263   DCHECK(IsPendingTree());
 264   if (!root_layer())
 265     return;
 266
 267   LayerTreeHostCommon::CallFunctionForSubtree(
 268       root_layer(), base::Bind(&ApplyScrollDeltasSinceBeginFrameTo));
 269 }
 270
 271 void LayerTreeImpl::SetViewportLayersFromIds(
 272     int page_scale_layer_id,
 273     int inner_viewport_scroll_layer_id,
 274     int outer_viewport_scroll_layer_id) {
 275   page_scale_layer_ = LayerById(page_scale_layer_id);
 276   DCHECK(page_scale_layer_);
 277
 278   inner_viewport_scroll_layer_ =
 279       LayerById(inner_viewport_scroll_layer_id);
 280   DCHECK(inner_viewport_scroll_layer_);
 281
 282   outer_viewport_scroll_layer_ =
 283       LayerById(outer_viewport_scroll_layer_id);
 284   DCHECK(outer_viewport_scroll_layer_ ||
 285          outer_viewport_scroll_layer_id == Layer::INVALID_ID);
 286 }
 287
 288 void LayerTreeImpl::ClearViewportLayers() {
 289   page_scale_layer_ = NULL;
 290   inner_viewport_scroll_layer_ = NULL;
 291   outer_viewport_scroll_layer_ = NULL;
 292 }
 293
 294 // TODO(wjmaclean) This needs to go away, and be replaced with a single core
 295 // of login that works for both scrollbar layer types. This is already planned
 296 // as part of the larger pinch-zoom re-factoring viewport.
 297 void LayerTreeImpl::UpdateSolidColorScrollbars() {
 298   DCHECK(settings().solid_color_scrollbars);
 299
 300   LayerImpl* root_scroll = RootScrollLayer();
 301   DCHECK(root_scroll);
 302   DCHECK(IsActiveTree());
 303
 304   gfx::RectF scrollable_viewport(
 305       gfx::PointAtOffsetFromOrigin(root_scroll->TotalScrollOffset()),
 306       ScrollableViewportSize());
 307   float vertical_adjust = 0.0f;
 308   if (RootContainerLayer())
 309     vertical_adjust =
 310         layer_tree_host_impl_->UnscaledScrollableViewportSize().height() -
 311         RootContainerLayer()->bounds().height();
 312   if (ScrollbarLayerImplBase* horiz =
 313           root_scroll->horizontal_scrollbar_layer()) {
 314     horiz->SetVerticalAdjust(vertical_adjust);
 315     horiz->SetVisibleToTotalLengthRatio(
 316         scrollable_viewport.width() / ScrollableSize().width());
 317   }
 318   if (ScrollbarLayerImplBase* vertical =
 319           root_scroll->vertical_scrollbar_layer()) {
 320     vertical->SetVerticalAdjust(vertical_adjust);
 321     vertical->SetVisibleToTotalLengthRatio(
 322         scrollable_viewport.height() / ScrollableSize().height());
 323   }
 324 }
 325
 326 void LayerTreeImpl::UpdateDrawProperties() {
 327   if (IsActiveTree() && RootScrollLayer() && RootContainerLayer())
 328     UpdateRootScrollLayerSizeDelta();
 329
 330   if (settings().solid_color_scrollbars &&
 331       IsActiveTree() &&
 332       RootScrollLayer()) {
 333     UpdateSolidColorScrollbars();
 334   }
 335
 336   needs_update_draw_properties_ = false;
 337   render_surface_layer_list_.clear();
 338
 339   // For max_texture_size.
 340   if (!layer_tree_host_impl_->renderer())
 341     return;
 342
 343   if (!root_layer())
 344     return;
 345
 346   {
 347     TRACE_EVENT2("cc",
 348                  "LayerTreeImpl::UpdateDrawProperties",
 349                  "IsActive",
 350                  IsActiveTree(),
 351                  "SourceFrameNumber",
 352                  source_frame_number_);
 353     LayerImpl* page_scale_layer =
 354         page_scale_layer_ ? page_scale_layer_ : RootContainerLayer();
 355     LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
 356         root_layer(),
 357         DrawViewportSize(),
 358         layer_tree_host_impl_->DrawTransform(),
 359         device_scale_factor(),
 360         total_page_scale_factor(),
 361         page_scale_layer,
 362         MaxTextureSize(),
 363         settings().can_use_lcd_text,
 364         settings().layer_transforms_should_scale_layer_contents,
 365         &render_surface_layer_list_);
 366     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 367   }
 368
 369   DCHECK(!needs_update_draw_properties_) <<
 370       "CalcDrawProperties should not set_needs_update_draw_properties()";
 371 }
 372
 373 const LayerImplList& LayerTreeImpl::RenderSurfaceLayerList() const {
 374   // If this assert triggers, then the list is dirty.
 375   DCHECK(!needs_update_draw_properties_);
 376   return render_surface_layer_list_;
 377 }
 378
 379 gfx::Size LayerTreeImpl::ScrollableSize() const {
 380   if (!root_scroll_layer_ || root_scroll_layer_->children().empty())
 381     return gfx::Size();
 382   return root_scroll_layer_->children()[0]->bounds();
 383 }
 384
 385 LayerImpl* LayerTreeImpl::LayerById(int id) {
 386   LayerIdMap::iterator iter = layer_id_map_.find(id);
 387   return iter != layer_id_map_.end() ? iter->second : NULL;
 388 }
 389
 390 void LayerTreeImpl::RegisterLayer(LayerImpl* layer) {
 391   DCHECK(!LayerById(layer->id()));
 392   layer_id_map_[layer->id()] = layer;
 393 }
 394
 395 void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) {
 396   DCHECK(LayerById(layer->id()));
 397   layer_id_map_.erase(layer->id());
 398 }
 399
 400 void LayerTreeImpl::PushPersistedState(LayerTreeImpl* pending_tree) {
 401   pending_tree->SetCurrentlyScrollingLayer(
 402       LayerTreeHostCommon::FindLayerInSubtree(pending_tree->root_layer(),
 403           currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0));
 404   pending_tree->SetLatencyInfo(latency_info_);
 405   latency_info_.Clear();
 406 }
 407
 408 static void DidBecomeActiveRecursive(LayerImpl* layer) {
 409   layer->DidBecomeActive();
 410   for (size_t i = 0; i < layer->children().size(); ++i)
 411     DidBecomeActiveRecursive(layer->children()[i]);
 412 }
 413
 414 void LayerTreeImpl::DidBecomeActive() {
 415   if (!root_layer())
 416     return;
 417
 418   DidBecomeActiveRecursive(root_layer());
 419   FindRootScrollLayer();
 420 }
 421
 422 bool LayerTreeImpl::ContentsTexturesPurged() const {
 423   return contents_textures_purged_;
 424 }
 425
 426 void LayerTreeImpl::SetContentsTexturesPurged() {
 427   if (contents_textures_purged_)
 428     return;
 429   contents_textures_purged_ = true;
 430   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 431 }
 432
 433 void LayerTreeImpl::ResetContentsTexturesPurged() {
 434   if (!contents_textures_purged_)
 435     return;
 436   contents_textures_purged_ = false;
 437   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 438 }
 439
 440 bool LayerTreeImpl::ViewportSizeInvalid() const {
 441   return viewport_size_invalid_;
 442 }
 443
 444 void LayerTreeImpl::SetViewportSizeInvalid() {
 445   viewport_size_invalid_ = true;
 446   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 447 }
 448
 449 void LayerTreeImpl::ResetViewportSizeInvalid() {
 450   viewport_size_invalid_ = false;
 451   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 452 }
 453
 454 Proxy* LayerTreeImpl::proxy() const {
 455   return layer_tree_host_impl_->proxy();
 456 }
 457
 458 const LayerTreeSettings& LayerTreeImpl::settings() const {
 459   return layer_tree_host_impl_->settings();
 460 }
 461
 462 const RendererCapabilities& LayerTreeImpl::GetRendererCapabilities() const {
 463   return layer_tree_host_impl_->GetRendererCapabilities();
 464 }
 465
 466 ContextProvider* LayerTreeImpl::context_provider() const {
 467   return output_surface()->context_provider();
 468 }
 469
 470 OutputSurface* LayerTreeImpl::output_surface() const {
 471   return layer_tree_host_impl_->output_surface();
 472 }
 473
 474 ResourceProvider* LayerTreeImpl::resource_provider() const {
 475   return layer_tree_host_impl_->resource_provider();
 476 }
 477
 478 TileManager* LayerTreeImpl::tile_manager() const {
 479   return layer_tree_host_impl_->tile_manager();
 480 }
 481
 482 FrameRateCounter* LayerTreeImpl::frame_rate_counter() const {
 483   return layer_tree_host_impl_->fps_counter();
 484 }
 485
 486 PaintTimeCounter* LayerTreeImpl::paint_time_counter() const {
 487   return layer_tree_host_impl_->paint_time_counter();
 488 }
 489
 490 MemoryHistory* LayerTreeImpl::memory_history() const {
 491   return layer_tree_host_impl_->memory_history();
 492 }
 493
 494 bool LayerTreeImpl::device_viewport_valid_for_tile_management() const {
 495   return layer_tree_host_impl_->device_viewport_valid_for_tile_management();
 496 }
 497
 498 bool LayerTreeImpl::IsActiveTree() const {
 499   return layer_tree_host_impl_->active_tree() == this;
 500 }
 501
 502 bool LayerTreeImpl::IsPendingTree() const {
 503   return layer_tree_host_impl_->pending_tree() == this;
 504 }
 505
 506 bool LayerTreeImpl::IsRecycleTree() const {
 507   return layer_tree_host_impl_->recycle_tree() == this;
 508 }
 509
 510 LayerImpl* LayerTreeImpl::FindActiveTreeLayerById(int id) {
 511   LayerTreeImpl* tree = layer_tree_host_impl_->active_tree();
 512   if (!tree)
 513     return NULL;
 514   return tree->LayerById(id);
 515 }
 516
 517 LayerImpl* LayerTreeImpl::FindPendingTreeLayerById(int id) {
 518   LayerTreeImpl* tree = layer_tree_host_impl_->pending_tree();
 519   if (!tree)
 520     return NULL;
 521   return tree->LayerById(id);
 522 }
 523
 524 int LayerTreeImpl::MaxTextureSize() const {
 525   return layer_tree_host_impl_->GetRendererCapabilities().max_texture_size;
 526 }
 527
 528 bool LayerTreeImpl::PinchGestureActive() const {
 529   return layer_tree_host_impl_->pinch_gesture_active();
 530 }
 531
 532 base::TimeTicks LayerTreeImpl::CurrentFrameTimeTicks() const {
 533   return layer_tree_host_impl_->CurrentFrameTimeTicks();
 534 }
 535
 536 base::Time LayerTreeImpl::CurrentFrameTime() const {
 537   return layer_tree_host_impl_->CurrentFrameTime();
 538 }
 539
 540 base::TimeTicks LayerTreeImpl::CurrentPhysicalTimeTicks() const {
 541   return layer_tree_host_impl_->CurrentPhysicalTimeTicks();
 542 }
 543
 544 void LayerTreeImpl::SetNeedsCommit() {
 545   layer_tree_host_impl_->SetNeedsCommit();
 546 }
 547
 548 gfx::Size LayerTreeImpl::DrawViewportSize() const {
 549   return layer_tree_host_impl_->DrawViewportSize();
 550 }
 551
 552 void LayerTreeImpl::StartScrollbarAnimation() {
 553   layer_tree_host_impl_->StartScrollbarAnimation();
 554 }
 555
 556 void LayerTreeImpl::SetNeedsRedraw() {
 557   layer_tree_host_impl_->SetNeedsRedraw();
 558 }
 559
 560 const LayerTreeDebugState& LayerTreeImpl::debug_state() const {
 561   return layer_tree_host_impl_->debug_state();
 562 }
 563
 564 float LayerTreeImpl::device_scale_factor() const {
 565   return layer_tree_host_impl_->device_scale_factor();
 566 }
 567
 568 DebugRectHistory* LayerTreeImpl::debug_rect_history() const {
 569   return layer_tree_host_impl_->debug_rect_history();
 570 }
 571
 572 AnimationRegistrar* LayerTreeImpl::animationRegistrar() const {
 573   return layer_tree_host_impl_->animation_registrar();
 574 }
 575
 576 scoped_ptr<base::Value> LayerTreeImpl::AsValue() const {
 577   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
 578   TracedValue::MakeDictIntoImplicitSnapshot(
 579       state.get(), "cc::LayerTreeImpl", this);
 580
 581   state->Set("root_layer", root_layer_->AsValue().release());
 582
 583   scoped_ptr<base::ListValue> render_surface_layer_list(new base::ListValue());
 584   typedef LayerIterator<LayerImpl,
 585                         LayerImplList,
 586                         RenderSurfaceImpl,
 587                         LayerIteratorActions::BackToFront> LayerIteratorType;
 588   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list_);
 589   for (LayerIteratorType it = LayerIteratorType::Begin(
 590            &render_surface_layer_list_); it != end; ++it) {
 591     if (!it.represents_itself())
 592       continue;
 593     render_surface_layer_list->Append(TracedValue::CreateIDRef(*it).release());
 594   }
 595
 596   state->Set("render_surface_layer_list",
 597              render_surface_layer_list.release());
 598   return state.PassAs<base::Value>();
 599 }
 600
 601 void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
 602     LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
 603   root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
 604   if (root_scroll_layer_) {
 605     root_scroll_layer_->SetScrollOffsetDelegate(
 606         root_layer_scroll_offset_delegate_);
 607   }
 608 }
 609
 610 void LayerTreeImpl::UpdateRootScrollLayerSizeDelta() {
 611   LayerImpl* root_scroll = RootScrollLayer();
 612   LayerImpl* root_container = RootContainerLayer();
 613   DCHECK(root_scroll);
 614   DCHECK(root_container);
 615   DCHECK(IsActiveTree());
 616
 617   gfx::Vector2dF scrollable_viewport_size =
 618       gfx::RectF(ScrollableViewportSize()).bottom_right() - gfx::PointF();
 619
 620   gfx::Vector2dF original_viewport_size =
 621       gfx::RectF(root_container->bounds()).bottom_right() -
 622       gfx::PointF();
 623   original_viewport_size.Scale(1 / page_scale_factor());
 624
 625   root_scroll->SetFixedContainerSizeDelta(
 626       scrollable_viewport_size - original_viewport_size);
 627 }
 628
 629 void LayerTreeImpl::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
 630   latency_info_.MergeWith(latency_info);
 631 }
 632
 633 const ui::LatencyInfo& LayerTreeImpl::GetLatencyInfo() {
 634   return latency_info_;
 635 }
 636
 637 void LayerTreeImpl::ClearLatencyInfo() {
 638   latency_info_.Clear();
 639 }
 640
 641 void LayerTreeImpl::DidModifyTilePriorities() {
 642   layer_tree_host_impl_->DidModifyTilePriorities();
 643 }
 644
 645 void LayerTreeImpl::set_ui_resource_request_queue(
 646     const UIResourceRequestQueue& queue) {
 647   ui_resource_request_queue_ = queue;
 648 }
 649
 650 ResourceProvider::ResourceId LayerTreeImpl::ResourceIdForUIResource(
 651     UIResourceId uid) const {
 652   return layer_tree_host_impl_->ResourceIdForUIResource(uid);
 653 }
 654
 655 void LayerTreeImpl::ProcessUIResourceRequestQueue() {
 656   while (ui_resource_request_queue_.size() > 0) {
 657     UIResourceRequest req = ui_resource_request_queue_.front();
 658     ui_resource_request_queue_.pop_front();
 659
 660     switch (req.type) {
 661       case UIResourceRequest::UIResourceCreate:
 662         layer_tree_host_impl_->CreateUIResource(req.id, req.bitmap);
 663         break;
 664       case UIResourceRequest::UIResourceDelete:
 665         layer_tree_host_impl_->DeleteUIResource(req.id);
 666         break;
 667       case UIResourceRequest::UIResourceInvalidRequest:
 668         NOTREACHED();
 669         break;
 670     }
 671   }
 672
 673   // If all UI resource evictions were not recreated by processing this queue,
 674   // then another commit is required.
 675   if (layer_tree_host_impl_->EvictedUIResourcesExist())
 676     layer_tree_host_impl_->SetNeedsCommit();
 677 }
 678
 679 void LayerTreeImpl::AddLayerWithCopyOutputRequest(LayerImpl* layer) {
 680   // Only the active tree needs to know about layers with copy requests, as
 681   // they are aborted if not serviced during draw.
 682   DCHECK(IsActiveTree());
 683
 684   DCHECK(std::find(layers_with_copy_output_request_.begin(),
 685                    layers_with_copy_output_request_.end(),
 686                    layer) == layers_with_copy_output_request_.end());
 687   layers_with_copy_output_request_.push_back(layer);
 688 }
 689
 690 void LayerTreeImpl::RemoveLayerWithCopyOutputRequest(LayerImpl* layer) {
 691   // Only the active tree needs to know about layers with copy requests, as
 692   // they are aborted if not serviced during draw.
 693   DCHECK(IsActiveTree());
 694
 695   std::vector<LayerImpl*>::iterator it = std::find(
 696       layers_with_copy_output_request_.begin(),
 697       layers_with_copy_output_request_.end(),
 698       layer);
 699   DCHECK(it != layers_with_copy_output_request_.end());
 700   layers_with_copy_output_request_.erase(it);
 701 }
 702
 703 const std::vector<LayerImpl*> LayerTreeImpl::LayersWithCopyOutputRequest()
 704     const {
 705   // Only the active tree needs to know about layers with copy requests, as
 706   // they are aborted if not serviced during draw.
 707   DCHECK(IsActiveTree());
 708
 709   return layers_with_copy_output_request_;
 710 }
 711
 712 }  // namespace cc