src/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/base/math_util.h"
  11 #include "cc/base/util.h"
  12 #include "cc/debug/traced_value.h"
  13 #include "cc/layers/heads_up_display_layer_impl.h"
  14 #include "cc/layers/layer.h"
  15 #include "cc/layers/render_surface_impl.h"
  16 #include "cc/layers/scrollbar_layer_impl_base.h"
  17 #include "cc/resources/ui_resource_request.h"
  18 #include "cc/trees/layer_tree_host_common.h"
  19 #include "cc/trees/layer_tree_host_impl.h"
  20 #include "ui/gfx/size_conversions.h"
  21 #include "ui/gfx/vector2d_conversions.h"
  22
  23 namespace cc {
  24
  25 // This class exists to split the LayerScrollOffsetDelegate between the
  26 // InnerViewportScrollLayer and the OuterViewportScrollLayer in a manner
  27 // that never requires the embedder or LayerImpl to know about.
  28 class LayerScrollOffsetDelegateProxy : public LayerScrollOffsetDelegate {
  29  public:
  30   LayerScrollOffsetDelegateProxy(LayerImpl* layer,
  31                                  LayerScrollOffsetDelegate* delegate,
  32                                  LayerTreeImpl* layer_tree)
  33       : layer_(layer), delegate_(delegate), layer_tree_impl_(layer_tree) {}
  34
  35   gfx::Vector2dF last_set_scroll_offset() const {
  36     return last_set_scroll_offset_;
  37   }
  38
  39   // LayerScrollOffsetDelegate implementation.
  40
  41   virtual void SetTotalScrollOffset(const gfx::Vector2dF& new_offset) OVERRIDE {
  42     last_set_scroll_offset_ = new_offset;
  43     layer_tree_impl_->UpdateScrollOffsetDelegate();
  44   }
  45
  46   virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE {
  47     return layer_tree_impl_->GetDelegatedScrollOffset(layer_);
  48   }
  49
  50   virtual bool IsExternalFlingActive() const OVERRIDE {
  51     return delegate_->IsExternalFlingActive();
  52   }
  53
  54   // Functions below this point are never called by LayerImpl on its
  55   // LayerScrollOffsetDelegate, and so are not implemented.
  56   virtual void SetMaxScrollOffset(const gfx::Vector2dF&) OVERRIDE {
  57     NOTIMPLEMENTED();
  58   }
  59
  60   virtual void SetTotalPageScaleFactorAndLimits(float, float, float) OVERRIDE {
  61     NOTIMPLEMENTED();
  62   }
  63
  64   virtual void SetScrollableSize(const gfx::SizeF& scrollable_size) OVERRIDE {
  65     NOTIMPLEMENTED();
  66   }
  67
  68  private:
  69   LayerImpl* layer_;
  70   LayerScrollOffsetDelegate* delegate_;
  71   LayerTreeImpl* layer_tree_impl_;
  72   gfx::Vector2dF last_set_scroll_offset_;
  73 };
  74
  75 LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl)
  76     : layer_tree_host_impl_(layer_tree_host_impl),
  77       source_frame_number_(-1),
  78       hud_layer_(0),
  79       currently_scrolling_layer_(NULL),
  80       root_layer_scroll_offset_delegate_(NULL),
  81       background_color_(0),
  82       has_transparent_background_(false),
  83       page_scale_layer_(NULL),
  84       inner_viewport_scroll_layer_(NULL),
  85       outer_viewport_scroll_layer_(NULL),
  86       page_scale_factor_(1),
  87       page_scale_delta_(1),
  88       sent_page_scale_delta_(1),
  89       min_page_scale_factor_(0),
  90       max_page_scale_factor_(0),
  91       scrolling_layer_id_from_previous_tree_(0),
  92       contents_textures_purged_(false),
  93       requires_high_res_to_draw_(false),
  94       viewport_size_invalid_(false),
  95       needs_update_draw_properties_(true),
  96       needs_full_tree_sync_(true),
  97       next_activation_forces_redraw_(false) {}
  98
  99 LayerTreeImpl::~LayerTreeImpl() {
 100   // Need to explicitly clear the tree prior to destroying this so that
 101   // the LayerTreeImpl pointer is still valid in the LayerImpl dtor.
 102   DCHECK(!root_layer_);
 103   DCHECK(layers_with_copy_output_request_.empty());
 104 }
 105
 106 void LayerTreeImpl::Shutdown() { root_layer_.reset(); }
 107
 108 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
 109   if (inner_viewport_scroll_layer_)
 110     inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
 111   if (outer_viewport_scroll_layer_)
 112     outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
 113   inner_viewport_scroll_delegate_proxy_.reset();
 114   outer_viewport_scroll_delegate_proxy_.reset();
 115
 116   root_layer_ = layer.Pass();
 117   currently_scrolling_layer_ = NULL;
 118   inner_viewport_scroll_layer_ = NULL;
 119   outer_viewport_scroll_layer_ = NULL;
 120   page_scale_layer_ = NULL;
 121
 122   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 123 }
 124
 125 LayerImpl* LayerTreeImpl::InnerViewportScrollLayer() const {
 126   return inner_viewport_scroll_layer_;
 127 }
 128
 129 LayerImpl* LayerTreeImpl::OuterViewportScrollLayer() const {
 130   return outer_viewport_scroll_layer_;
 131 }
 132
 133 gfx::Vector2dF LayerTreeImpl::TotalScrollOffset() const {
 134   gfx::Vector2dF offset;
 135
 136   if (inner_viewport_scroll_layer_)
 137     offset += inner_viewport_scroll_layer_->TotalScrollOffset();
 138
 139   if (outer_viewport_scroll_layer_)
 140     offset += outer_viewport_scroll_layer_->TotalScrollOffset();
 141
 142   return offset;
 143 }
 144
 145 gfx::Vector2dF LayerTreeImpl::TotalMaxScrollOffset() const {
 146   gfx::Vector2dF offset;
 147
 148   if (inner_viewport_scroll_layer_)
 149     offset += inner_viewport_scroll_layer_->MaxScrollOffset();
 150
 151   if (outer_viewport_scroll_layer_)
 152     offset += outer_viewport_scroll_layer_->MaxScrollOffset();
 153
 154   return offset;
 155 }
 156 gfx::Vector2dF LayerTreeImpl::TotalScrollDelta() const {
 157   DCHECK(inner_viewport_scroll_layer_);
 158   gfx::Vector2dF delta = inner_viewport_scroll_layer_->ScrollDelta();
 159
 160   if (outer_viewport_scroll_layer_)
 161     delta += outer_viewport_scroll_layer_->ScrollDelta();
 162
 163   return delta;
 164 }
 165
 166 scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() {
 167   // Clear all data structures that have direct references to the layer tree.
 168   scrolling_layer_id_from_previous_tree_ =
 169     currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
 170   if (inner_viewport_scroll_layer_)
 171     inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
 172   if (outer_viewport_scroll_layer_)
 173     outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
 174   inner_viewport_scroll_delegate_proxy_.reset();
 175   outer_viewport_scroll_delegate_proxy_.reset();
 176   inner_viewport_scroll_layer_ = NULL;
 177   outer_viewport_scroll_layer_ = NULL;
 178   page_scale_layer_ = NULL;
 179   currently_scrolling_layer_ = NULL;
 180
 181   render_surface_layer_list_.clear();
 182   set_needs_update_draw_properties();
 183   return root_layer_.Pass();
 184 }
 185
 186 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
 187   // The request queue should have been processed and does not require a push.
 188   DCHECK_EQ(ui_resource_request_queue_.size(), 0u);
 189
 190   if (next_activation_forces_redraw_) {
 191     layer_tree_host_impl_->SetFullRootLayerDamage();
 192     next_activation_forces_redraw_ = false;
 193   }
 194
 195   target_tree->PassSwapPromises(&swap_promise_list_);
 196
 197   target_tree->SetPageScaleFactorAndLimits(
 198       page_scale_factor(), min_page_scale_factor(), max_page_scale_factor());
 199   target_tree->SetPageScaleDelta(
 200       target_tree->page_scale_delta() / target_tree->sent_page_scale_delta());
 201   target_tree->set_sent_page_scale_delta(1);
 202
 203   if (page_scale_layer_ && inner_viewport_scroll_layer_) {
 204     target_tree->SetViewportLayersFromIds(
 205         page_scale_layer_->id(),
 206         inner_viewport_scroll_layer_->id(),
 207         outer_viewport_scroll_layer_ ? outer_viewport_scroll_layer_->id()
 208                                      : Layer::INVALID_ID);
 209   } else {
 210     target_tree->ClearViewportLayers();
 211   }
 212   // This should match the property synchronization in
 213   // LayerTreeHost::finishCommitOnImplThread().
 214   target_tree->set_source_frame_number(source_frame_number());
 215   target_tree->set_background_color(background_color());
 216   target_tree->set_has_transparent_background(has_transparent_background());
 217
 218   if (ContentsTexturesPurged())
 219     target_tree->SetContentsTexturesPurged();
 220   else
 221     target_tree->ResetContentsTexturesPurged();
 222
 223   // Always reset this flag on activation, as we would only have activated
 224   // if we were in a good state.
 225   target_tree->ResetRequiresHighResToDraw();
 226
 227   if (ViewportSizeInvalid())
 228     target_tree->SetViewportSizeInvalid();
 229   else
 230     target_tree->ResetViewportSizeInvalid();
 231
 232   if (hud_layer())
 233     target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(
 234         LayerTreeHostCommon::FindLayerInSubtree(
 235             target_tree->root_layer(), hud_layer()->id())));
 236   else
 237     target_tree->set_hud_layer(NULL);
 238 }
 239
 240 LayerImpl* LayerTreeImpl::InnerViewportContainerLayer() const {
 241   return inner_viewport_scroll_layer_
 242              ? inner_viewport_scroll_layer_->scroll_clip_layer()
 243              : NULL;
 244 }
 245
 246 LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() const {
 247   DCHECK(IsActiveTree());
 248   return currently_scrolling_layer_;
 249 }
 250
 251 void LayerTreeImpl::SetCurrentlyScrollingLayer(LayerImpl* layer) {
 252   if (currently_scrolling_layer_ == layer)
 253     return;
 254
 255   if (currently_scrolling_layer_ &&
 256       currently_scrolling_layer_->scrollbar_animation_controller())
 257     currently_scrolling_layer_->scrollbar_animation_controller()->
 258         DidScrollGestureEnd(CurrentPhysicalTimeTicks());
 259   currently_scrolling_layer_ = layer;
 260   if (layer && layer->scrollbar_animation_controller())
 261     layer->scrollbar_animation_controller()->DidScrollGestureBegin();
 262 }
 263
 264 void LayerTreeImpl::ClearCurrentlyScrollingLayer() {
 265   SetCurrentlyScrollingLayer(NULL);
 266   scrolling_layer_id_from_previous_tree_ = 0;
 267 }
 268
 269 float LayerTreeImpl::VerticalAdjust(const LayerImpl* layer) const {
 270   DCHECK(layer);
 271   if (layer->parent() != InnerViewportContainerLayer())
 272     return 0.f;
 273
 274   return layer_tree_host_impl_->VerticalAdjust();
 275 }
 276
 277 namespace {
 278
 279 void ForceScrollbarParameterUpdateAfterScaleChange(LayerImpl* current_layer) {
 280   if (!current_layer)
 281     return;
 282
 283   while (current_layer) {
 284     current_layer->ScrollbarParametersDidChange();
 285     current_layer = current_layer->parent();
 286   }
 287 }
 288
 289 }  // namespace
 290
 291 void LayerTreeImpl::SetPageScaleFactorAndLimits(float page_scale_factor,
 292     float min_page_scale_factor, float max_page_scale_factor) {
 293   if (!page_scale_factor)
 294     return;
 295
 296   if (min_page_scale_factor == min_page_scale_factor_ &&
 297       max_page_scale_factor == max_page_scale_factor_ &&
 298       page_scale_factor == page_scale_factor_)
 299     return;
 300
 301   min_page_scale_factor_ = min_page_scale_factor;
 302   max_page_scale_factor_ = max_page_scale_factor;
 303   page_scale_factor_ = page_scale_factor;
 304
 305   if (root_layer_scroll_offset_delegate_) {
 306     root_layer_scroll_offset_delegate_->SetTotalPageScaleFactorAndLimits(
 307         total_page_scale_factor(),
 308         this->min_page_scale_factor(),
 309         this->max_page_scale_factor());
 310   }
 311
 312   ForceScrollbarParameterUpdateAfterScaleChange(page_scale_layer());
 313 }
 314
 315 void LayerTreeImpl::SetPageScaleDelta(float delta) {
 316   // Clamp to the current min/max limits.
 317   float total = page_scale_factor_ * delta;
 318   if (min_page_scale_factor_ && total < min_page_scale_factor_)
 319     delta = min_page_scale_factor_ / page_scale_factor_;
 320   else if (max_page_scale_factor_ && total > max_page_scale_factor_)
 321     delta = max_page_scale_factor_ / page_scale_factor_;
 322
 323   if (delta == page_scale_delta_)
 324     return;
 325
 326   page_scale_delta_ = delta;
 327
 328   if (IsActiveTree()) {
 329     LayerTreeImpl* pending_tree = layer_tree_host_impl_->pending_tree();
 330     if (pending_tree) {
 331       DCHECK_EQ(1, pending_tree->sent_page_scale_delta());
 332       pending_tree->SetPageScaleDelta(
 333           page_scale_delta_ / sent_page_scale_delta_);
 334     }
 335   }
 336
 337   set_needs_update_draw_properties();
 338
 339   if (root_layer_scroll_offset_delegate_) {
 340     root_layer_scroll_offset_delegate_->SetTotalPageScaleFactorAndLimits(
 341         total_page_scale_factor(),
 342         min_page_scale_factor(),
 343         max_page_scale_factor());
 344   }
 345 }
 346
 347 gfx::SizeF LayerTreeImpl::ScrollableViewportSize() const {
 348   if (outer_viewport_scroll_layer_)
 349     return layer_tree_host_impl_->UnscaledScrollableViewportSize();
 350   else
 351     return gfx::ScaleSize(
 352         layer_tree_host_impl_->UnscaledScrollableViewportSize(),
 353         1.0f / total_page_scale_factor());
 354 }
 355
 356 gfx::Rect LayerTreeImpl::RootScrollLayerDeviceViewportBounds() const {
 357   LayerImpl* root_scroll_layer = OuterViewportScrollLayer()
 358                                      ? OuterViewportScrollLayer()
 359                                      : InnerViewportScrollLayer();
 360   if (!root_scroll_layer || root_scroll_layer->children().empty())
 361     return gfx::Rect();
 362   LayerImpl* layer = root_scroll_layer->children()[0];
 363   return MathUtil::MapEnclosingClippedRect(layer->screen_space_transform(),
 364                                            gfx::Rect(layer->content_bounds()));
 365 }
 366
 367 static void ApplySentScrollDeltasFromAbortedCommitTo(LayerImpl* layer) {
 368   layer->ApplySentScrollDeltasFromAbortedCommit();
 369 }
 370
 371 void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() {
 372   DCHECK(IsActiveTree());
 373
 374   page_scale_factor_ *= sent_page_scale_delta_;
 375   page_scale_delta_ /= sent_page_scale_delta_;
 376   sent_page_scale_delta_ = 1.f;
 377
 378   if (!root_layer())
 379     return;
 380
 381   LayerTreeHostCommon::CallFunctionForSubtree(
 382       root_layer(), base::Bind(&ApplySentScrollDeltasFromAbortedCommitTo));
 383 }
 384
 385 static void ApplyScrollDeltasSinceBeginMainFrameTo(LayerImpl* layer) {
 386   layer->ApplyScrollDeltasSinceBeginMainFrame();
 387 }
 388
 389 void LayerTreeImpl::ApplyScrollDeltasSinceBeginMainFrame() {
 390   DCHECK(IsPendingTree());
 391   if (!root_layer())
 392     return;
 393
 394   LayerTreeHostCommon::CallFunctionForSubtree(
 395       root_layer(), base::Bind(&ApplyScrollDeltasSinceBeginMainFrameTo));
 396 }
 397
 398 void LayerTreeImpl::SetViewportLayersFromIds(
 399     int page_scale_layer_id,
 400     int inner_viewport_scroll_layer_id,
 401     int outer_viewport_scroll_layer_id) {
 402   page_scale_layer_ = LayerById(page_scale_layer_id);
 403   DCHECK(page_scale_layer_);
 404
 405   inner_viewport_scroll_layer_ =
 406       LayerById(inner_viewport_scroll_layer_id);
 407   DCHECK(inner_viewport_scroll_layer_);
 408
 409   outer_viewport_scroll_layer_ =
 410       LayerById(outer_viewport_scroll_layer_id);
 411   DCHECK(outer_viewport_scroll_layer_ ||
 412          outer_viewport_scroll_layer_id == Layer::INVALID_ID);
 413
 414   if (!root_layer_scroll_offset_delegate_)
 415     return;
 416
 417   inner_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
 418       new LayerScrollOffsetDelegateProxy(inner_viewport_scroll_layer_,
 419                                          root_layer_scroll_offset_delegate_,
 420                                          this));
 421
 422   if (outer_viewport_scroll_layer_)
 423     outer_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
 424         new LayerScrollOffsetDelegateProxy(outer_viewport_scroll_layer_,
 425                                            root_layer_scroll_offset_delegate_,
 426                                            this));
 427 }
 428
 429 void LayerTreeImpl::ClearViewportLayers() {
 430   page_scale_layer_ = NULL;
 431   inner_viewport_scroll_layer_ = NULL;
 432   outer_viewport_scroll_layer_ = NULL;
 433 }
 434
 435 void LayerTreeImpl::UpdateDrawProperties() {
 436   needs_update_draw_properties_ = false;
 437   render_surface_layer_list_.clear();
 438
 439   // For max_texture_size.
 440   if (!layer_tree_host_impl_->renderer())
 441     return;
 442
 443   if (!root_layer())
 444     return;
 445
 446   {
 447     TRACE_EVENT2("cc",
 448                  "LayerTreeImpl::UpdateDrawProperties",
 449                  "IsActive",
 450                  IsActiveTree(),
 451                  "SourceFrameNumber",
 452                  source_frame_number_);
 453     LayerImpl* page_scale_layer =
 454         page_scale_layer_ ? page_scale_layer_ : InnerViewportContainerLayer();
 455     bool can_render_to_separate_surface =
 456         !output_surface()->ForcedDrawToSoftwareDevice();
 457     LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
 458         root_layer(),
 459         DrawViewportSize(),
 460         layer_tree_host_impl_->DrawTransform(),
 461         device_scale_factor(),
 462         total_page_scale_factor(),
 463         page_scale_layer,
 464         MaxTextureSize(),
 465         settings().can_use_lcd_text,
 466         can_render_to_separate_surface,
 467         settings().layer_transforms_should_scale_layer_contents,
 468         &render_surface_layer_list_);
 469     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 470   }
 471
 472   {
 473     TRACE_EVENT2("cc",
 474                  "LayerTreeImpl::UpdateTilePriorities",
 475                  "IsActive",
 476                  IsActiveTree(),
 477                  "SourceFrameNumber",
 478                  source_frame_number_);
 479     // LayerIterator is used here instead of CallFunctionForSubtree to only
 480     // UpdateTilePriorities on layers that will be visible (and thus have valid
 481     // draw properties) and not because any ordering is required.
 482     typedef LayerIterator<LayerImpl> LayerIteratorType;
 483     LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list_);
 484     for (LayerIteratorType it =
 485              LayerIteratorType::Begin(&render_surface_layer_list_);
 486          it != end;
 487          ++it) {
 488       if (!it.represents_itself())
 489         continue;
 490       LayerImpl* layer = *it;
 491
 492       layer->UpdateTilePriorities();
 493       if (layer->mask_layer())
 494         layer->mask_layer()->UpdateTilePriorities();
 495       if (layer->replica_layer() && layer->replica_layer()->mask_layer())
 496         layer->replica_layer()->mask_layer()->UpdateTilePriorities();
 497     }
 498   }
 499
 500   DCHECK(!needs_update_draw_properties_) <<
 501       "CalcDrawProperties should not set_needs_update_draw_properties()";
 502 }
 503
 504 const LayerImplList& LayerTreeImpl::RenderSurfaceLayerList() const {
 505   // If this assert triggers, then the list is dirty.
 506   DCHECK(!needs_update_draw_properties_);
 507   return render_surface_layer_list_;
 508 }
 509
 510 gfx::Size LayerTreeImpl::ScrollableSize() const {
 511   LayerImpl* root_scroll_layer = OuterViewportScrollLayer()
 512                                      ? OuterViewportScrollLayer()
 513                                      : InnerViewportScrollLayer();
 514   if (!root_scroll_layer || root_scroll_layer->children().empty())
 515     return gfx::Size();
 516   return root_scroll_layer->children()[0]->bounds();
 517 }
 518
 519 LayerImpl* LayerTreeImpl::LayerById(int id) {
 520   LayerIdMap::iterator iter = layer_id_map_.find(id);
 521   return iter != layer_id_map_.end() ? iter->second : NULL;
 522 }
 523
 524 void LayerTreeImpl::RegisterLayer(LayerImpl* layer) {
 525   DCHECK(!LayerById(layer->id()));
 526   layer_id_map_[layer->id()] = layer;
 527 }
 528
 529 void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) {
 530   DCHECK(LayerById(layer->id()));
 531   layer_id_map_.erase(layer->id());
 532 }
 533
 534 void LayerTreeImpl::PushPersistedState(LayerTreeImpl* pending_tree) {
 535   pending_tree->SetCurrentlyScrollingLayer(
 536       LayerTreeHostCommon::FindLayerInSubtree(pending_tree->root_layer(),
 537           currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0));
 538 }
 539
 540 static void DidBecomeActiveRecursive(LayerImpl* layer) {
 541   layer->DidBecomeActive();
 542   for (size_t i = 0; i < layer->children().size(); ++i)
 543     DidBecomeActiveRecursive(layer->children()[i]);
 544 }
 545
 546 void LayerTreeImpl::DidBecomeActive() {
 547   if (!root_layer())
 548     return;
 549
 550   if (scrolling_layer_id_from_previous_tree_) {
 551     currently_scrolling_layer_ = LayerTreeHostCommon::FindLayerInSubtree(
 552         root_layer_.get(), scrolling_layer_id_from_previous_tree_);
 553   }
 554
 555   DidBecomeActiveRecursive(root_layer());
 556 }
 557
 558 bool LayerTreeImpl::ContentsTexturesPurged() const {
 559   return contents_textures_purged_;
 560 }
 561
 562 void LayerTreeImpl::SetContentsTexturesPurged() {
 563   if (contents_textures_purged_)
 564     return;
 565   contents_textures_purged_ = true;
 566   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 567 }
 568
 569 void LayerTreeImpl::ResetContentsTexturesPurged() {
 570   if (!contents_textures_purged_)
 571     return;
 572   contents_textures_purged_ = false;
 573   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 574 }
 575
 576 void LayerTreeImpl::SetRequiresHighResToDraw() {
 577   requires_high_res_to_draw_ = true;
 578 }
 579
 580 void LayerTreeImpl::ResetRequiresHighResToDraw() {
 581   requires_high_res_to_draw_ = false;
 582 }
 583
 584 bool LayerTreeImpl::RequiresHighResToDraw() const {
 585   return requires_high_res_to_draw_;
 586 }
 587
 588 bool LayerTreeImpl::ViewportSizeInvalid() const {
 589   return viewport_size_invalid_;
 590 }
 591
 592 void LayerTreeImpl::SetViewportSizeInvalid() {
 593   viewport_size_invalid_ = true;
 594   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 595 }
 596
 597 void LayerTreeImpl::ResetViewportSizeInvalid() {
 598   viewport_size_invalid_ = false;
 599   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 600 }
 601
 602 Proxy* LayerTreeImpl::proxy() const {
 603   return layer_tree_host_impl_->proxy();
 604 }
 605
 606 const LayerTreeSettings& LayerTreeImpl::settings() const {
 607   return layer_tree_host_impl_->settings();
 608 }
 609
 610 const RendererCapabilitiesImpl& LayerTreeImpl::GetRendererCapabilities() const {
 611   return layer_tree_host_impl_->GetRendererCapabilities();
 612 }
 613
 614 ContextProvider* LayerTreeImpl::context_provider() const {
 615   return output_surface()->context_provider();
 616 }
 617
 618 OutputSurface* LayerTreeImpl::output_surface() const {
 619   return layer_tree_host_impl_->output_surface();
 620 }
 621
 622 ResourceProvider* LayerTreeImpl::resource_provider() const {
 623   return layer_tree_host_impl_->resource_provider();
 624 }
 625
 626 TileManager* LayerTreeImpl::tile_manager() const {
 627   return layer_tree_host_impl_->tile_manager();
 628 }
 629
 630 FrameRateCounter* LayerTreeImpl::frame_rate_counter() const {
 631   return layer_tree_host_impl_->fps_counter();
 632 }
 633
 634 PaintTimeCounter* LayerTreeImpl::paint_time_counter() const {
 635   return layer_tree_host_impl_->paint_time_counter();
 636 }
 637
 638 MemoryHistory* LayerTreeImpl::memory_history() const {
 639   return layer_tree_host_impl_->memory_history();
 640 }
 641
 642 bool LayerTreeImpl::device_viewport_valid_for_tile_management() const {
 643   return layer_tree_host_impl_->device_viewport_valid_for_tile_management();
 644 }
 645
 646 bool LayerTreeImpl::IsActiveTree() const {
 647   return layer_tree_host_impl_->active_tree() == this;
 648 }
 649
 650 bool LayerTreeImpl::IsPendingTree() const {
 651   return layer_tree_host_impl_->pending_tree() == this;
 652 }
 653
 654 bool LayerTreeImpl::IsRecycleTree() const {
 655   return layer_tree_host_impl_->recycle_tree() == this;
 656 }
 657
 658 LayerImpl* LayerTreeImpl::FindActiveTreeLayerById(int id) {
 659   LayerTreeImpl* tree = layer_tree_host_impl_->active_tree();
 660   if (!tree)
 661     return NULL;
 662   return tree->LayerById(id);
 663 }
 664
 665 LayerImpl* LayerTreeImpl::FindPendingTreeLayerById(int id) {
 666   LayerTreeImpl* tree = layer_tree_host_impl_->pending_tree();
 667   if (!tree)
 668     return NULL;
 669   return tree->LayerById(id);
 670 }
 671
 672 int LayerTreeImpl::MaxTextureSize() const {
 673   return layer_tree_host_impl_->GetRendererCapabilities().max_texture_size;
 674 }
 675
 676 bool LayerTreeImpl::PinchGestureActive() const {
 677   return layer_tree_host_impl_->pinch_gesture_active();
 678 }
 679
 680 base::TimeTicks LayerTreeImpl::CurrentFrameTimeTicks() const {
 681   return layer_tree_host_impl_->CurrentFrameTimeTicks();
 682 }
 683
 684 base::Time LayerTreeImpl::CurrentFrameTime() const {
 685   return layer_tree_host_impl_->CurrentFrameTime();
 686 }
 687
 688 base::TimeTicks LayerTreeImpl::CurrentPhysicalTimeTicks() const {
 689   return layer_tree_host_impl_->CurrentPhysicalTimeTicks();
 690 }
 691
 692 void LayerTreeImpl::SetNeedsCommit() {
 693   layer_tree_host_impl_->SetNeedsCommit();
 694 }
 695
 696 gfx::Size LayerTreeImpl::DrawViewportSize() const {
 697   return layer_tree_host_impl_->DrawViewportSize();
 698 }
 699
 700 void LayerTreeImpl::StartScrollbarAnimation() {
 701   layer_tree_host_impl_->StartScrollbarAnimation();
 702 }
 703
 704 void LayerTreeImpl::DidAnimateScrollOffset() {
 705   layer_tree_host_impl_->DidAnimateScrollOffset();
 706 }
 707
 708 void LayerTreeImpl::SetNeedsRedraw() {
 709   layer_tree_host_impl_->SetNeedsRedraw();
 710 }
 711
 712 const LayerTreeDebugState& LayerTreeImpl::debug_state() const {
 713   return layer_tree_host_impl_->debug_state();
 714 }
 715
 716 float LayerTreeImpl::device_scale_factor() const {
 717   return layer_tree_host_impl_->device_scale_factor();
 718 }
 719
 720 DebugRectHistory* LayerTreeImpl::debug_rect_history() const {
 721   return layer_tree_host_impl_->debug_rect_history();
 722 }
 723
 724 AnimationRegistrar* LayerTreeImpl::animationRegistrar() const {
 725   return layer_tree_host_impl_->animation_registrar();
 726 }
 727
 728 scoped_ptr<base::Value> LayerTreeImpl::AsValue() const {
 729   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
 730   TracedValue::MakeDictIntoImplicitSnapshot(
 731       state.get(), "cc::LayerTreeImpl", this);
 732
 733   state->Set("root_layer", root_layer_->AsValue().release());
 734
 735   scoped_ptr<base::ListValue> render_surface_layer_list(new base::ListValue());
 736   typedef LayerIterator<LayerImpl> LayerIteratorType;
 737   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list_);
 738   for (LayerIteratorType it = LayerIteratorType::Begin(
 739            &render_surface_layer_list_); it != end; ++it) {
 740     if (!it.represents_itself())
 741       continue;
 742     render_surface_layer_list->Append(TracedValue::CreateIDRef(*it).release());
 743   }
 744
 745   state->Set("render_surface_layer_list",
 746              render_surface_layer_list.release());
 747   return state.PassAs<base::Value>();
 748 }
 749
 750 void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
 751     LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
 752   if (root_layer_scroll_offset_delegate_ == root_layer_scroll_offset_delegate)
 753     return;
 754
 755   if (!root_layer_scroll_offset_delegate) {
 756     // Make sure we remove the proxies from their layers before
 757     // releasing them.
 758     if (InnerViewportScrollLayer())
 759       InnerViewportScrollLayer()->SetScrollOffsetDelegate(NULL);
 760     if (OuterViewportScrollLayer())
 761       OuterViewportScrollLayer()->SetScrollOffsetDelegate(NULL);
 762     inner_viewport_scroll_delegate_proxy_.reset();
 763     outer_viewport_scroll_delegate_proxy_.reset();
 764   }
 765
 766   root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
 767
 768   if (root_layer_scroll_offset_delegate_) {
 769     root_layer_scroll_offset_delegate_->SetTotalScrollOffset(
 770         TotalScrollOffset());
 771     root_layer_scroll_offset_delegate_->SetMaxScrollOffset(
 772         TotalMaxScrollOffset());
 773     root_layer_scroll_offset_delegate_->SetScrollableSize(ScrollableSize());
 774     root_layer_scroll_offset_delegate_->SetTotalPageScaleFactorAndLimits(
 775         total_page_scale_factor(),
 776         min_page_scale_factor(),
 777         max_page_scale_factor());
 778
 779     if (inner_viewport_scroll_layer_) {
 780       inner_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
 781           new LayerScrollOffsetDelegateProxy(InnerViewportScrollLayer(),
 782                                              root_layer_scroll_offset_delegate_,
 783                                              this));
 784       inner_viewport_scroll_layer_->SetScrollOffsetDelegate(
 785           inner_viewport_scroll_delegate_proxy_.get());
 786     }
 787
 788     if (outer_viewport_scroll_layer_) {
 789       outer_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
 790           new LayerScrollOffsetDelegateProxy(OuterViewportScrollLayer(),
 791                                              root_layer_scroll_offset_delegate_,
 792                                              this));
 793       outer_viewport_scroll_layer_->SetScrollOffsetDelegate(
 794           outer_viewport_scroll_delegate_proxy_.get());
 795     }
 796   }
 797 }
 798
 799 void LayerTreeImpl::UpdateScrollOffsetDelegate() {
 800   DCHECK(InnerViewportScrollLayer());
 801   DCHECK(root_layer_scroll_offset_delegate_);
 802
 803   gfx::Vector2dF offset =
 804       inner_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
 805
 806   if (OuterViewportScrollLayer())
 807     offset += outer_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
 808
 809   root_layer_scroll_offset_delegate_->SetTotalScrollOffset(offset);
 810   root_layer_scroll_offset_delegate_->SetMaxScrollOffset(
 811       TotalMaxScrollOffset());
 812 }
 813
 814 gfx::Vector2dF LayerTreeImpl::GetDelegatedScrollOffset(LayerImpl* layer) {
 815   DCHECK(root_layer_scroll_offset_delegate_);
 816   DCHECK(InnerViewportScrollLayer());
 817   if (layer == InnerViewportScrollLayer() && !OuterViewportScrollLayer())
 818     return root_layer_scroll_offset_delegate_->GetTotalScrollOffset();
 819
 820   // If we get here, we have both inner/outer viewports, and need to distribute
 821   // the scroll offset between them.
 822   DCHECK(inner_viewport_scroll_delegate_proxy_);
 823   DCHECK(outer_viewport_scroll_delegate_proxy_);
 824   gfx::Vector2dF inner_viewport_offset =
 825       inner_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
 826   gfx::Vector2dF outer_viewport_offset =
 827       outer_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
 828
 829   // It may be nothing has changed.
 830   gfx::Vector2dF delegate_offset =
 831       root_layer_scroll_offset_delegate_->GetTotalScrollOffset();
 832   if (inner_viewport_offset + outer_viewport_offset == delegate_offset) {
 833     if (layer == InnerViewportScrollLayer())
 834       return inner_viewport_offset;
 835     else
 836       return outer_viewport_offset;
 837   }
 838
 839   gfx::Vector2d max_outer_viewport_scroll_offset =
 840       OuterViewportScrollLayer()->MaxScrollOffset();
 841
 842   outer_viewport_offset = delegate_offset - inner_viewport_offset;
 843   outer_viewport_offset.SetToMin(max_outer_viewport_scroll_offset);
 844   outer_viewport_offset.SetToMax(gfx::Vector2d());
 845
 846   if (layer == OuterViewportScrollLayer())
 847     return outer_viewport_offset;
 848
 849   inner_viewport_offset = delegate_offset - outer_viewport_offset;
 850
 851   return inner_viewport_offset;
 852 }
 853
 854 void LayerTreeImpl::QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise) {
 855   DCHECK(swap_promise);
 856   if (swap_promise_list_.size() > kMaxQueuedSwapPromiseNumber)
 857     BreakSwapPromises(SwapPromise::SWAP_PROMISE_LIST_OVERFLOW);
 858   swap_promise_list_.push_back(swap_promise.Pass());
 859 }
 860
 861 void LayerTreeImpl::PassSwapPromises(
 862     ScopedPtrVector<SwapPromise>* new_swap_promise) {
 863   swap_promise_list_.insert_and_take(swap_promise_list_.end(),
 864                                      *new_swap_promise);
 865   new_swap_promise->clear();
 866 }
 867
 868 void LayerTreeImpl::FinishSwapPromises(CompositorFrameMetadata* metadata) {
 869   for (size_t i = 0; i < swap_promise_list_.size(); i++)
 870     swap_promise_list_[i]->DidSwap(metadata);
 871   swap_promise_list_.clear();
 872 }
 873
 874 void LayerTreeImpl::BreakSwapPromises(SwapPromise::DidNotSwapReason reason) {
 875   for (size_t i = 0; i < swap_promise_list_.size(); i++)
 876     swap_promise_list_[i]->DidNotSwap(reason);
 877   swap_promise_list_.clear();
 878 }
 879
 880 void LayerTreeImpl::DidModifyTilePriorities() {
 881   layer_tree_host_impl_->DidModifyTilePriorities();
 882 }
 883
 884 void LayerTreeImpl::set_ui_resource_request_queue(
 885     const UIResourceRequestQueue& queue) {
 886   ui_resource_request_queue_ = queue;
 887 }
 888
 889 ResourceProvider::ResourceId LayerTreeImpl::ResourceIdForUIResource(
 890     UIResourceId uid) const {
 891   return layer_tree_host_impl_->ResourceIdForUIResource(uid);
 892 }
 893
 894 bool LayerTreeImpl::IsUIResourceOpaque(UIResourceId uid) const {
 895   return layer_tree_host_impl_->IsUIResourceOpaque(uid);
 896 }
 897
 898 void LayerTreeImpl::ProcessUIResourceRequestQueue() {
 899   while (ui_resource_request_queue_.size() > 0) {
 900     UIResourceRequest req = ui_resource_request_queue_.front();
 901     ui_resource_request_queue_.pop_front();
 902
 903     switch (req.GetType()) {
 904       case UIResourceRequest::UIResourceCreate:
 905         layer_tree_host_impl_->CreateUIResource(req.GetId(), req.GetBitmap());
 906         break;
 907       case UIResourceRequest::UIResourceDelete:
 908         layer_tree_host_impl_->DeleteUIResource(req.GetId());
 909         break;
 910       case UIResourceRequest::UIResourceInvalidRequest:
 911         NOTREACHED();
 912         break;
 913     }
 914   }
 915
 916   // If all UI resource evictions were not recreated by processing this queue,
 917   // then another commit is required.
 918   if (layer_tree_host_impl_->EvictedUIResourcesExist())
 919     layer_tree_host_impl_->SetNeedsCommit();
 920 }
 921
 922 void LayerTreeImpl::AddLayerWithCopyOutputRequest(LayerImpl* layer) {
 923   // Only the active tree needs to know about layers with copy requests, as
 924   // they are aborted if not serviced during draw.
 925   DCHECK(IsActiveTree());
 926
 927   // DCHECK(std::find(layers_with_copy_output_request_.begin(),
 928   //                 layers_with_copy_output_request_.end(),
 929   //                 layer) == layers_with_copy_output_request_.end());
 930   // TODO(danakj): Remove this once crash is found crbug.com/309777
 931   for (size_t i = 0; i < layers_with_copy_output_request_.size(); ++i) {
 932     CHECK(layers_with_copy_output_request_[i] != layer)
 933         << i << " of " << layers_with_copy_output_request_.size();
 934   }
 935   layers_with_copy_output_request_.push_back(layer);
 936 }
 937
 938 void LayerTreeImpl::RemoveLayerWithCopyOutputRequest(LayerImpl* layer) {
 939   // Only the active tree needs to know about layers with copy requests, as
 940   // they are aborted if not serviced during draw.
 941   DCHECK(IsActiveTree());
 942
 943   std::vector<LayerImpl*>::iterator it = std::find(
 944       layers_with_copy_output_request_.begin(),
 945       layers_with_copy_output_request_.end(),
 946       layer);
 947   DCHECK(it != layers_with_copy_output_request_.end());
 948   layers_with_copy_output_request_.erase(it);
 949
 950   // TODO(danakj): Remove this once crash is found crbug.com/309777
 951   for (size_t i = 0; i < layers_with_copy_output_request_.size(); ++i) {
 952     CHECK(layers_with_copy_output_request_[i] != layer)
 953         << i << " of " << layers_with_copy_output_request_.size();
 954   }
 955 }
 956
 957 const std::vector<LayerImpl*>& LayerTreeImpl::LayersWithCopyOutputRequest()
 958     const {
 959   // Only the active tree needs to know about layers with copy requests, as
 960   // they are aborted if not serviced during draw.
 961   DCHECK(IsActiveTree());
 962
 963   return layers_with_copy_output_request_;
 964 }
 965
 966 }  // namespace cc