Fix race conditions in window snapshot code.

cc/trees/thread_proxy.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/thread_proxy.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 496 matching lines @@
                  impl_thread_weak_ptr_,
                  damage_rect));
 }
 
 void ThreadProxy::SetNextCommitWaitsForActivation() {
   DCHECK(IsMainThread());
   DCHECK(!inside_commit_);
   commit_waits_for_activation_ = true;
 }
 
+void ThreadProxy::SetNextCommitForcesRedraw() {

[enne (OOO), 2013/09/11 17:42:43]

This isn't going to work.  This function is "SetNextDrawForcesRedraw", but it
could force the previous source frame (or the one previous to that!) to draw and
not the source frame that comes with the next commit.

The right way to do this is to set a boolean on LayerTreeHost in
LayerTreeHost::SetNextCommitForcesRedraw and then do some work in
LayerTreeHost::FinishCommitOnImplThread.

For the non-impl-side painting path, you can just set full layer damage in that
function.

For the impl-side painting path, you'll need to set some new boolean on
LayerTreeImpl.  Then, in LayerTreeImpl::PushPropertiesTo (aka activation) if
that boolean is true, you can set full root layer damage there on
LayerTreeHostImpl.

That will properly synchronize the damage with the commit that you are forcing.

+  DCHECK(IsMainThread());
+  DCHECK(!inside_commit_);
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::SetFullRootLayerDamageOnImplThread,
+                 impl_thread_weak_ptr_));
+}
+
 void ThreadProxy::SetDeferCommits(bool defer_commits) {
   DCHECK(IsMainThread());
   DCHECK_NE(defer_commits_, defer_commits);
   defer_commits_ = defer_commits;
 
   if (defer_commits_)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ThreadProxy::SetDeferCommits", this);
   else
     TRACE_EVENT_ASYNC_END0("cc", "ThreadProxy::SetDeferCommits", this);
 
@@ skipping 58 matching lines @@
 
 void ThreadProxy::SetInputThrottledUntilCommitOnImplThread(
     bool is_throttled) {
   DCHECK(IsImplThread());
   if (is_throttled == input_throttled_until_commit_)
     return;
   input_throttled_until_commit_ = is_throttled;
   RenewTreePriority();
 }
 
+void ThreadProxy::SetFullRootLayerDamageOnImplThread() {
+  DCHECK(IsImplThread());
+  layer_tree_host_impl_->SetFullRootLayerDamage();
+  LOG(INFO) << "ThreadProxy::SetFullRootLayerDamageOnImplThread";
+}
+
 void ThreadProxy::Start(scoped_ptr<OutputSurface> first_output_surface) {
   DCHECK(IsMainThread());
   DCHECK(Proxy::HasImplThread());
   DCHECK(first_output_surface);
 
   // Create LayerTreeHostImpl.
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
@@ skipping 101 matching lines @@
 
 void ThreadProxy::BeginFrameOnMainThread(
     scoped_ptr<BeginFrameAndCommitState> begin_frame_state) {
   TRACE_EVENT0("cc", "ThreadProxy::BeginFrameOnMainThread");
   DCHECK(IsMainThread());
 
   if (!layer_tree_host_)
     return;
 
   if (defer_commits_) {
+    LOG(INFO) << "EarlyOut_DeferCommits";
     pending_deferred_commit_ = begin_frame_state.Pass();
     layer_tree_host_->DidDeferCommit();
     TRACE_EVENT0("cc", "EarlyOut_DeferCommits");
     return;
   }
 
   // Do not notify the impl thread of commit requests that occur during
   // the apply/animate/layout part of the BeginFrameAndCommit process since
   // those commit requests will get painted immediately. Once we have done
   // the paint, commit_requested_ will be set to false to allow new commit
   // requests to be scheduled.
   commit_requested_ = true;
   commit_request_sent_to_impl_thread_ = true;
 
   // On the other hand, the AnimationRequested flag needs to be cleared
   // here so that any animation requests generated by the apply or animate
   // callbacks will trigger another frame.
   animate_requested_ = false;
 
   if (!in_composite_and_readback_ && !layer_tree_host_->visible()) {
     commit_requested_ = false;
     commit_request_sent_to_impl_thread_ = false;
 
+    LOG(INFO) << "EarlyOut_NotVisible";
     TRACE_EVENT0("cc", "EarlyOut_NotVisible");
     bool did_handle = false;
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread,
                    impl_thread_weak_ptr_,
                    did_handle));
     return;
   }
 
@@ skipping 34 matching lines @@
       begin_frame_state ? begin_frame_state->memory_allocation_limit_bytes
                         : 0u);
 
   // Once single buffered layers are committed, they cannot be modified until
   // they are drawn by the impl thread.
   textures_acquired_ = false;
 
   layer_tree_host_->WillCommit();
 
   if (!updated && can_cancel_this_commit) {
+    LOG(INFO) << "EarlyOut_NoUpdates";
     TRACE_EVENT0("cc", "EarlyOut_NoUpdates");
     bool did_handle = true;
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread,
                    impl_thread_weak_ptr_,
                    did_handle));
 
     // Although the commit is internally aborted, this is because it has been
     // detected to be a no-op.  From the perspective of an embedder, this commit
@@ skipping 66 matching lines @@
     scoped_refptr<cc::ContextProvider> offscreen_context_provider) {
   scoped_ptr<ResourceUpdateQueue> queue(raw_queue);
 
   TRACE_EVENT0("cc", "ThreadProxy::StartCommitOnImplThread");
   DCHECK(!commit_completion_event_on_impl_thread_);
   DCHECK(IsImplThread() && IsMainThreadBlocked());
   DCHECK(scheduler_on_impl_thread_);
   DCHECK(scheduler_on_impl_thread_->CommitPending());
 
   if (!layer_tree_host_impl_) {
+    LOG(INFO) << "EarlyOut_NoLayerTree";
     TRACE_EVENT0("cc", "EarlyOut_NoLayerTree");
     completion->Signal();
     return;
   }
 
   if (offscreen_context_provider.get())
     offscreen_context_provider->BindToCurrentThread();
   layer_tree_host_impl_->SetOffscreenContextProvider(
       offscreen_context_provider);
 
@@ skipping 632 matching lines @@
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 
   UpdateBackgroundAnimateTicking();
 
   commit_to_activate_duration_history_.InsertSample(
       base::TimeTicks::HighResNow() - commit_complete_time_);
 }
 
 }  // namespace cc