cc: Remove the opaque rect return-parameter from ContentLayerClient.

cc/layers/tiled_layer.cc

 // Copyright 2011 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/tiled_layer.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 203 matching lines @@
     if (!tile->valid_for_frame) {
       // Invalidated tiles are set so they can get different debug colors.
       tiled_layer->PushInvalidTile(i, j);
       continue;
     }
 
     tiled_layer->PushTileProperties(
         i,
         j,
         tile->managed_resource()->resource_id(),
-        tile->opaque_rect(),
         tile->managed_resource()->contents_swizzled());
   }
   for (std::vector<UpdatableTile*>::const_iterator iter = invalid_tiles.begin();
        iter != invalid_tiles.end();
        ++iter)
     tiler_->TakeTile((*iter)->i(), (*iter)->j());
 
   // TiledLayer must push properties every frame, since viewport state and
   // occlusion from anywhere in the tree can change what the layer decides to
   // push to the impl tree.
@@ skipping 235 matching lines @@
       paint_properties().bounds.height() /
       static_cast<float>(content_bounds().height());
   update_rect_ = gfx::ScaleRect(update_rect, width_scale, height_scale);
 
   // Calling PrepareToUpdate() calls into WebKit to paint, which may have the
   // side effect of disabling compositing, which causes our reference to the
   // texture updater to be deleted.  However, we can't free the memory backing
   // the SkCanvas until the paint finishes, so we grab a local reference here to
   // hold the updater alive until the paint completes.
   scoped_refptr<LayerUpdater> protector(Updater());
-  gfx::Rect painted_opaque_rect;
-  Updater()->PrepareToUpdate(paint_rect,
-                             tiler_->tile_size(),
-                             1.f / width_scale,
-                             1.f / height_scale,
-                             &painted_opaque_rect);
+  Updater()->PrepareToUpdate(
+      paint_rect, tiler_->tile_size(), 1.f / width_scale, 1.f / height_scale);
 
   for (int j = top; j <= bottom; ++j) {
     for (int i = left; i <= right; ++i) {
       UpdatableTile* tile = TileAt(i, j);
       DCHECK(tile);  // Did SetTexturePriorites get skipped?
                      // TODO(enne): This should not ever be null.
       if (!tile)
         continue;
 
       gfx::Rect tile_rect = tiler_->tile_bounds(i, j);
 
       // Use update_rect as the above loop copied the dirty rect for this frame
       // to update_rect.
       gfx::Rect dirty_rect = tile->update_rect;
       if (dirty_rect.IsEmpty())
         continue;
 
-      // Save what was painted opaque in the tile. Keep the old area if the
-      // paint didn't touch it, and didn't paint some other part of the tile
-      // opaque.
-      gfx::Rect tile_painted_rect = gfx::IntersectRects(tile_rect, paint_rect);
-      gfx::Rect tile_painted_opaque_rect =
-          gfx::IntersectRects(tile_rect, painted_opaque_rect);
-      if (!tile_painted_rect.IsEmpty()) {
-        gfx::Rect paint_inside_tile_opaque_rect =
-            gfx::IntersectRects(tile->opaque_rect(), tile_painted_rect);
-        bool paint_inside_tile_opaque_rect_is_non_opaque =
-            !paint_inside_tile_opaque_rect.IsEmpty() &&
-            !tile_painted_opaque_rect.Contains(paint_inside_tile_opaque_rect);
-        bool opaque_paint_not_inside_tile_opaque_rect =
-            !tile_painted_opaque_rect.IsEmpty() &&
-            !tile->opaque_rect().Contains(tile_painted_opaque_rect);
-
-        if (paint_inside_tile_opaque_rect_is_non_opaque ||
-            opaque_paint_not_inside_tile_opaque_rect)
-          tile->set_opaque_rect(tile_painted_opaque_rect);
-      }
-
       // source_rect starts as a full-sized tile with border texels included.
       gfx::Rect source_rect = tiler_->TileRect(tile);
       source_rect.Intersect(dirty_rect);
       // Paint rect not guaranteed to line up on tile boundaries, so
       // make sure that source_rect doesn't extend outside of it.
       source_rect.Intersect(paint_rect);
 
       tile->update_rect = source_rect;
 
       if (source_rect.IsEmpty())
@@ skipping 102 matching lines @@
                           tile_rect,
                           draws_to_root,
                           small_animated_layer,
                           tile->managed_resource());
   }
 }
 
 SimpleEnclosedRegion TiledLayer::VisibleContentOpaqueRegion() const {
   if (skips_draw_)
     return SimpleEnclosedRegion();
-  if (contents_opaque())
-    return SimpleEnclosedRegion(visible_content_rect());
-  return tiler_->OpaqueRegionInContentRect(visible_content_rect());
+  return Layer::VisibleContentOpaqueRegion();
 }
 
 void TiledLayer::ResetUpdateState() {
   skips_draw_ = false;
   failed_update_ = false;
 
   LayerTilingData::TileMap::const_iterator end = tiler_->tiles().end();
   for (LayerTilingData::TileMap::const_iterator iter = tiler_->tiles().begin();
        iter != end;
        ++iter) {
@@ skipping 233 matching lines @@
   gfx::Rect prepaint_rect = visible_content_rect();
   prepaint_rect.Inset(-tiler_->tile_size().width() * kPrepaintColumns,
                       -tiler_->tile_size().height() * kPrepaintRows);
   gfx::Rect content_rect(content_bounds());
   prepaint_rect.Intersect(content_rect);
 
   return prepaint_rect;
 }
 
 }  // namespace cc