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

cc/layers/tiled_layer_impl.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_impl.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/strings/stringprintf.h"
 #include "cc/base/math_util.h"
@@ skipping 124 matching lines @@
   for (LayerTilingData::TileMap::const_iterator iter = tiler_->tiles().begin();
        iter != tiler_->tiles().end();
        ++iter) {
     int i = iter->first.first;
     int j = iter->first.second;
     DrawableTile* tile = static_cast<DrawableTile*>(iter->second);
     DCHECK(tile);
     tiled_layer->PushTileProperties(i,
                                     j,
                                     tile->resource_id(),
-                                    tile->opaque_rect(),
                                     tile->contents_swizzled());
   }
 }
 
 bool TiledLayerImpl::WillDraw(DrawMode draw_mode,
                               ResourceProvider* resource_provider) {
   if (!tiler_ || tiler_->has_empty_bounds() ||
       visible_content_rect().IsEmpty() ||
       draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
     return false;
@@ skipping 76 matching lines @@
         }
 
         CheckerboardDrawQuad* checkerboard_quad =
             render_pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
         checkerboard_quad->SetNew(
             shared_quad_state, tile_rect, visible_tile_rect, checker_color);
         append_quads_data->num_missing_tiles++;
         continue;
       }
 
-      gfx::Rect tile_opaque_rect =
-          contents_opaque() ? tile_rect : gfx::IntersectRects(
-                                              tile->opaque_rect(), tile_rect);
+      gfx::Rect tile_opaque_rect = contents_opaque() ? tile_rect : gfx::Rect();
 
       // Keep track of how the top left has moved, so the texture can be
       // offset the same amount.
       gfx::Vector2d display_offset = tile_rect.origin() - display_rect.origin();
       gfx::Vector2d texture_offset =
           tiler_->texture_offset(i, j) + display_offset;
       gfx::RectF tex_coord_rect = gfx::RectF(tile_rect.size()) + texture_offset;
 
       float tile_width = static_cast<float>(tiler_->tile_size().width());
       float tile_height = static_cast<float>(tiler_->tile_size().height());
@@ skipping 21 matching lines @@
                                          ? LayerTilingData::HAS_BORDER_TEXELS
                                          : LayerTilingData::NO_BORDER_TEXELS);
   }
   *tiler_ = tiler;
 }
 
 void TiledLayerImpl::PushTileProperties(
     int i,
     int j,
     ResourceProvider::ResourceId resource_id,
-    const gfx::Rect& opaque_rect,
     bool contents_swizzled) {
   DrawableTile* tile = TileAt(i, j);
   if (!tile)
     tile = CreateTile(i, j);
   tile->set_resource_id(resource_id);
-  tile->set_opaque_rect(opaque_rect);
   tile->set_contents_swizzled(contents_swizzled);
 }
 
 void TiledLayerImpl::PushInvalidTile(int i, int j) {
   DrawableTile* tile = TileAt(i, j);
   if (!tile)
     tile = CreateTile(i, j);
   tile->set_resource_id(0);
-  tile->set_opaque_rect(gfx::Rect());
   tile->set_contents_swizzled(false);
 }
 
 SimpleEnclosedRegion TiledLayerImpl::VisibleContentOpaqueRegion() const {
   if (skips_draw_)
     return SimpleEnclosedRegion();
-  if (contents_opaque())
-    return SimpleEnclosedRegion(visible_content_rect());
-  return tiler_->OpaqueRegionInContentRect(visible_content_rect());
+  return LayerImpl::VisibleContentOpaqueRegion();
 }
 
 void TiledLayerImpl::ReleaseResources() {
   tiler_->reset();
 }
 
 const char* TiledLayerImpl::LayerTypeAsString() const {
   return "cc::TiledLayerImpl";
 }
 
 }  // namespace cc