cc: Remove invalidation history

Now that Blink handles animated gifs, this code is not needed.

BUG=467197

Review URL: https://codereview.chromium.org/1061203002

Cr-Commit-Position: refs/heads/master@{#324084}

12 files changed, 69 insertions, 416 deletions

diff --git a/cc/layers/picture_layer.cc b/cc/layers/picture_layer.cc
index 2234e2c..d41b541 100644
--- a/cc/layers/picture_layer.cc
+++ b/cc/layers/picture_layer.cc
@@ -95,7 +95,6 @@ void PictureLayer::SetLayerTreeHost(LayerTreeHost* host) {
                           host->settings().default_tile_grid_size));
     }
   }
-  recording_source_->DidMoveToNewCompositor();
   recording_source_->SetSlowdownRasterScaleFactor(
       host->debug_state().slow_down_raster_scale_factor);
   recording_source_->SetGatherPixelRefs(host->settings().gather_pixel_refs);
diff --git a/cc/resources/display_list_recording_source.cc b/cc/resources/display_list_recording_source.cc
index e6488687..3a47c90 100644
--- a/cc/resources/display_list_recording_source.cc
+++ b/cc/resources/display_list_recording_source.cc
@@ -123,10 +123,6 @@ bool DisplayListRecordingSource::UpdateAndExpandInvalidation(
   return true;
 }
 
-void DisplayListRecordingSource::DidMoveToNewCompositor() {
-  // No invalidation history to worry about here.
-}
-
 gfx::Size DisplayListRecordingSource::GetSize() const {
   return size_;
 }
diff --git a/cc/resources/display_list_recording_source.h b/cc/resources/display_list_recording_source.h
index a87c848..54ccad07 100644
--- a/cc/resources/display_list_recording_source.h
+++ b/cc/resources/display_list_recording_source.h
@@ -24,7 +24,6 @@ class CC_EXPORT DisplayListRecordingSource : public RecordingSource {
                                    const gfx::Rect& visible_layer_rect,
                                    int frame_number,
                                    RecordingMode recording_mode) override;
-  void DidMoveToNewCompositor() override;
   scoped_refptr<RasterSource> CreateRasterSource(
       bool can_use_lcd_text) const override;
   gfx::Size GetSize() const final;
diff --git a/cc/resources/picture_pile.cc b/cc/resources/picture_pile.cc
index 76570ed..1b81447 100644
--- a/cc/resources/picture_pile.cc
+++ b/cc/resources/picture_pile.cc
@@ -25,16 +25,6 @@ const int kOpCountThatIsOkToAnalyze = 10;
 // the base picture in each tile.
 const int kBasePictureSize = 512;
 
-// Invalidation frequency settings. kInvalidationFrequencyThreshold is a value
-// between 0 and 1 meaning invalidation frequency between 0% and 100% that
-// indicates when to stop invalidating offscreen regions.
-// kFrequentInvalidationDistanceThreshold defines what it means to be
-// "offscreen" in terms of distance to visible in css pixels.
-// TODO(vmpstr): Remove invalidation frequency after frequently invalidated
-// content is not painted at a higher level.
-const float kInvalidationFrequencyThreshold = 0.75f;
-const int kFrequentInvalidationDistanceThreshold = 1024;
-
 // TODO(humper): The density threshold here is somewhat arbitrary; need a
 // way to set // this from the command line so we can write a benchmark
 // script and find a sweet spot.
@@ -216,11 +206,6 @@ bool PicturePile::UpdateAndExpandInvalidation(
   return true;
 }
 
-void PicturePile::DidMoveToNewCompositor() {
-  for (auto& map_pair : picture_map_)
-    map_pair.second.ResetInvalidationHistory();
-}
-
 bool PicturePile::ApplyInvalidationAndResize(const gfx::Rect& interest_rect,
                                              Region* invalidation,
                                              const gfx::Size& layer_size,
@@ -265,7 +250,7 @@ bool PicturePile::ApplyInvalidationAndResize(const gfx::Rect& interest_rect,
     for (const auto& key_picture_pair : picture_map_) {
       const PictureMapKey& key = key_picture_pair.first;
       if (key.first < min_toss_x && key.second < min_toss_y) {
-        has_any_recordings_ |= !!key_picture_pair.second.GetPicture();
+        has_any_recordings_ = true;
         continue;
       }
       to_erase.push_back(key);
@@ -437,8 +422,8 @@ bool PicturePile::ApplyInvalidationAndResize(const gfx::Rect& interest_rect,
   // can just drop/invalidate everything.
   if (invalidation->Contains(gfx::Rect(old_tiling_size)) ||
       invalidation->Contains(gfx::Rect(GetSize()))) {
-    for (auto& it : picture_map_)
-      updated = it.second.Invalidate(frame_number) || updated;
+    updated = !picture_map_.empty();
+    picture_map_.clear();
   } else {
     // Expand invalidation that is on tiles that aren't in the interest rect and
     // will not be re-recorded below. These tiles are no longer valid and should
@@ -478,8 +463,9 @@ bool PicturePile::ApplyInvalidationAndResize(const gfx::Rect& interest_rect,
         if (picture_it == picture_map_.end())
           continue;
 
-        // Inform the grid cell that it has been invalidated in this frame.
-        updated = picture_it->second.Invalidate(frame_number) || updated;
+        updated = true;
+        picture_map_.erase(key);
+
         // Invalidate drops the picture so the whole tile better be invalidated
         // if it won't be re-recorded below.
         DCHECK_IMPLIES(!tiling_.TileBounds(key.first, key.second)
@@ -506,29 +492,8 @@ void PicturePile::GetInvalidTileRects(const gfx::Rect& interest_rect,
   for (TilingData::Iterator it(&tiling_, interest_rect, include_borders); it;
        ++it) {
     const PictureMapKey& key = it.index();
-    PictureInfo& info = picture_map_[key];
-
-    gfx::Rect rect = PaddedRect(key);
-    int distance_to_visible =
-        rect.ManhattanInternalDistance(visible_layer_rect);
-
-    if (info.NeedsRecording(frame_number, distance_to_visible)) {
-      gfx::Rect tile = tiling_.TileBounds(key.first, key.second);
-      invalid_tiles->push_back(tile);
-    } else if (!info.GetPicture()) {
-      if (recorded_viewport_.Intersects(rect)) {
-        // Recorded viewport is just an optimization for a fully recorded
-        // interest rect.  In this case, a tile in that rect has declined
-        // to be recorded (probably due to frequent invalidations).
-        // TODO(enne): Shrink the recorded_viewport_ rather than clearing.
-        recorded_viewport_ = gfx::Rect();
-      }
-
-      // If a tile in the interest rect is not recorded, the entire tile needs
-      // to be considered invalid, so that we know not to keep around raster
-      // tiles that intersect this recording tile.
-      invalidation->Union(tiling_.TileBounds(it.index_x(), it.index_y()));
-    }
+    if (picture_map_.find(key) == picture_map_.end())
+      invalid_tiles->push_back(tiling_.TileBounds(key.first, key.second));
   }
 }
 
@@ -570,8 +535,7 @@ void PicturePile::CreatePictures(ContentLayerClient* painter,
       const PictureMapKey& key = it.index();
       gfx::Rect tile = PaddedRect(key);
       if (padded_record_rect.Contains(tile)) {
-        PictureInfo& info = picture_map_[key];
-        info.SetPicture(picture);
+        picture_map_[key] = picture;
         found_tile_for_recorded_picture = true;
       }
     }
@@ -657,8 +621,6 @@ bool PicturePile::CanRasterSlowTileCheck(const gfx::Rect& layer_rect) const {
     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;
 }
@@ -672,7 +634,7 @@ void PicturePile::DetermineIfSolidColor() {
   }
 
   PictureMap::const_iterator it = picture_map_.begin();
-  const Picture* picture = it->second.GetPicture();
+  const Picture* picture = it->second.get();
 
   // Missing recordings due to frequent invalidations or being too far away
   // from the interest rect will cause the a null picture to exist.
@@ -685,7 +647,7 @@ void PicturePile::DetermineIfSolidColor() {
 
   // Make sure all of the mapped images point to the same picture.
   for (++it; it != picture_map_.end(); ++it) {
-    if (it->second.GetPicture() != picture)
+    if (it->second.get() != picture)
       return;
   }
 
@@ -715,48 +677,6 @@ void PicturePile::Clear() {
   is_solid_color_ = false;
 }
 
-PicturePile::PictureInfo::PictureInfo() : last_frame_number_(0) {
-}
-
-PicturePile::PictureInfo::~PictureInfo() {
-}
-
-void PicturePile::PictureInfo::AdvanceInvalidationHistory(int frame_number) {
-  DCHECK_GE(frame_number, last_frame_number_);
-  if (frame_number == last_frame_number_)
-    return;
-
-  invalidation_history_ <<= (frame_number - last_frame_number_);
-  last_frame_number_ = frame_number;
-}
-
-bool PicturePile::PictureInfo::Invalidate(int frame_number) {
-  AdvanceInvalidationHistory(frame_number);
-  invalidation_history_.set(0);
-
-  bool did_invalidate = !!picture_.get();
-  picture_ = NULL;
-  return did_invalidate;
-}
-
-bool PicturePile::PictureInfo::NeedsRecording(int frame_number,
-                                              int distance_to_visible) {
-  AdvanceInvalidationHistory(frame_number);
-
-  // We only need recording if we don't have a picture. Furthermore, we only
-  // need a recording if we're within frequent invalidation distance threshold
-  // or the invalidation is not frequent enough (below invalidation frequency
-  // threshold).
-  return !picture_.get() &&
-         ((distance_to_visible <= kFrequentInvalidationDistanceThreshold) ||
-          (GetInvalidationFrequency() < kInvalidationFrequencyThreshold));
-}
-
-void PicturePile::PictureInfo::ResetInvalidationHistory() {
-  invalidation_history_.reset();
-  last_frame_number_ = 0;
-}
-
 void PicturePile::SetBufferPixels(int new_buffer_pixels) {
   if (new_buffer_pixels == buffer_pixels())
     return;
@@ -765,17 +685,4 @@ void PicturePile::SetBufferPixels(int new_buffer_pixels) {
   tiling_.SetBorderTexels(new_buffer_pixels);
 }
 
-void PicturePile::PictureInfo::SetPicture(scoped_refptr<Picture> picture) {
-  picture_ = picture;
-}
-
-const Picture* PicturePile::PictureInfo::GetPicture() const {
-  return picture_.get();
-}
-
-float PicturePile::PictureInfo::GetInvalidationFrequency() const {
-  return invalidation_history_.count() /
-         static_cast<float>(INVALIDATION_FRAMES_TRACKED);
-}
-
 }  // namespace cc
diff --git a/cc/resources/picture_pile.h b/cc/resources/picture_pile.h
index f3c9569..9f29e06 100644
--- a/cc/resources/picture_pile.h
+++ b/cc/resources/picture_pile.h
@@ -29,7 +29,6 @@ class CC_EXPORT PicturePile : public RecordingSource {
                                    const gfx::Rect& visible_layer_rect,
                                    int frame_number,
                                    RecordingMode recording_mode) override;
-  void DidMoveToNewCompositor() override;
   scoped_refptr<RasterSource> CreateRasterSource(
       bool can_use_lcd_text) const override;
   gfx::Size GetSize() const final;
@@ -42,36 +41,9 @@ class CC_EXPORT PicturePile : public RecordingSource {
   void SetUnsuitableForGpuRasterizationForTesting() override;
   gfx::Size GetTileGridSizeForTesting() const override;
 
- protected:
-  class CC_EXPORT PictureInfo {
-   public:
-    enum { INVALIDATION_FRAMES_TRACKED = 32 };
-
-    PictureInfo();
-    ~PictureInfo();
-
-    bool Invalidate(int frame_number);
-    bool NeedsRecording(int frame_number, int distance_to_visible);
-    void SetPicture(scoped_refptr<Picture> picture);
-    const Picture* GetPicture() const;
-
-    float GetInvalidationFrequencyForTesting() const {
-      return GetInvalidationFrequency();
-    }
-
-    void ResetInvalidationHistory();
-
-   private:
-    void AdvanceInvalidationHistory(int frame_number);
-    float GetInvalidationFrequency() const;
-
-    int last_frame_number_;
-    scoped_refptr<const Picture> picture_;
-    std::bitset<INVALIDATION_FRAMES_TRACKED> invalidation_history_;
-  };
-
   typedef std::pair<int, int> PictureMapKey;
-  typedef base::hash_map<PictureMapKey, PictureInfo> PictureMap;
+  typedef base::hash_map<PictureMapKey, scoped_refptr<const Picture>>
+      PictureMap;
 
   // An internal CanRaster check that goes to the picture_map rather than
   // using the recorded_viewport hint.
diff --git a/cc/resources/picture_pile_impl.cc b/cc/resources/picture_pile_impl.cc
index 9c68137..be05358 100644
--- a/cc/resources/picture_pile_impl.cc
+++ b/cc/resources/picture_pile_impl.cc
@@ -135,10 +135,8 @@ void PicturePileImpl::CoalesceRasters(const gfx::Rect& canvas_rect,
     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
@@ -269,8 +267,8 @@ size_t PicturePileImpl::GetPictureMemoryUsage() const {
   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();
   }
 
@@ -357,8 +355,6 @@ bool PicturePileImpl::CanRasterSlowTileCheck(
     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;
 }
@@ -382,8 +378,8 @@ void PicturePileImpl::AsValueInto(
     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);
     }
@@ -439,8 +435,8 @@ void PicturePileImpl::PixelRefIterator::AdvanceToTilePictureWithPixelRefs() {
     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;
 
@@ -454,8 +450,8 @@ void PicturePileImpl::PixelRefIterator::AdvanceToTilePictureWithPixelRefs() {
 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);
     }
diff --git a/cc/resources/picture_pile_impl.h b/cc/resources/picture_pile_impl.h
index 72f9a5c..4b7af42 100644
--- a/cc/resources/picture_pile_impl.h
+++ b/cc/resources/picture_pile_impl.h
@@ -96,10 +96,8 @@ class CC_EXPORT PicturePileImpl : public RasterSource {
   friend class PicturePile;
   friend class PixelRefIterator;
 
-  // TODO(vmpstr): Change this when pictures are split from invalidation info.
   using PictureMapKey = PicturePile::PictureMapKey;
   using PictureMap = PicturePile::PictureMap;
-  using PictureInfo = PicturePile::PictureInfo;
 
   PicturePileImpl();
   explicit PicturePileImpl(const PicturePile* other, bool can_use_lcd_text);
diff --git a/cc/resources/picture_pile_unittest.cc b/cc/resources/picture_pile_unittest.cc
index bfeb082..882bbf4 100644
--- a/cc/resources/picture_pile_unittest.cc
+++ b/cc/resources/picture_pile_unittest.cc
@@ -151,17 +151,19 @@ TEST_F(PicturePileTest, SmallInvalidateInflated) {
   EXPECT_EQ(1, pile_.tiling().num_tiles_x());
   EXPECT_EQ(1, pile_.tiling().num_tiles_y());
 
-  FakePicturePile::PictureInfo& picture_info =
-      pile_.picture_map().find(FakePicturePile::PictureMapKey(0, 0))->second;
-  // We should have a picture.
-  EXPECT_TRUE(!!picture_info.GetPicture());
-  gfx::Rect picture_rect = gfx::ScaleToEnclosedRect(
-      picture_info.GetPicture()->LayerRect(), min_scale_);
+  PicturePile::PictureMapKey key = FakePicturePile::PictureMapKey(0, 0);
+  PicturePile::PictureMap::iterator it = pile_.picture_map().find(key);
+  EXPECT_TRUE(it != pile_.picture_map().end());
+  const Picture* picture = it->second.get();
+  EXPECT_TRUE(picture);
+
+  gfx::Rect picture_rect =
+      gfx::ScaleToEnclosedRect(picture->LayerRect(), min_scale_);
 
   // The the picture should be large enough that scaling it never makes a rect
   // smaller than 1 px wide or tall.
-  EXPECT_FALSE(picture_rect.IsEmpty()) << "Picture rect " <<
-      picture_rect.ToString();
+  EXPECT_FALSE(picture_rect.IsEmpty()) << "Picture rect "
+                                       << picture_rect.ToString();
 }
 
 TEST_F(PicturePileTest, LargeInvalidateInflated) {
@@ -173,174 +175,17 @@ TEST_F(PicturePileTest, LargeInvalidateInflated) {
   EXPECT_EQ(1, pile_.tiling().num_tiles_x());
   EXPECT_EQ(1, pile_.tiling().num_tiles_y());
 
-  FakePicturePile::PictureInfo& picture_info =
-      pile_.picture_map().find(FakePicturePile::PictureMapKey(0, 0))->second;
-  EXPECT_TRUE(!!picture_info.GetPicture());
+  PicturePile::PictureMapKey key = FakePicturePile::PictureMapKey(0, 0);
+  PicturePile::PictureMap::iterator it = pile_.picture_map().find(key);
+  EXPECT_TRUE(it != pile_.picture_map().end());
+  const Picture* picture = it->second.get();
+  EXPECT_TRUE(picture);
 
   int expected_inflation = pile_.buffer_pixels();
 
-  const Picture* base_picture = picture_info.GetPicture();
   gfx::Rect base_picture_rect(tiling_size());
   base_picture_rect.Inset(-expected_inflation, -expected_inflation);
-  EXPECT_EQ(base_picture_rect.ToString(),
-            base_picture->LayerRect().ToString());
-}
-
-TEST_F(PicturePileTest, InvalidateOnTileBoundaryInflated) {
-  gfx::Size new_tiling_size =
-      gfx::ToCeiledSize(gfx::ScaleSize(tiling_size(), 2.f));
-  // This creates initial pictures.
-  SetTilingSize(new_tiling_size);
-
-  // Due to border pixels, we should have 3 tiles.
-  EXPECT_EQ(3, pile_.tiling().num_tiles_x());
-  EXPECT_EQ(3, pile_.tiling().num_tiles_y());
-
-  // We should have 1/.125 - 1 = 7 border pixels.
-  EXPECT_EQ(7, pile_.buffer_pixels());
-  EXPECT_EQ(7, pile_.tiling().border_texels());
-
-  // Invalidate everything to have a non zero invalidation frequency.
-  UpdateWholePile();
-
-  // Invalidate something just over a tile boundary by a single pixel.
-  // This will invalidate the tile (1, 1), as well as 1 row of pixels in (1, 0).
-  Region invalidate_rect(
-      gfx::Rect(pile_.tiling().TileBoundsWithBorder(0, 0).right(),
-                pile_.tiling().TileBoundsWithBorder(0, 0).bottom() - 1,
-                50,
-                50));
-  Region expected_invalidation = invalidate_rect;
-  UpdateAndExpandInvalidation(&invalidate_rect, tiling_size(), tiling_rect());
-  EXPECT_EQ(expected_invalidation.ToString(), invalidate_rect.ToString());
-
-  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
-      FakePicturePile::PictureInfo& picture_info =
-          pile_.picture_map()
-              .find(FakePicturePile::PictureMapKey(i, j))
-              ->second;
-
-      // Expect (1, 1) and (1, 0) to be invalidated once more
-      // than the rest of the tiles.
-      if (i == 1 && (j == 0 || j == 1)) {
-        EXPECT_FLOAT_EQ(
-            2.0f / FakePicturePile::PictureInfo::INVALIDATION_FRAMES_TRACKED,
-            picture_info.GetInvalidationFrequencyForTesting());
-      } else {
-        EXPECT_FLOAT_EQ(
-            1.0f / FakePicturePile::PictureInfo::INVALIDATION_FRAMES_TRACKED,
-            picture_info.GetInvalidationFrequencyForTesting());
-      }
-    }
-  }
-}
-
-TEST_F(PicturePileTest, InvalidateOnFullLayer) {
-  UpdateWholePile();
-
-  // Everything was invalidated once so far.
-  for (auto& it : pile_.picture_map()) {
-    EXPECT_FLOAT_EQ(
-        1.0f / FakePicturePile::PictureInfo::INVALIDATION_FRAMES_TRACKED,
-        it.second.GetInvalidationFrequencyForTesting());
-  }
-
-  // Invalidate everything,
-  Region invalidation = tiling_rect();
-  UpdateAndExpandInvalidation(&invalidation, tiling_size(), tiling_rect());
-
-  // Everything was invalidated again.
-  for (auto& it : pile_.picture_map()) {
-    EXPECT_FLOAT_EQ(
-        2.0f / FakePicturePile::PictureInfo::INVALIDATION_FRAMES_TRACKED,
-        it.second.GetInvalidationFrequencyForTesting());
-  }
-}
-
-TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
-  gfx::Size new_tiling_size =
-      gfx::ToCeiledSize(gfx::ScaleSize(tiling_size(), 4.f));
-  SetTilingSize(new_tiling_size);
-
-  gfx::Rect viewport(tiling_size().width(), 1);
-
-  // Update the whole pile until the invalidation frequency is high.
-  for (int frame = 0; frame < 33; ++frame) {
-    UpdateWholePile();
-  }
-
-  // Make sure we have a high invalidation frequency.
-  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
-      FakePicturePile::PictureInfo& picture_info =
-          pile_.picture_map()
-              .find(FakePicturePile::PictureMapKey(i, j))
-              ->second;
-      EXPECT_FLOAT_EQ(1.0f, picture_info.GetInvalidationFrequencyForTesting())
-          << "i " << i << " j " << j;
-    }
-  }
-
-  // Update once more with a small viewport.
-  Region invalidation(tiling_rect());
-  UpdateAndExpandInvalidation(&invalidation, tiling_size(), viewport);
-  EXPECT_EQ(tiling_rect().ToString(), invalidation.ToString());
-
-  bool had_tiles_with_no_pictures = false;
-  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
-      FakePicturePile::PictureInfo& picture_info =
-          pile_.picture_map()
-              .find(FakePicturePile::PictureMapKey(i, j))
-              ->second;
-      EXPECT_FLOAT_EQ(1.0f, picture_info.GetInvalidationFrequencyForTesting());
-
-      // If the y far enough away we expect to find no picture (no re-recording
-      // happened). For close y, the picture should change.
-      if (j >= 3) {
-        EXPECT_FALSE(picture_info.GetPicture()) << "i " << i << " j " << j;
-        had_tiles_with_no_pictures = true;
-      } else {
-        EXPECT_TRUE(picture_info.GetPicture()) << "i " << i << " j " << j;
-      }
-    }
-  }
-
-  EXPECT_TRUE(had_tiles_with_no_pictures);
-
-  // Update a partial tile that doesn't get recorded. We should expand the
-  // invalidation to the entire tiles that overlap it.
-  Region small_invalidation =
-      gfx::Rect(pile_.tiling().TileBounds(3, 4).x(),
-                pile_.tiling().TileBounds(3, 4).y() + 10,
-                1,
-                1);
-  UpdateAndExpandInvalidation(&small_invalidation, tiling_size(), viewport);
-  EXPECT_TRUE(small_invalidation.Contains(gfx::UnionRects(
-      pile_.tiling().TileBounds(2, 4), pile_.tiling().TileBounds(3, 4))))
-      << small_invalidation.ToString();
-
-  // Now update with no invalidation and full viewport
-  Region empty_invalidation;
-  UpdateAndExpandInvalidation(&empty_invalidation, tiling_size(),
-                              tiling_rect());
-  EXPECT_EQ(Region().ToString(), empty_invalidation.ToString());
-
-  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
-      FakePicturePile::PictureInfo& picture_info =
-          pile_.picture_map()
-              .find(FakePicturePile::PictureMapKey(i, j))
-              ->second;
-      // Expect the invalidation frequency to be less than 1, since we just
-      // updated with no invalidations.
-      EXPECT_LT(picture_info.GetInvalidationFrequencyForTesting(), 1.f);
-
-      // We expect that there are pictures everywhere now.
-      EXPECT_TRUE(picture_info.GetPicture()) << "i " << i << " j " << j;
-    }
-  }
+  EXPECT_EQ(base_picture_rect.ToString(), picture->LayerRect().ToString());
 }
 
 TEST_F(PicturePileTest, ClearingInvalidatesRecordedRect) {
@@ -356,58 +201,6 @@ TEST_F(PicturePileTest, ClearingInvalidatesRecordedRect) {
   EXPECT_FALSE(pile_.CanRasterSlowTileCheck(rect));
 }
 
-TEST_F(PicturePileTest, FrequentInvalidationCanRaster) {
-  // This test makes sure that if part of the page is frequently invalidated
-  // and doesn't get re-recorded, then CanRaster is not true for any
-  // tiles touching it, but is true for adjacent tiles, even if it
-  // overlaps on borders (edge case).
-  gfx::Size new_tiling_size =
-      gfx::ToCeiledSize(gfx::ScaleSize(tiling_size(), 4.f));
-  SetTilingSize(new_tiling_size);
-
-  gfx::Rect tile02_borders = pile_.tiling().TileBoundsWithBorder(0, 2);
-  gfx::Rect tile03_borders = pile_.tiling().TileBoundsWithBorder(0, 3);
-  gfx::Rect tile02_noborders = pile_.tiling().TileBounds(0, 2);
-  gfx::Rect tile03_noborders = pile_.tiling().TileBounds(0, 3);
-
-  // Sanity check these two tiles are overlapping with borders, since this is
-  // what the test is trying to repro.
-  EXPECT_TRUE(tile02_borders.Intersects(tile03_borders));
-  EXPECT_FALSE(tile02_noborders.Intersects(tile03_noborders));
-  UpdateWholePile();
-  EXPECT_TRUE(pile_.CanRasterLayerRect(tile02_noborders));
-  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile02_noborders));
-  EXPECT_TRUE(pile_.CanRasterLayerRect(tile03_noborders));
-  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile03_noborders));
-  // Sanity check that an initial paint goes down the fast path of having
-  // a valid recorded viewport.
-  EXPECT_TRUE(!pile_.recorded_viewport().IsEmpty());
-
-  // Update the whole layer until the invalidation frequency is high.
-  for (int frame = 0; frame < 33; ++frame) {
-    UpdateWholePile();
-  }
-
-  // Update once more with a small viewport.
-  gfx::Rect viewport(tiling_size().width(), 1);
-  Region invalidation(tiling_rect());
-  UpdateAndExpandInvalidation(&invalidation, tiling_size(), viewport);
-  EXPECT_EQ(tiling_rect().ToString(), invalidation.ToString());
-
-  // Sanity check some pictures exist and others don't.
-  EXPECT_TRUE(pile_.picture_map()
-                  .find(FakePicturePile::PictureMapKey(0, 2))
-                  ->second.GetPicture());
-  EXPECT_FALSE(pile_.picture_map()
-                   .find(FakePicturePile::PictureMapKey(0, 3))
-                   ->second.GetPicture());
-
-  EXPECT_TRUE(pile_.CanRasterLayerRect(tile02_noborders));
-  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile02_noborders));
-  EXPECT_FALSE(pile_.CanRasterLayerRect(tile03_noborders));
-  EXPECT_FALSE(pile_.CanRasterSlowTileCheck(tile03_noborders));
-}
-
 TEST_F(PicturePileTest, NoInvalidationValidViewport) {
   // This test validates that the recorded_viewport cache of full tiles
   // is still valid for some use cases.  If it's not, it's a performance
@@ -581,7 +374,7 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -599,7 +392,7 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_EQ(j < 5, it != map.end() && it->second.GetPicture());
+      EXPECT_EQ(j < 5, it != map.end() && it->second.get());
     }
   }
 
@@ -644,7 +437,7 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
           expect_tile = j < 5 || (j == 5 && i == 5);
           break;
       }
-      EXPECT_EQ(expect_tile, it != map.end() && it->second.GetPicture());
+      EXPECT_EQ(expect_tile, it != map.end() && it->second.get());
     }
   }
 
@@ -691,7 +484,7 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_EQ(i < 5, it != map.end() && it->second.GetPicture());
+      EXPECT_EQ(i < 5, it != map.end() && it->second.get());
     }
   }
 
@@ -738,7 +531,7 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
           expect_tile = i < 5 || (j == 5 && i == 5);
           break;
       }
-      EXPECT_EQ(expect_tile, it != map.end() && it->second.GetPicture());
+      EXPECT_EQ(expect_tile, it != map.end() && it->second.get());
     }
   }
 
@@ -780,7 +573,7 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_EQ(i < 5 && j < 5, it != map.end() && it->second.GetPicture());
+      EXPECT_EQ(i < 5 && j < 5, it != map.end() && it->second.get());
     }
   }
 
@@ -830,8 +623,8 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
           expect_tile = (i < 5 && j < 5) || (j == 5 && i == 5);
           break;
       }
-      EXPECT_EQ(expect_tile, it != map.end() && it->second.GetPicture())
-          << i << "," << j;
+      EXPECT_EQ(expect_tile, it != map.end() && it->second.get()) << i << ","
+                                                                  << j;
     }
   }
 
@@ -895,7 +688,7 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -936,7 +729,7 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
             expect_tile = j < 5 || (j == 5 && i == 5);
             break;
         }
-        EXPECT_EQ(expect_tile, it != map.end() && it->second.GetPicture());
+        EXPECT_EQ(expect_tile, it != map.end() && it->second.get());
       }
     }
 
@@ -1002,7 +795,7 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
             expect_tile = i < 5 || (j == 5 && i == 5);
             break;
         }
-        EXPECT_EQ(expect_tile, it != map.end() && it->second.GetPicture());
+        EXPECT_EQ(expect_tile, it != map.end() && it->second.get());
       }
     }
 
@@ -1071,8 +864,8 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
             expect_tile = (i < 5 && j < 5) || (j == 5 && i == 5);
             break;
         }
-        EXPECT_EQ(expect_tile, it != map.end() && it->second.GetPicture())
-            << i << "," << j;
+        EXPECT_EQ(expect_tile, it != map.end() && it->second.get()) << i << ","
+                                                                    << j;
       }
     }
 
@@ -1152,7 +945,7 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1167,7 +960,7 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1193,7 +986,7 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1216,7 +1009,7 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1242,7 +1035,7 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1265,7 +1058,7 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1295,7 +1088,7 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1333,7 +1126,7 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1348,7 +1141,7 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1369,7 +1162,7 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1391,7 +1184,7 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1412,7 +1205,7 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1434,7 +1227,7 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
@@ -1455,7 +1248,7 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
       FakePicturePile::PictureMapKey key(i, j);
       FakePicturePile::PictureMap& map = pile_.picture_map();
       FakePicturePile::PictureMap::iterator it = map.find(key);
-      EXPECT_TRUE(it != map.end() && it->second.GetPicture());
+      EXPECT_TRUE(it != map.end() && it->second.get());
     }
   }
 
diff --git a/cc/resources/recording_source.h b/cc/resources/recording_source.h
index 98e4e87..ef8c033 100644
--- a/cc/resources/recording_source.h
+++ b/cc/resources/recording_source.h
@@ -39,8 +39,6 @@ class CC_EXPORT RecordingSource {
                                            int frame_number,
                                            RecordingMode recording_mode) = 0;
 
-  virtual void DidMoveToNewCompositor() = 0;
-
   virtual scoped_refptr<RasterSource> CreateRasterSource(
       bool can_use_lcd_text) const = 0;
 
diff --git a/cc/test/fake_picture_pile.cc b/cc/test/fake_picture_pile.cc
index 614d106..80a584b 100644
--- a/cc/test/fake_picture_pile.cc
+++ b/cc/test/fake_picture_pile.cc
@@ -68,7 +68,7 @@ void FakePicturePile::AddRecordingAt(int x, int y) {
   scoped_refptr<Picture> picture(
       Picture::Create(bounds, &client_, tile_grid_size_, gather_pixel_refs_,
                       RecordingSource::RECORD_NORMALLY));
-  picture_map_[std::pair<int, int>(x, y)].SetPicture(picture);
+  picture_map_[std::pair<int, int>(x, y)] = picture;
   EXPECT_TRUE(HasRecordingAt(x, y));
 
   has_any_recordings_ = true;
@@ -88,9 +88,7 @@ void FakePicturePile::RemoveRecordingAt(int x, int y) {
 
 bool FakePicturePile::HasRecordingAt(int x, int y) const {
   PictureMap::const_iterator found = picture_map_.find(PictureMapKey(x, y));
-  if (found == picture_map_.end())
-    return false;
-  return !!found->second.GetPicture();
+  return found != picture_map_.end();
 }
 
 void FakePicturePile::Rerecord() {
diff --git a/cc/test/fake_picture_pile.h b/cc/test/fake_picture_pile.h
index 9a9b3fa..e6f81dd 100644
--- a/cc/test/fake_picture_pile.h
+++ b/cc/test/fake_picture_pile.h
@@ -17,7 +17,6 @@ namespace cc {
 
 class FakePicturePile : public PicturePile {
  public:
-  using PictureInfo = PicturePile::PictureInfo;
   using PictureMapKey = PicturePile::PictureMapKey;
   using PictureMap = PicturePile::PictureMap;
 
diff --git a/cc/test/fake_picture_pile_impl.cc b/cc/test/fake_picture_pile_impl.cc
index ab255cc..172a434 100644
--- a/cc/test/fake_picture_pile_impl.cc
+++ b/cc/test/fake_picture_pile_impl.cc
@@ -114,9 +114,7 @@ void FakePicturePileImpl::PlaybackToCanvas(SkCanvas* canvas,
 
 bool FakePicturePileImpl::HasRecordingAt(int x, int y) const {
   PictureMap::const_iterator found = picture_map_.find(PictureMapKey(x, y));
-  if (found == picture_map_.end())
-    return false;
-  return !!found->second.GetPicture();
+  return found != picture_map_.end();
 }
 
 }  // namespace cc