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 504 matching lines @@
   tilings_->RemoveAllTilings();
   tilings_->AddTilingsToMatchScales(*other->tilings_, MinimumContentsScale());
   DCHECK(bounds() == tilings_->layer_bounds());
 }
 
 void PictureLayerImpl::SyncTiling(
     const PictureLayerTiling* tiling) {
   if (!DrawsContent() || tiling->contents_scale() < MinimumContentsScale())
     return;
   tilings_->AddTiling(tiling->contents_scale());
+
+  // 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