cc: Use BeginFrameArgs

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 "cc/layers/delegated_renderer_layer.h"
 #include "cc/layers/delegated_renderer_layer_client.h"
 #include "cc/layers/delegated_renderer_layer_impl.h"
 #include "cc/output/delegated_frame_data.h"
@@ skipping 137 matching lines @@
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     WebKit::WebGraphicsContext3D* context =
         host_impl->resource_provider()->GraphicsContext3D();
 
     ++num_activates_;
-    switch (num_activates_) {
-      case 2:
+    if (num_activates_ == 2) {
         EXPECT_TRUE(delegated_impl->ChildId());
         EXPECT_FALSE(did_reset_child_id_);
 
         context->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                      GL_INNOCENT_CONTEXT_RESET_ARB);
-        break;
-      case 3:
+    } else if (did_reset_child_id_) {

[enne (OOO), 2013/08/15 19:47:59]

I'm not sure I understand the changes to this test.  How can you get a fourth
activation prior to initializing the renderer? It seems like you'd have to
initialize the renderer and draw the tree from the third activation first.

[brianderson, 2013/08/15 23:05:10]

I made changes to the Scheduler's behavior when we lose the output surface such
that it clears the pipeline by immediately activating the pending tree and
aborting the draw of that activation.  (Then, after output surface
initialization, the Scheduler waits for the first commit to activate before
drawing.)

The way I clear the pipeline ruined the assumptions of this test.

I could have cleared the pipeline as a special function, but I found it easier
to reason about the behavior of the scheduler when it goes through the motions
in corner cases like this rather than adding another branch into it's behavior.

[enne (OOO), 2013/08/16 00:53:22]

Ah, ok.  This is that new aborted draw case.  Thanks for all the patient
explanation.  :)

         EXPECT_TRUE(delegated_impl->ChildId());
-        EXPECT_TRUE(did_reset_child_id_);
         EndTest();
-        break;
     }
   }
 
   virtual void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                            bool success) OVERRIDE {
     EXPECT_TRUE(success);
 
     if (num_activates_ < 2)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
-    EXPECT_EQ(2, num_activates_);
+    EXPECT_LE(2, num_activates_);
     EXPECT_FALSE(delegated_impl->ChildId());
     did_reset_child_id_ = true;
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  protected:
   int num_activates_;
   bool did_reset_child_id_;
 };
@@ skipping 1092 matching lines @@
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestCommitWithoutTake);
 
 }  // namespace
 }  // namespace cc