Fix race conditions in window snapshot code.

cc/trees/thread_proxy.cc

Index: cc/trees/thread_proxy.cc
diff --git a/cc/trees/thread_proxy.cc b/cc/trees/thread_proxy.cc
index dda25ecb79ad4b24337fa6a00cda38c3bbd4b5e6..104380be2166b76b12d95d15e914dca3dd7ef782 100644
--- a/cc/trees/thread_proxy.cc
+++ b/cc/trees/thread_proxy.cc
@@ -514,6 +514,15 @@ void ThreadProxy::SetNextCommitWaitsForActivation() {
   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);
@@ -592,6 +601,12 @@ void ThreadProxy::SetInputThrottledUntilCommitOnImplThread(
   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());
@@ -713,6 +728,7 @@ void ThreadProxy::BeginFrameOnMainThread(
     return;
 
   if (defer_commits_) {
+    LOG(INFO) << "EarlyOut_DeferCommits";
     pending_deferred_commit_ = begin_frame_state.Pass();
     layer_tree_host_->DidDeferCommit();
     TRACE_EVENT0("cc", "EarlyOut_DeferCommits");
@@ -736,6 +752,7 @@ void ThreadProxy::BeginFrameOnMainThread(
     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(
@@ -790,6 +807,7 @@ void ThreadProxy::BeginFrameOnMainThread(
   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(
@@ -876,6 +894,7 @@ void ThreadProxy::StartCommitOnImplThread(
   DCHECK(scheduler_on_impl_thread_->CommitPending());
 
   if (!layer_tree_host_impl_) {
+    LOG(INFO) << "EarlyOut_NoLayerTree";
     TRACE_EVENT0("cc", "EarlyOut_NoLayerTree");
     completion->Signal();
     return;