cc: Make PrepareToDraw return an enum for why it aborts

cc/trees/thread_proxy.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/trees/thread_proxy.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 1070 matching lines @@
       base::Bind(&ThreadProxy::CreateAndInitializeOutputSurface,
                  main_thread_weak_ptr_));
 }
 
 DrawSwapReadbackResult ThreadProxy::DrawSwapReadbackInternal(
     bool forced_draw,
     bool swap_requested,
     bool readback_requested) {
   TRACE_EVENT_SYNTHETIC_DELAY("cc.DrawAndSwap");
   DrawSwapReadbackResult result;
-  result.did_draw = false;
   result.did_swap = false;
   result.did_readback = false;
+
   DCHECK(IsImplThread());
   DCHECK(layer_tree_host_impl_.get());
-  if (!layer_tree_host_impl_)
+  if (!layer_tree_host_impl_) {
+    result.draw_result = DrawSwapReadbackResult::DRAW_ABORTED_NO_TREE;
     return result;
+  }
 
   DCHECK(layer_tree_host_impl_->renderer());
-  if (!layer_tree_host_impl_->renderer())
+  if (!layer_tree_host_impl_->renderer()) {
+    result.draw_result = DrawSwapReadbackResult::DRAW_ABORTED_NO_RENDERER;
     return result;
+  }
 
   base::TimeTicks start_time = base::TimeTicks::HighResNow();
   base::TimeDelta draw_duration_estimate = DrawDurationEstimate();
   base::AutoReset<bool> mark_inside(&inside_draw_, true);
 
   // Advance our animations.
   base::TimeTicks monotonic_time =
       layer_tree_host_impl_->CurrentFrameTimeTicks();
   base::Time wall_clock_time = layer_tree_host_impl_->CurrentFrameTime();
 
@@ skipping 20 matching lines @@
   LayerTreeHostImpl::FrameData frame;
   bool draw_frame = false;
 
   if (layer_tree_host_impl_->CanDraw() &&
       (!drawing_for_readback || can_do_readback)) {
     // If it is for a readback, make sure we draw the portion being read back.
     gfx::Rect readback_rect;
     if (drawing_for_readback)
       readback_rect = readback_request_on_impl_thread_->rect;
 
-    if (layer_tree_host_impl_->PrepareToDraw(&frame, readback_rect) ||
-        forced_draw)
-      draw_frame = true;
+    result.draw_result =
+        layer_tree_host_impl_->PrepareToDraw(&frame, readback_rect);

[brianderson, 2014/01/29 01:31:22]

It feels funny to have PrepareToDraw return DID_DRAW when the draw hasn't
occurred yet, but I don't see how to make it any better without needlessly
complicating the code.

[enne (OOO), 2014/01/29 01:40:19]

Yeah, I thought that too.  I could change DID_DRAW to DRAW_SUCCESS, and then it
might make sense before drawing and after drawing?

[danakj, 2014/01/29 01:42:35]

WILL_DRAW?

[enne (OOO), 2014/01/29 01:47:20]

WILL_DRAW doesn't make sense as a result after DrawAndSwapIfPossible.  This
seems like the reverse of why DID_DRAW doesn't make sense for PrepareToDraw.

+    draw_frame =
+        forced_draw || result.draw_result == DrawSwapReadbackResult::DID_DRAW;
   }
 
   if (draw_frame) {
     layer_tree_host_impl_->DrawLayers(
         &frame,
         scheduler_on_impl_thread_->LastBeginImplFrameTime());
-    result.did_draw = true;
+    result.draw_result = DrawSwapReadbackResult::DID_DRAW;
+  } else {
+    DCHECK_NE(DrawSwapReadbackResult::DID_DRAW, result.draw_result);
   }
   layer_tree_host_impl_->DidDrawAllLayers(frame);
 
   bool start_ready_animations = draw_frame;
   layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
 
   // Check for a pending CompositeAndReadback.
   if (drawing_for_readback) {
     DCHECK(!swap_requested);
     result.did_readback = false;
@@ skipping 491 matching lines @@
   commit_to_activate_duration_history_.InsertSample(
       base::TimeTicks::HighResNow() - commit_complete_time_);
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   scheduler_on_impl_thread_->DidManageTiles();
 }
 
 }  // namespace cc