cc: Fix race in SurfaceLayer unittests.

cc/layers/surface_layer_unittest.cc

 // Copyright 2014 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 <set>
 #include <vector>
 
 #include "base/message_loop/message_loop_proxy.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/surface_layer.h"
@@ skipping 161 matching lines @@
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(&SurfaceLayerSwapPromise::ChangeTree,
                               base::Unretained(this)));
   }
 
   void ChangeTree() {
+    base::AutoLock lock(lock_);

[danakj, 2015/01/06 15:57:40]

This still means ChangeTree and SwapBuffersOnThread may run in either order
which is not very desirable for a test.

Probably DidCommit should be DidCommitAndDrawFrame() so that SwapBuffersOnThread
always comes first? Or post the ChangeTree call from SwapBuffersOnThread
instead?

[sohanjg, 2015/01/08 12:05:41]

Yes, i have changed DidCommit to DidCommitAndDrawFrame.
I tried posting ChangeTree from SwapBuffersOnThread, but that hits an assert as
we do SetRootLayer in ChangeTree, and that will do a setneedscommit, which is
expected from Main thread.

     ++commit_count_;
     switch (commit_count_) {
       case 1:
         // Remove SurfaceLayer from tree to cause SwapPromise to be created.
         blank_layer_ = SolidColorLayer::Create();
         blank_layer_->SetIsDrawable(true);
         blank_layer_->SetBounds(gfx::Size(10, 10));
         layer_tree_host()->SetRootLayer(blank_layer_);
         break;
       case 2:
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
     EXPECT_TRUE(result);
     std::vector<uint32_t>& satisfied =
         output_surface()->last_sent_frame().metadata.satisfies_sequences;
     EXPECT_LE(satisfied.size(), 1u);
     if (satisfied.size() == 1) {
       // Eventually the one SurfaceSequence should be satisfied, but only
       // after the layer was removed from the tree, and only once.
+      base::AutoLock lock(lock_);
       EXPECT_EQ(1u, satisfied[0]);
       EXPECT_LE(1, commit_count_);
       EXPECT_FALSE(sequence_was_satisfied_);
       sequence_was_satisfied_ = true;
       EndTest();
     }
   }
 
   void AfterTest() override {
     EXPECT_TRUE(required_id_ == SurfaceId(1));
     EXPECT_EQ(1u, required_set_.size());
     // Sequence should have been satisfied through Swap, not with the
     // callback.
     EXPECT_TRUE(satisfied_sequence_.is_null());
   }
 
  private:
   int commit_count_;
   bool sequence_was_satisfied_;
   scoped_refptr<SurfaceLayer> layer_;
   scoped_refptr<Layer> blank_layer_;
   SurfaceSequence satisfied_sequence_;
 
   SurfaceId required_id_;
   std::set<SurfaceSequence> required_set_;
+  base::Lock lock_;
 };
 
 // TODO(jbauman): Reenable on single thread once http://crbug.com/421923 is
 // fixed.
 MULTI_THREAD_TEST_F(SurfaceLayerSwapPromise);
 
 }  // namespace
 }  // namespace cc