cc: Replace recorded region with direct map lookup

cc/layers/picture_layer_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 "cc/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/time/time.h"
@@ skipping 846 matching lines @@
 
   needs_post_commit_initialization_ = false;
 }
 
 PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   DCHECK(CanHaveTilingWithScale(contents_scale)) <<
       "contents_scale: " << contents_scale;
 
   PictureLayerTiling* tiling = tilings_->AddTiling(contents_scale);
 
-  const Region& recorded = pile_->recorded_region();
-  DCHECK(!recorded.IsEmpty());
+  DCHECK(pile_->HasRecordings());
 
   if (twin_layer_ &&
       twin_layer_->ShouldUseGpuRasterization() == ShouldUseGpuRasterization())
     twin_layer_->SyncTiling(tiling);
 
   return tiling;
 }
 
 void PictureLayerImpl::RemoveTiling(float contents_scale) {
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
@@ skipping 291 matching lines @@
   low_res_raster_contents_scale_ = 0.f;
 
   // When raster scales aren't valid, don't update tile priorities until
   // this layer has been updated via UpdateDrawProperties.
   should_update_tile_priorities_ = false;
 }
 
 bool PictureLayerImpl::CanHaveTilings() const {
   if (!DrawsContent())
     return false;
-  if (pile_->recorded_region().IsEmpty())
+  if (!pile_->HasRecordings())
     return false;
   return true;
 }
 
 bool PictureLayerImpl::CanHaveTilingWithScale(float contents_scale) const {
   if (!CanHaveTilings())
     return false;
   if (contents_scale < MinimumContentsScale())
     return false;
   return true;
@@ skipping 23 matching lines @@
 
 void PictureLayerImpl::AsValueInto(base::DictionaryValue* state) const {
   const_cast<PictureLayerImpl*>(this)->DoPostCommitInitializationIfNeeded();
   LayerImpl::AsValueInto(state);
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->SetDouble("geometry_contents_scale", contents_scale_x());
   state->Set("tilings", tilings_->AsValue().release());
   state->Set("pictures", pile_->AsValue().release());
   state->Set("invalidation", invalidation_.AsValue().release());
 
-  Region unrecorded_region(gfx::Rect(pile_->size()));
-  unrecorded_region.Subtract(pile_->recorded_region());
-  if (!unrecorded_region.IsEmpty())
-    state->Set("unrecorded_region", unrecorded_region.AsValue().release());
-
   scoped_ptr<base::ListValue> coverage_tiles(new base::ListValue);
   for (PictureLayerTilingSet::CoverageIterator iter(tilings_.get(),
                                                     contents_scale_x(),
                                                     gfx::Rect(content_bounds()),
                                                     ideal_contents_scale_);
        iter;
        ++iter) {
     scoped_ptr<base::DictionaryValue> tile_data(new base::DictionaryValue);
     tile_data->Set("geometry_rect",
                    MathUtil::AsValue(iter.geometry_rect()).release());
@@ skipping 10 matching lines @@
 size_t PictureLayerImpl::GPUMemoryUsageInBytes() const {
   const_cast<PictureLayerImpl*>(this)->DoPostCommitInitializationIfNeeded();
   return tilings_->GPUMemoryUsageInBytes();
 }
 
 void PictureLayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 }  // namespace cc