SetNeedsRedraw directly when updating a visible tile.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 1099 matching lines @@
     }
   }
 }
 
 DrawResult LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
   TRACE_EVENT1("cc",
                "LayerTreeHostImpl::PrepareToDraw",
                "SourceFrameNumber",
                active_tree_->source_frame_number());
 
-  if (need_to_update_visible_tiles_before_draw_ &&
-      tile_manager_ && tile_manager_->UpdateVisibleTiles()) {
-    DidInitializeVisibleTile();
-  }
+  if (need_to_update_visible_tiles_before_draw_ && tile_manager_)
+    tile_manager_->UpdateVisibleTiles();
   need_to_update_visible_tiles_before_draw_ = true;
 
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Compositing.NumActiveLayers", active_tree_->NumLayers(), 1, 400, 20);
 
   bool ok = active_tree_->UpdateDrawProperties();
   DCHECK(ok) << "UpdateDrawProperties failed during draw";
 
   frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
   frame->render_passes.clear();
@@ skipping 128 matching lines @@
 }
 
 void LayerTreeHostImpl::DidModifyTilePriorities() {
   DCHECK(settings_.impl_side_painting);
   // Mark priorities as dirty and schedule a ManageTiles().
   tile_priorities_dirty_ = true;
   client_->SetNeedsManageTilesOnImplThread();
 }
 
 void LayerTreeHostImpl::DidInitializeVisibleTile() {
-  if (client_ && !client_->IsInsideDraw())
-    client_->DidInitializeVisibleTileOnImplThread();
+  DCHECK(!client_->IsInsideDraw());
+  client_->DidInitializeVisibleTileOnImplThread();
 }
 
 void LayerTreeHostImpl::GetPictureLayerImplPairs(
     std::vector<PictureLayerImpl::Pair>* layer_pairs) const {
   DCHECK(layer_pairs->empty());
   for (std::vector<PictureLayerImpl*>::const_iterator it =
            picture_layers_.begin();
        it != picture_layers_.end();
        ++it) {
     PictureLayerImpl* layer = *it;
@@ skipping 39 matching lines @@
 
 const std::vector<PictureLayerImpl*>& LayerTreeHostImpl::GetPictureLayers()
     const {
   return picture_layers_;
 }
 
 void LayerTreeHostImpl::NotifyReadyToActivate() {
   client_->NotifyReadyToActivate();
 }
 
-void LayerTreeHostImpl::NotifyTileStateChanged(const Tile* tile) {
+void LayerTreeHostImpl::NotifyTileStateChanged(const Tile* tile,
+                                               bool visible_tile) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileStateChanged");
 
   if (active_tree_) {
     LayerImpl* layer_impl =
         active_tree_->FindActiveTreeLayerById(tile->layer_id());
     if (layer_impl)
       layer_impl->NotifyTileStateChanged(tile);
   }
 
   if (pending_tree_) {
     LayerImpl* layer_impl =
         pending_tree_->FindPendingTreeLayerById(tile->layer_id());
     if (layer_impl)
       layer_impl->NotifyTileStateChanged(tile);
   }
+
+  if (visible_tile && !client_->IsInsideDraw())

[enne (OOO), 2014/10/28 18:09:22]

I don't think we want to redraw if a tile gets removed, since that could mean
that the new frame is strictly worse.

[danakj, 2014/10/28 18:24:48]

Ya.. though that's like flaky at best if you scroll it'd disappear anyway, for
example. Maybe I can pass that through with the Tile* though, not sure.

[enne (OOO), 2014/10/28 18:47:33]

No, it's true that it's flaky at best.  But, it seems like we shouldn't do work
to put up a worse frame unless we have to.  :P

[danakj, 2014/10/31 20:02:01]

Actually, I don't think I agree. If we're evicting a tile in the renderer, we
need to draw and swap to tell the browser to stop using the tile in order to
actually free that memory. We could special case this in the browser but that
does not seem worth the complexity at all given the browser will rarely if ever
checkerboard anything.

+    SetNeedsRedraw();
 }
 
 void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   SetManagedMemoryPolicy(policy, zero_budget_);
 }
 
 void LayerTreeHostImpl::SetTreeActivationCallback(
     const base::Closure& callback) {
   DCHECK(proxy_->IsImplThread());
   DCHECK(settings_.impl_side_painting || callback.is_null());
@@ skipping 1625 matching lines @@
 
 void LayerTreeHostImpl::PinchGestureEnd() {
   pinch_gesture_active_ = false;
   if (pinch_gesture_end_should_clear_scrolling_layer_) {
     pinch_gesture_end_should_clear_scrolling_layer_ = false;
     ClearCurrentlyScrollingLayer();
   }
   if (top_controls_manager_)
     top_controls_manager_->PinchEnd();
   client_->SetNeedsCommitOnImplThread();
+  // When a pinch ends, we may be displaying content cached at incorrect scales,
+  // so updating draw properties and drawing will ensure we are using the right
+  // scales that we want when we're not inside a pinch.
+  LOG(ERROR) << "END PINCH";
+  active_tree_->set_needs_update_draw_properties();
+  SetNeedsRedraw();

[enne (OOO), 2014/10/28 18:09:21]

Do you need the set needs redraw as well? Is this redundant with the
NotifyTileStateChanged one?

[enne (OOO), 2014/10/28 18:09:21]

Do you need the set needs redraw as well? Is this redundant with the
NotifyTileStateChanged one?

[danakj, 2014/10/28 18:24:48]

We need this in order to trigger an UpdateDrawProperties and make the new raster
scale.

[enne (OOO), 2014/10/28 18:47:33]

As I said elsewhere, the redraw part of that seems racy with respect to tiles
being done.  I guess we'll early out of drawing if nothing has changed,
but...it's kind of weird vs. just doing an UDP.

[danakj, 2014/10/31 20:02:01]

I think we agreed this is not racey. The Draw will do UpdateVisibleTiles() which
will damage any tiles that have completed so far, and then draw them. Or early
out if there's nothing damaged on screen.

 }
 
 static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
                                 LayerImpl* layer_impl) {
   DCHECK(layer_impl);
 
   gfx::Vector2d scroll_delta =
       gfx::ToFlooredVector2d(layer_impl->ScrollDelta());
   if (!scroll_delta.IsZero()) {
     LayerTreeHostCommon::ScrollUpdateInfo scroll;
@@ skipping 474 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc