Revert two cc patches due to crashes on canary.

cc/resources/picture_layer_tiling.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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 108 matching lines @@
   gfx::Rect tile_rect = paint_rect;
   tile_rect.set_size(tiling_data_.max_texture_size());
 
   // Check our twin for a valid tile.
   if (twin_tiling &&
       tiling_data_.max_texture_size() ==
       twin_tiling->tiling_data_.max_texture_size()) {
     if (Tile* candidate_tile = twin_tiling->TileAt(i, j)) {
       gfx::Rect rect =
           gfx::ScaleToEnclosingRect(paint_rect, 1.0f / contents_scale_);
-      const Region* invalidation = client_->GetPendingInvalidation();
-      if (!invalidation || !invalidation->Intersects(rect)) {
+      if (!client_->GetInvalidation()->Intersects(rect)) {
         DCHECK(!candidate_tile->is_shared());
         DCHECK_EQ(i, candidate_tile->tiling_i_index());
         DCHECK_EQ(j, candidate_tile->tiling_j_index());
         candidate_tile->set_shared(true);
         tiles_[key] = candidate_tile;
         return candidate_tile;
       }
     }
   }
 
   // Create a new tile because our twin didn't have a valid one.
   scoped_refptr<Tile> tile = client_->CreateTile(this, tile_rect);
   if (tile.get()) {
     DCHECK(!tile->is_shared());
     tile->set_tiling_index(i, j);
     tiles_[key] = tile;
   }
   return tile.get();
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
-  const PictureLayerTiling* twin_tiling =
-      client_->GetPendingOrActiveTwinTiling(this);
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
   bool include_borders = false;
   for (TilingData::Iterator iter(
            &tiling_data_, live_tiles_rect_, include_borders);
        iter;
        ++iter) {
     TileMapKey key = iter.index();
     TileMap::iterator find = tiles_.find(key);
     if (find != tiles_.end())
       continue;
     CreateTile(key.first, key.second, twin_tiling);
@@ skipping 56 matching lines @@
       for (int j = before_top; j <= before_bottom; ++j)
         RemoveTileAt(i, j, recycled_twin);
     }
     for (int i = before_left; i <= after_right; ++i) {
       for (int j = after_bottom + 1; j <= before_bottom; ++j)
         RemoveTileAt(i, j, recycled_twin);
     }
 
     // If the layer grew, the live_tiles_rect_ is not changed, but a new row
     // and/or column of tiles may now exist inside the same live_tiles_rect_.
-    const PictureLayerTiling* twin_tiling =
-        client_->GetPendingOrActiveTwinTiling(this);
+    const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
     if (after_right > before_right) {
       DCHECK_EQ(after_right, before_right + 1);
       for (int j = before_top; j <= after_bottom; ++j)
         CreateTile(after_right, j, twin_tiling);
     }
     if (after_bottom > before_bottom) {
       DCHECK_EQ(after_bottom, before_bottom + 1);
       for (int i = before_left; i <= before_right; ++i)
         CreateTile(i, after_bottom, twin_tiling);
     }
@@ skipping 383 matching lines @@
   // Iterate to delete all tiles outside of our new live_tiles rect.
   PictureLayerTiling* recycled_twin = client_->GetRecycledTwinTiling(this);
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            live_tiles_rect_,
                                            new_live_tiles_rect);
        iter;
        ++iter) {
     RemoveTileAt(iter.index_x(), iter.index_y(), recycled_twin);
   }
 
-  const PictureLayerTiling* twin_tiling =
-      client_->GetPendingOrActiveTwinTiling(this);
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
 
   // Iterate to allocate new tiles for all regions with newly exposed area.
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            new_live_tiles_rect,
                                            live_tiles_rect_);
        iter;
        ++iter) {
     TileMapKey key(iter.index());
     CreateTile(key.first, key.second, twin_tiling);
   }
@@ skipping 67 matching lines @@
 
   if (resolution_ != HIGH_RESOLUTION)
     return false;
 
   if (IsTileOccluded(tile))
     return false;
 
   if (client_->RequiresHighResToDraw())
     return true;
 
-  const PictureLayerTiling* twin_tiling =
-      client_->GetPendingOrActiveTwinTiling(this);
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
   if (!twin_tiling)
     return true;
 
   if (twin_tiling->layer_bounds() != layer_bounds())
     return true;
 
   if (twin_tiling->current_visible_rect_ != current_visible_rect_)
     return true;
 
   Tile* twin_tile =
       twin_tiling->TileAt(tile->tiling_i_index(), tile->tiling_j_index());
   // If twin tile is missing, it might not have a recording, so we don't need
   // this tile to be required for activation.
   if (!twin_tile)
     return false;
 
   return true;
 }
 
 void PictureLayerTiling::UpdateTileAndTwinPriority(Tile* tile) const {
   UpdateTilePriority(tile);
 
-  const PictureLayerTiling* twin_tiling =
-      client_->GetPendingOrActiveTwinTiling(this);
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
   if (!tile->is_shared() || !twin_tiling) {
     WhichTree tree = client_->GetTree();
     WhichTree twin_tree = tree == ACTIVE_TREE ? PENDING_TREE : ACTIVE_TREE;
     tile->SetPriority(twin_tree, TilePriority());
     tile->set_is_occluded(twin_tree, false);
     if (twin_tree == PENDING_TREE)
       tile->set_required_for_activation(false);
     return;
   }
 
@@ skipping 472 matching lines @@
   DCHECK(*this);
   do {
     ++current_eviction_tiles_index_;
   } while (current_eviction_tiles_index_ != eviction_tiles_->size() &&
            !(*eviction_tiles_)[current_eviction_tiles_index_]->HasResources());
 
   return *this;
 }
 
 }  // namespace cc