cc: Fix races in LTHDelegatedTest

cc/trees/layer_tree_host_unittest_delegated.cc

 // Copyright 2013 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 "base/bind.h"
 #include "base/location.h"
@@ skipping 452 matching lines @@
   int num_activates_;
   int num_output_surfaces_initialized_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostDelegatedTestInvalidFrameAfterContextLost);
 
 class LayerTreeHostDelegatedTestLayerUsesFrameDamage
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
   LayerTreeHostDelegatedTestLayerUsesFrameDamage()

[danakj, 2015/01/05 19:45:14]

nit: you can just remove this whole constructor i think?

[sohanjg, 2015/01/06 07:25:22]

Done.

-      : LayerTreeHostDelegatedTestCaseSingleDelegatedLayer(),
-        first_draw_for_source_frame_(true) {}
+      : LayerTreeHostDelegatedTestCaseSingleDelegatedLayer() {}
 
   void DidCommit() override {
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         // The first time the layer gets a frame the whole layer should be
         // damaged.
         SetFrameData(
             CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)));
         break;
@@ skipping 88 matching lines @@
         SetFrameData(
             CreateFrameData(gfx::Rect(0, 0, 10, 10), gfx::Rect(4, 0, 1, 1)));
         break;
       case 18:
         // Set another new frame, both layers should be damaged in the same
         // ways.
         SetFrameData(
             CreateFrameData(gfx::Rect(0, 0, 10, 10), gfx::Rect(3, 3, 1, 1)));
         break;
     }
-    first_draw_for_source_frame_ = true;
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
-    if (!first_draw_for_source_frame_)
-      return draw_result;
-

[sohanjg, 2015/01/05 12:39:58]

I think we can assume, PrepareToDraw will happen only after we have committed.
Isnt it ?

[danakj, 2015/01/05 19:45:14]

Yes but this is trying to prevent multiple draws from the same source frame from
being tested against, as followup frames would not have the same damage.

That said, I don't see anything in this test that would cause multiple draws per
source frame, so maybe this was just being overly cautious.

[sohanjg, 2015/01/06 07:25:22]

Acknowledged.

     gfx::Rect damage_rect;
     if (!frame->has_no_damage) {
       damage_rect = frame->render_passes.back()->damage_rect;
     } else {
       // If there is no damage, then we have no render passes to send.
       EXPECT_TRUE(frame->render_passes.empty());
     }
 
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
@@ skipping 57 matching lines @@
         EXPECT_EQ(gfx::Rect(3, 3, 6, 1).ToString(), damage_rect.ToString());
         EndTest();
         break;
     }
 
     return draw_result;
   }
 
  protected:
   scoped_refptr<DelegatedRendererLayer> delegated_copy_;
-  bool first_draw_for_source_frame_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestLayerUsesFrameDamage);
 
 class LayerTreeHostDelegatedTestMergeResources
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
   void BeginTest() override {
     // Push two frames to the delegated renderer layer with no commit between.
 
@@ skipping 1486 matching lines @@
   }
 
   scoped_refptr<DelegatedRendererLayer> delegated_thief_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostDelegatedTestRemoveAndChangeResources);
 
 }  // namespace
 }  // namespace cc