cc: Fix impl-side painting flashing due to missing tiles

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 "base/time.h"
 #include "cc/base/math_util.h"
@@ skipping 359 matching lines @@
   *contents_scale_x = max_contents_scale;
   *contents_scale_y = max_contents_scale;
   *content_bounds = gfx::ToCeiledSize(
       gfx::ScaleSize(bounds(), max_contents_scale, max_contents_scale));
 }
 
 skia::RefPtr<SkPicture> PictureLayerImpl::GetPicture() {
   return pile_->GetFlattenedPicture();
 }
 
-scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
-                                                 gfx::Rect content_rect) {
+scoped_refptr<Tile> PictureLayerImpl::CreateTile(
+    const PictureLayerTiling* tiling,

[enne (OOO), 2013/05/02 23:25:37]

This isn't actually needed.  I previously was trying to CreateTile as my check
to see if a null tile was ok, but abandoned that due to the fact that a null
tile can be both missing recorded region or live tiles rect.  The right check is
just to make sure the tiling has been updated.

However, making this const seemed pretty reasonable, so I left it.

+    gfx::Rect content_rect) {
   if (!pile_->CanRaster(tiling->contents_scale(), content_rect))
     return scoped_refptr<Tile>();
 
   return make_scoped_refptr(new Tile(
       layer_tree_impl()->tile_manager(),
       pile_.get(),
       content_rect.size(),
       content_rect,
       contents_opaque() ? content_rect : gfx::Rect(),
       tiling->contents_scale(),
@@ skipping 125 matching lines @@
 
   tilings_->CloneAll(*other->tilings_, MinimumContentsScale());
   DCHECK(bounds() == tilings_->layer_bounds());
 }
 
 void PictureLayerImpl::SyncTiling(
     const PictureLayerTiling* tiling) {
   if (!DrawsContent() || tiling->contents_scale() < MinimumContentsScale())
     return;
   tilings_->Clone(tiling);
+
+  // If this tree needs update draw properties, then the tiling will
+  // get updated prior to drawing or activation.  If this tree does not
+  // need update draw properties, then its transforms are up to date and
+  // we can create tiles for this tiling immediately.
+  if (!layer_tree_impl()->needs_update_draw_properties())
+    UpdateTilePriorities();
 }
 
 void PictureLayerImpl::SetIsMask(bool is_mask) {
   if (is_mask_ == is_mask)
     return;
   is_mask_ = is_mask;
   if (tilings_)
     tilings_->RemoveAllTiles();
 }
 
@@ skipping 13 matching lines @@
     // Masks only supported if they fit on exactly one tile.
     if (iter.geometry_rect() != content_rect)
       return 0;
     return iter->drawing_info().get_resource_id();
   }
   return 0;
 }
 
 bool PictureLayerImpl::AreVisibleResourcesReady() const {
   DCHECK(layer_tree_impl()->IsPendingTree());
+  DCHECK(!layer_tree_impl()->needs_update_draw_properties());
   DCHECK(ideal_contents_scale_);
 
   if (!tilings_->num_tilings())
     return true;
 
   gfx::Rect rect(visible_content_rect());
 
   float min_acceptable_scale =
       std::min(raster_contents_scale_, ideal_contents_scale_);
 
@@ skipping 11 matching lines @@
     // called for active twin.
     if (twin_min_acceptable_scale != 0.0f) {
       min_acceptable_scale =
           std::min(min_acceptable_scale, twin_min_acceptable_scale);
     }
   }
 
   Region missing_region = rect;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
+    DCHECK(tiling->has_ever_been_updated());
 
     if (tiling->contents_scale() < min_acceptable_scale)
       continue;
 
     for (PictureLayerTiling::CoverageIterator iter(tiling,
                                                    contents_scale_x(),
                                                    rect);
          iter;
          ++iter) {
       if (should_force_uploads && *iter)
@@ skipping 310 matching lines @@
 scoped_ptr<base::Value> PictureLayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   LayerImpl::AsValueInto(state.get());
 
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->Set("tilings", tilings_->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc