cc: Remove OverdrawMetrics and --trace-overdraw flag.

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"
 #include "base/basictypes.h"
 #include "build/build_config.h"
-#include "cc/debug/overdraw_metrics.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/tiled_layer_impl.h"
 #include "cc/resources/layer_updater.h"
 #include "cc/resources/prioritized_resource.h"
 #include "cc/resources/priority_calculator.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/gfx/rect_conversions.h"
 
@@ skipping 311 matching lines @@
   if (!HaveTexturesForTiles(left, top, right, bottom, ignore_occlusions)) {
     failed_update_ = true;
     return false;
   }
 
   gfx::Rect update_rect;
   gfx::Rect paint_rect;
   MarkTilesForUpdate(
     &update_rect, &paint_rect, left, top, right, bottom, ignore_occlusions);
 
-  if (occlusion)
-    occlusion->overdraw_metrics()->DidPaint(paint_rect);
-
   if (paint_rect.IsEmpty())
     return true;
 
   *updated = true;
   UpdateTileTextures(
       update_rect, paint_rect, left, top, right, bottom, queue, occlusion);
   return true;
 }
 
 void TiledLayer::MarkOcclusionsAndRequestTextures(
     int left,
     int top,
     int right,
     int bottom,
     const OcclusionTracker<Layer>* occlusion) {
-  // There is some difficult dependancies between occlusions, recording
-  // occlusion metrics and requesting memory so those are encapsulated in this
-  // function: - We only want to call RequestLate on unoccluded textures (to
-  // preserve memory for other layers when near OOM).  - We only want to record
-  // occlusion metrics if all memory requests succeed.
-
   int occluded_tile_count = 0;
   bool succeeded = true;
   for (int j = top; j <= bottom; ++j) {
     for (int i = left; i <= right; ++i) {
       UpdatableTile* tile = TileAt(i, j);
       DCHECK(tile);  // Did SetTexturePriorities get skipped?
       // TODO(enne): This should not ever be null.
       if (!tile)
         continue;
       // Did ResetUpdateState get skipped? Are we doing more than one occlusion
       // pass?
       DCHECK(!tile->occluded);
       gfx::Rect visible_tile_rect = gfx::IntersectRects(
           tiler_->tile_bounds(i, j), visible_content_rect());
       if (!draw_transform_is_animating() && occlusion &&
           occlusion->Occluded(
               render_target(), visible_tile_rect, draw_transform())) {
         tile->occluded = true;
         occluded_tile_count++;
       } else {
         succeeded &= tile->managed_resource()->RequestLate();
       }
     }
   }
-
-  if (!succeeded)
-    return;
-  if (occlusion)
-    occlusion->overdraw_metrics()->DidCullTilesForUpload(occluded_tile_count);
 }
 
 bool TiledLayer::HaveTexturesForTiles(int left,
                                       int top,
                                       int right,
                                       int bottom,
                                       bool ignore_occlusions) {
   for (int j = top; j <= bottom; ++j) {
     for (int i = left; i <= right; ++i) {
       UpdatableTile* tile = TileAt(i, j);
@@ skipping 151 matching lines @@
 
       // Offset from paint rectangle to this tile's dirty rectangle.
       gfx::Vector2d paint_offset = source_rect.origin() - paint_rect.origin();
       CHECK_GE(paint_offset.x(), 0);
       CHECK_GE(paint_offset.y(), 0);
       CHECK_LE(paint_offset.x() + source_rect.width(), paint_rect.width());
       CHECK_LE(paint_offset.y() + source_rect.height(), paint_rect.height());
 
       tile->updater_resource()->Update(
           queue, source_rect, dest_offset, tile->partial_update);
-      if (occlusion) {
-        occlusion->overdraw_metrics()->
-            DidUpload(gfx::Transform(), source_rect, tile->opaque_rect());
-      }
     }
   }
 }
 
 // This picks a small animated layer to be anything less than one viewport. This
 // is specifically for page transitions which are viewport-sized layers. The
 // extra tile of padding is due to these layers being slightly larger than the
 // viewport in some cases.
 bool TiledLayer::IsSmallAnimatedLayer() const {
   if (!draw_transform_is_animating() && !screen_space_transform_is_animating())
@@ skipping 330 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