cc: Remove invalidation history

cc/resources/picture_pile_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 <algorithm>
 #include <limits>
 #include <set>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/region.h"
@@ skipping 117 matching lines @@
   // that and subtract chunk rects to get the region that we need to subtract
   // from the canvas. Then, we can use clipRect with difference op to subtract
   // each rect in the region.
   bool include_borders = true;
   for (TilingData::Iterator tile_iter(&tiling_, layer_rect, include_borders);
        tile_iter;
        ++tile_iter) {
     PictureMap::const_iterator map_iter = picture_map_.find(tile_iter.index());
     if (map_iter == picture_map_.end())
       continue;
-    const PictureInfo& info = map_iter->second;
-    const Picture* picture = info.GetPicture();
-    if (!picture)
-      continue;
+    const Picture* picture = map_iter->second.get();
+    DCHECK(picture);
 
     // This is intentionally *enclosed* rect, so that the clip is aligned on
     // integral post-scale content pixels and does not extend past the edges
     // of the picture chunk's layer rect.  The min_contents_scale enforces that
     // enough buffer pixels have been added such that the enclosed rect
     // encompasses all invalidated pixels at any larger scale level.
     gfx::Rect chunk_rect = PaddedRect(tile_iter.index());
     gfx::Rect content_clip =
         gfx::ScaleToEnclosedRect(chunk_rect, contents_scale);
     DCHECK(!content_clip.IsEmpty()) << "Layer rect: "
@@ skipping 110 matching lines @@
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
 
   return picture;
 }
 
 size_t PicturePileImpl::GetPictureMemoryUsage() const {
   // Place all pictures in a set to de-dupe.
   size_t total_size = 0;
   std::set<const Picture*> pictures_seen;
   for (const auto& map_value : picture_map_) {
-    const Picture* picture = map_value.second.GetPicture();
-    if (picture && pictures_seen.insert(picture).second)
+    const Picture* picture = map_value.second.get();
+    if (pictures_seen.insert(picture).second)
       total_size += picture->ApproximateMemoryUsage();
   }
 
   return total_size;
 }
 
 void PicturePileImpl::PerformSolidColorAnalysis(
     const gfx::Rect& content_rect,
     float contents_scale,
     RasterSource::SolidColorAnalysis* analysis) const {
@@ skipping 66 matching lines @@
 }
 
 bool PicturePileImpl::CanRasterSlowTileCheck(
     const gfx::Rect& layer_rect) const {
   bool include_borders = false;
   for (TilingData::Iterator tile_iter(&tiling_, layer_rect, include_borders);
        tile_iter; ++tile_iter) {
     PictureMap::const_iterator map_iter = picture_map_.find(tile_iter.index());
     if (map_iter == picture_map_.end())
       return false;
-    if (!map_iter->second.GetPicture())
-      return false;
   }
   return true;
 }
 
 void PicturePileImpl::SetShouldAttemptToUseDistanceFieldText() {
   should_attempt_to_use_distance_field_text_ = true;
 }
 
 bool PicturePileImpl::ShouldAttemptToUseDistanceFieldText() const {
   return should_attempt_to_use_distance_field_text_;
 }
 
 void PicturePileImpl::AsValueInto(
     base::trace_event::TracedValue* pictures) const {
   gfx::Rect tiling_rect(tiling_.tiling_size());
   std::set<const void*> appended_pictures;
   bool include_borders = true;
   for (TilingData::Iterator tile_iter(&tiling_, tiling_rect, include_borders);
        tile_iter; ++tile_iter) {
     PictureMap::const_iterator map_iter = picture_map_.find(tile_iter.index());
     if (map_iter == picture_map_.end())
       continue;
 
-    const Picture* picture = map_iter->second.GetPicture();
-    if (picture && (appended_pictures.count(picture) == 0)) {
+    const Picture* picture = map_iter->second.get();
+    if (appended_pictures.count(picture) == 0) {
       appended_pictures.insert(picture);
       TracedValue::AppendIDRef(picture, pictures);
     }
   }
 }
 
 bool PicturePileImpl::CanUseLCDText() const {
   return can_use_lcd_text_;
 }
 
@@ skipping 35 matching lines @@
   return *this;
 }
 
 void PicturePileImpl::PixelRefIterator::AdvanceToTilePictureWithPixelRefs() {
   for (; tile_iterator_; ++tile_iterator_) {
     PictureMap::const_iterator it =
         picture_pile_->picture_map_.find(tile_iterator_.index());
     if (it == picture_pile_->picture_map_.end())
       continue;
 
-    const Picture* picture = it->second.GetPicture();
-    if (!picture || (processed_pictures_.count(picture) != 0) ||
+    const Picture* picture = it->second.get();
+    if ((processed_pictures_.count(picture) != 0) ||
         !picture->WillPlayBackBitmaps())
       continue;
 
     processed_pictures_.insert(picture);
     pixel_ref_iterator_ = picture->GetPixelRefMapIterator(layer_rect_);
     if (pixel_ref_iterator_)
       break;
   }
 }
 
 void PicturePileImpl::DidBeginTracing() {
   std::set<const void*> processed_pictures;
   for (const auto& map_pair : picture_map_) {
-    const Picture* picture = map_pair.second.GetPicture();
-    if (picture && (processed_pictures.count(picture) == 0)) {
+    const Picture* picture = map_pair.second.get();
+    if (processed_pictures.count(picture) == 0) {
       picture->EmitTraceSnapshot();
       processed_pictures.insert(picture);
     }
   }
 }
 
 }  // namespace cc