cc: Always keep the PictureLayerImpl::twin_layer_ pointer valid.

cc/layers/picture_layer_impl.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 72 matching lines @@
       low_res_raster_contents_scale_(0.f),
       raster_source_scale_is_fixed_(false),
       was_screen_space_transform_animating_(false),
       needs_post_commit_initialization_(true),
       should_update_tile_priorities_(false),
       only_used_low_res_last_append_quads_(false) {
   layer_tree_impl()->RegisterPictureLayerImpl(this);
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
+  if (twin_layer_)
+    twin_layer_->twin_layer_ = nullptr;
   layer_tree_impl()->UnregisterPictureLayerImpl(this);
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
   return "cc::PictureLayerImpl";
 }
 
 scoped_ptr<LayerImpl> PictureLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return PictureLayerImpl::Create(tree_impl, id());
 }
 
 void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
   // It's possible this layer was never drawn or updated (e.g. because it was
   // a descendant of an opacity 0 layer).
   DoPostCommitInitializationIfNeeded();
   PictureLayerImpl* layer_impl = static_cast<PictureLayerImpl*>(base_layer);
 
   LayerImpl::PushPropertiesTo(base_layer);
 
-  // When the pending tree pushes to the active tree, the pending twin
-  // becomes recycled.
-  layer_impl->twin_layer_ = nullptr;
-  twin_layer_ = nullptr;
+  // Twin relationships should never change once established.
+  DCHECK_IMPLIES(twin_layer_, twin_layer_ == layer_impl);
+  DCHECK_IMPLIES(twin_layer_, layer_impl->twin_layer_ == this);
+  // The twin relationship does not need to exist before the first
+  // PushPropertiesTo from pending to active layer since before that the active
+  // layer can not have a pile or tilings, it has only been created and inserted
+  // into the tree at that point.
+  twin_layer_ = layer_impl;
+  layer_impl->twin_layer_ = this;
 
   layer_impl->pile_ = pile_;
 
   DCHECK(!pile_->is_solid_color() || !tilings_->num_tilings());
   // Tilings would be expensive to push, so we swap.
   layer_impl->tilings_.swap(tilings_);
   layer_impl->tilings_->SetClient(layer_impl);
   if (tilings_)
     tilings_->SetClient(this);
 
@@ skipping 432 matching lines @@
     if (screen_space_transform().GetInverse(&view_to_layer)) {
       // Transform from view space to content space.
       visible_rect_in_content_space =
           gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
               view_to_layer, viewport_rect_for_tile_priority));
     }
   }
   return visible_rect_in_content_space;
 }
 
-PictureLayerImpl* PictureLayerImpl::GetRecycledTwinLayer() {
-  // TODO(vmpstr): Maintain recycled twin as a member. crbug.com/407418
-  return static_cast<PictureLayerImpl*>(
-      layer_tree_impl()->FindRecycleTreeLayerById(id()));
+PictureLayerImpl* PictureLayerImpl::GetPendingOrActiveTwinLayer() const {
+  if (!twin_layer_ || !twin_layer_->IsOnActiveOrPendingTree())
+    return nullptr;
+  return twin_layer_;
+}
+
+PictureLayerImpl* PictureLayerImpl::GetRecycledTwinLayer() const {
+  if (!twin_layer_ || twin_layer_->IsOnActiveOrPendingTree())
+    return nullptr;
+  return twin_layer_;
 }
 
 void PictureLayerImpl::NotifyTileStateChanged(const Tile* tile) {
   if (layer_tree_impl()->IsActiveTree()) {
     gfx::RectF layer_damage_rect =
         gfx::ScaleRect(tile->content_rect(), 1.f / tile->contents_scale());
     AddDamageRect(layer_damage_rect);
   }
 }
 
@@ skipping 51 matching lines @@
 }
 
 PicturePileImpl* PictureLayerImpl::GetPile() {
   return pile_.get();
 }
 
 const Region* PictureLayerImpl::GetPendingInvalidation() {
   if (layer_tree_impl()->IsPendingTree())
     return &invalidation_;
   DCHECK(layer_tree_impl()->IsActiveTree());
-  if (PictureLayerImpl* twin_layer = GetTwinLayer())
+  if (PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer())
     return &twin_layer->invalidation_;
   return nullptr;
 }
 
-const PictureLayerTiling* PictureLayerImpl::GetTwinTiling(
+const PictureLayerTiling* PictureLayerImpl::GetPendingOrActiveTwinTiling(
     const PictureLayerTiling* tiling) const {
-  if (!twin_layer_)
+  PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer();
+  if (!twin_layer)
     return nullptr;
-  return twin_layer_->tilings_->TilingAtScale(tiling->contents_scale());
+  // TODO(danakj): Remove this when no longer swapping tilings.
+  if (!twin_layer->tilings_)
+    return nullptr;
+  return twin_layer->tilings_->TilingAtScale(tiling->contents_scale());
 }
 
 PictureLayerTiling* PictureLayerImpl::GetRecycledTwinTiling(
     const PictureLayerTiling* tiling) {
   PictureLayerImpl* recycled_twin = GetRecycledTwinLayer();
   if (!recycled_twin || !recycled_twin->tilings_)
     return nullptr;
   return recycled_twin->tilings_->TilingAtScale(tiling->contents_scale());
 }
 
@@ skipping 132 matching lines @@
   // should refactor this code a little bit and actually recalculate this.
   // However, this is a larger undertaking, so this will work for now.
   if (!synced_high_res_tiling)
     ResetRasterScale();
   else
     SanityCheckTilingState();
 }
 
 void PictureLayerImpl::SyncTiling(
     const PictureLayerTiling* tiling) {
+  if (!tilings_)
+    return;
   if (!CanHaveTilingWithScale(tiling->contents_scale()))
     return;
   tilings_->AddTiling(tiling->contents_scale(), pile_->tiling_size());
 
   // If this tree needs update draw properties, then the tiling will
   // get updated prior to drawing or activation.  If this tree does not
   // need update draw properties, then its transforms are up to date and
   // we can create tiles for this tiling immediately.
   if (!layer_tree_impl()->needs_update_draw_properties() &&
       should_update_tile_priorities_) {
@@ skipping 35 matching lines @@
   *resource_size = iter.texture_size();
 }
 
 void PictureLayerImpl::DoPostCommitInitialization() {
   DCHECK(needs_post_commit_initialization_);
   DCHECK(layer_tree_impl()->IsPendingTree());
 
   if (!tilings_)
     tilings_ = make_scoped_ptr(new PictureLayerTilingSet(this));
 
-  DCHECK(!twin_layer_);
-  twin_layer_ = static_cast<PictureLayerImpl*>(
-      layer_tree_impl()->FindActiveTreeLayerById(id()));
-  if (twin_layer_) {
-    DCHECK(!twin_layer_->twin_layer_);
-    twin_layer_->twin_layer_ = this;
+  PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer();
+  if (twin_layer) {
     // If the twin has never been pushed to, do not sync from it.
     // This can happen if this function is called during activation.
-    if (!twin_layer_->needs_post_commit_initialization_)
-      SyncFromActiveLayer(twin_layer_);
+    if (!twin_layer->needs_post_commit_initialization_)
+      SyncFromActiveLayer(twin_layer);
   }
 
   needs_post_commit_initialization_ = false;
 }
 
 PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   DCHECK(CanHaveTilingWithScale(contents_scale)) <<
       "contents_scale: " << contents_scale;
 
   PictureLayerTiling* tiling =
       tilings_->AddTiling(contents_scale, pile_->tiling_size());
 
   DCHECK(pile_->HasRecordings());
 
-  if (twin_layer_)
-    twin_layer_->SyncTiling(tiling);
+  if (PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer())
+    twin_layer->SyncTiling(tiling);
 
   return tiling;
 }
 
 void PictureLayerImpl::RemoveTiling(float contents_scale) {
   if (!tilings_ || tilings_->num_tilings() == 0)
     return;
 
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
@@ skipping 223 matching lines @@
   DCHECK(layer_tree_impl()->IsActiveTree());
   if (tilings_->num_tilings() == 0)
     return;
 
   float min_acceptable_high_res_scale = std::min(
       raster_contents_scale_, ideal_contents_scale_);
   float max_acceptable_high_res_scale = std::max(
       raster_contents_scale_, ideal_contents_scale_);
   float twin_low_res_scale = 0.f;
 
-  PictureLayerImpl* twin = twin_layer_;
+  PictureLayerImpl* twin = GetPendingOrActiveTwinLayer();
   if (twin && twin->CanHaveTilings()) {
     min_acceptable_high_res_scale = std::min(
         min_acceptable_high_res_scale,
         std::min(twin->raster_contents_scale_, twin->ideal_contents_scale_));
     max_acceptable_high_res_scale = std::max(
         max_acceptable_high_res_scale,
         std::max(twin->raster_contents_scale_, twin->ideal_contents_scale_));
 
-    for (size_t i = 0; i < twin->tilings_->num_tilings(); ++i) {
-      PictureLayerTiling* tiling = twin->tilings_->tiling_at(i);
-      if (tiling->resolution() == LOW_RESOLUTION)
-        twin_low_res_scale = tiling->contents_scale();
+    // TODO(danakj): Remove the tilings_ check when we create them in the
+    // constructor.
+    if (twin->tilings_) {
+      for (size_t i = 0; i < twin->tilings_->num_tilings(); ++i) {
+        PictureLayerTiling* tiling = twin->tilings_->tiling_at(i);
+        if (tiling->resolution() == LOW_RESOLUTION)
+          twin_low_res_scale = tiling->contents_scale();
+      }
     }
   }
 
   std::vector<PictureLayerTiling*> to_remove;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
 
     // Keep multiple high resolution tilings even if not used to help
     // activate earlier at non-ideal resolutions.
     if (tiling->contents_scale() >= min_acceptable_high_res_scale &&
@@ skipping 14 matching lines @@
 
     to_remove.push_back(tiling);
   }
 
   if (to_remove.empty())
     return;
 
   PictureLayerImpl* recycled_twin = GetRecycledTwinLayer();
   // Remove tilings on this tree and the twin tree.
   for (size_t i = 0; i < to_remove.size(); ++i) {
-    const PictureLayerTiling* twin_tiling = GetTwinTiling(to_remove[i]);
+    const PictureLayerTiling* twin_tiling =
+        GetPendingOrActiveTwinTiling(to_remove[i]);
     // Only remove tilings from the twin layer if they have
     // NON_IDEAL_RESOLUTION.
     if (twin_tiling && twin_tiling->resolution() == NON_IDEAL_RESOLUTION)
       twin->RemoveTiling(to_remove[i]->contents_scale());
     // Remove the tiling from the recycle tree. Note that we ignore resolution,
     // since we don't need to maintain high/low res on the recycle tree.
     if (recycled_twin)
       recycled_twin->RemoveTiling(to_remove[i]->contents_scale());
     // TODO(enne): temporary sanity CHECK for http://crbug.com/358350
     CHECK_NE(HIGH_RESOLUTION, to_remove[i]->resolution());
@@ skipping 504 matching lines @@
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace cc