Fix race conditions in window snapshot code.

cc/trees/layer_tree_host.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.h"
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 115 matching lines @@
       visible_(true),
       page_scale_factor_(1.f),
       min_page_scale_factor_(1.f),
       max_page_scale_factor_(1.f),
       trigger_idle_updates_(true),
       background_color_(SK_ColorWHITE),
       has_transparent_background_(false),
       partial_texture_update_requests_(0),
       in_paint_layer_contents_(false),
       total_frames_used_for_lcd_text_metrics_(0),
-      tree_id_(s_next_tree_id++) {
+      tree_id_(s_next_tree_id++),
+      next_commit_forces_redraw_(false) {
   if (settings_.accelerated_animation_enabled)
     animation_registrar_ = AnimationRegistrar::Create();
   s_num_layer_tree_instances++;
   rendering_stats_instrumentation_->set_record_rendering_stats(
       debug_state_.RecordRenderingStats());
 }
 
 bool LayerTreeHost::Initialize(
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
   if (impl_task_runner.get())
@@ skipping 169 matching lines @@
   // In impl-side painting, synchronize to the pending tree so that it has
   // time to raster before being displayed.  If no pending tree is needed,
   // synchronization can happen directly to the active tree and
   // unlinked contents resources can be reclaimed immediately.
   LayerTreeImpl* sync_tree;
   if (settings_.impl_side_painting) {
     // Commits should not occur while there is already a pending tree.
     DCHECK(!host_impl->pending_tree());
     host_impl->CreatePendingTree();
     sync_tree = host_impl->pending_tree();
+    if (next_commit_forces_redraw_)
+      sync_tree->ForceRedrawNextActivation();
   } else {
+    if (next_commit_forces_redraw_)
+      host_impl->SetFullRootLayerDamage();
     contents_texture_manager_->ReduceMemory(host_impl->resource_provider());
     sync_tree = host_impl->active_tree();
   }
 
+  next_commit_forces_redraw_ = false;
+
   sync_tree->set_source_frame_number(source_frame_number());
 
   if (needs_full_tree_sync_)
     sync_tree->SetRootLayer(TreeSynchronizer::SynchronizeTrees(
         root_layer(), sync_tree->DetachLayerTree(), sync_tree));
   {
     TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
     TreeSynchronizer::PushProperties(root_layer(), sync_tree->root_layer());
   }
 
@@ skipping 217 matching lines @@
 }
 
 bool LayerTreeHost::CommitRequested() const {
   return proxy_->CommitRequested();
 }
 
 void LayerTreeHost::SetNextCommitWaitsForActivation() {
   proxy_->SetNextCommitWaitsForActivation();
 }
 
+void LayerTreeHost::SetNextCommitForcesRedraw() {
+  next_commit_forces_redraw_ = true;
+}
+
 void LayerTreeHost::SetAnimationEvents(scoped_ptr<AnimationEventsVector> events,
                                        base::Time wall_clock_time) {
   DCHECK(proxy_->IsMainThread());
   for (size_t event_index = 0; event_index < events->size(); ++event_index) {
     int event_layer_id = (*events)[event_index].layer_id;
 
     // Use the map of all controllers, not just active ones, since non-active
     // controllers may still receive events for impl-only animations.
     const AnimationRegistrar::AnimationControllerMap& animation_controllers =
         animation_registrar_->all_animation_controllers();
@@ skipping 682 matching lines @@
   outer_viewport_scroll_layer_ = outer_viewport_scroll_layer;
 }
 
 bool LayerTreeHost::ScheduleMicroBenchmark(
     const std::string& benchmark_name,
     const MicroBenchmark::DoneCallback& callback) {
   return micro_benchmark_controller_.ScheduleRun(benchmark_name, callback);
 }
 
 }  // namespace cc