cc: Toward merging DrawFrame and SwapBuffers in DelegatingRenderer.

cc/test/layer_tree_test.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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 165 matching lines @@
     test_hooks_->WillPrepareTilesOnThread(this);
     return LayerTreeHostImpl::PrepareTiles();
   }
 
   DrawResult PrepareToDraw(FrameData* frame) override {
     test_hooks_->WillPrepareToDrawOnThread(this);
     DrawResult draw_result = LayerTreeHostImpl::PrepareToDraw(frame);
     return test_hooks_->PrepareToDrawOnThread(this, frame, draw_result);
   }
 
-  void DrawLayers(FrameData* frame) override {
-    LayerTreeHostImpl::DrawLayers(frame);
+  bool SwapBuffers(const FrameData& frame) override {
+    bool r = LayerTreeHostImpl::SwapBuffers(frame);

[enne (OOO), 2016/09/07 18:05:52]

I know swap is going to go away, but why does SwapBuffers happen before
DrawLayersOnThread? Shouldn't DrawLayersOnThread happen first to preserve the
old ordering?

[danakj, 2016/09/07 18:28:12]

What's happening is the frame is being given to the output surface inside
"DrawAndSwapCombined" step. So when we tell the test LTHI has done this step, it
has already also been told about the CompositorFrame handed to the output
surface. I double checked and no tests except those I touched in this CL were
both using DrawLayersOnThread and DisplayReceivedCompositorFrame.

[enne (OOO), 2016/09/07 18:38:08]

I figured that this was safe to do in the current state of tests given that
things were green.  But, why?  Why reorder them if you don't have to?  Or do you
have to and I misunderstand?

[danakj, 2016/09/07 18:42:16]

Well, usually TestHooks happen *after* LTHI does some thing, unless it is
prefixed "Will". Before this change, after drawing, swap was not done yet. While
technically still true, swap is being merged into the draw step. So I am here
pretending that draw doesn't exist anymore, only swap (which will be true in
https://codereview.chromium.org/2317953002/ tho i named it back to draw :).
Since the hook is after the "draw and swap combined" step, it will be after
sending the frame to the output surface.

[enne (OOO), 2016/09/07 19:02:58]

Sure, DrawLayersOnThread always happens after DrawLayers.  But it's that the
DisplayReceivedCompositorFrame might happen before DrawLayersOnThread now.  I
guess if they're getting merged then this doesn't matter.  I still don't
understand why you'd reorder them in this patch, since it doesn't seem
necessary, but whatever.

[danakj, 2016/09/07 19:05:46]

Ah, just cuz I wanted to make tests work with that reordering, I had problems
with tests before when merging so I wanted to work thru them in smaller logical
changes.

     test_hooks_->DrawLayersOnThread(this);
+    return r;
   }
 
   void NotifyReadyToActivate() override {
     if (block_notify_ready_to_activate_for_testing_) {
       notify_ready_to_activate_was_blocked_ = true;
     } else {
       LayerTreeHostImpl::NotifyReadyToActivate();
       test_hooks_->NotifyReadyToActivateOnThread(this);
     }
   }
@@ skipping 741 matching lines @@
 }
 
 LayerTreeHost* LayerTreeTest::remote_client_layer_tree_host() {
   DCHECK(IsRemoteTest());
   DCHECK(task_runner_provider()->IsMainThread() ||
          task_runner_provider()->IsMainThreadBlocked());
   return remote_client_layer_tree_host_.get();
 }
 
 }  // namespace cc