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