cc: Add more DrawSwapReadbackResult enums

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 <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 1142 matching lines @@
   // DrawLayers() depends on the result of PrepareToDraw(), it is guarded on
   // CanDraw() as well.
 
   bool drawing_for_readback = readback_requested && !!impl().readback_request;
   bool can_do_readback =
       impl().layer_tree_host_impl->renderer()->CanReadPixels();
 
   LayerTreeHostImpl::FrameData frame;
   bool draw_frame = false;
 
-  if (impl().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 = impl().readback_request->rect;
+  if (impl().layer_tree_host_impl->CanDraw()) {
+    if (!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 = impl().readback_request->rect;
 
-    result.draw_result =
-        impl().layer_tree_host_impl->PrepareToDraw(&frame, readback_rect);
-    draw_frame = forced_draw ||
-                 result.draw_result == DrawSwapReadbackResult::DRAW_SUCCESS;
+      result.draw_result =
+          impl().layer_tree_host_impl->PrepareToDraw(&frame, readback_rect);
+      draw_frame = forced_draw ||
+                   result.draw_result == DrawSwapReadbackResult::DRAW_SUCCESS;
+    } else {
+      result.draw_result = DrawSwapReadbackResult::DRAW_ABORTED_CANT_READBACK;
+    }
+  } else {
+    result.draw_result = DrawSwapReadbackResult::DRAW_ABORTED_CANT_DRAW;
   }
 
   if (draw_frame) {
     impl().layer_tree_host_impl->DrawLayers(
         &frame, impl().scheduler->LastBeginImplFrameTime());
     result.draw_result = DrawSwapReadbackResult::DRAW_SUCCESS;
     impl().animations_frozen_until_next_draw = false;
   } else if (result.draw_result ==
                  DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS &&
              !impl().layer_tree_host_impl->settings().impl_side_painting) {
@@ skipping 11 matching lines @@
   }
   impl().layer_tree_host_impl->DidDrawAllLayers(frame);
 
   bool start_ready_animations = draw_frame;
   impl().layer_tree_host_impl->UpdateAnimationState(start_ready_animations);
 
   // Check for a pending CompositeAndReadback.
   if (drawing_for_readback) {
     DCHECK(!swap_requested);
     result.did_readback = false;
-    if (draw_frame && !impl().layer_tree_host_impl->IsContextLost()) {
-      impl().layer_tree_host_impl->Readback(impl().readback_request->pixels,
-                                            impl().readback_request->rect);
-      result.did_readback = true;
+    if (draw_frame) {
+      if (!impl().layer_tree_host_impl->IsContextLost()) {
+        impl().layer_tree_host_impl->Readback(impl().readback_request->pixels,
+                                              impl().readback_request->rect);
+        result.did_readback = true;
+      } else {
+        result.draw_result = DrawSwapReadbackResult::DRAW_ABORTED_CONTEXT_LOST;
+      }
     }
     impl().readback_request->success = result.did_readback;
     impl().readback_request->completion.Signal();
     impl().readback_request = NULL;
   } else if (draw_frame) {
     DCHECK(swap_requested);
     result.did_swap = impl().layer_tree_host_impl->SwapBuffers(frame);
 
     // We don't know if we have incomplete tiles if we didn't actually swap.
     if (result.did_swap) {
       DCHECK(!frame.has_no_damage);
       SetSwapUsedIncompleteTileOnImplThread(frame.contains_incomplete_tile);
     }
   }
 
   // Tell the main thread that the the newly-commited frame was drawn.
   if (impl().next_frame_is_newly_committed_frame) {
     impl().next_frame_is_newly_committed_frame = false;
     Proxy::MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::DidCommitAndDrawFrame, main_thread_weak_ptr_));
   }
 
-  if (draw_frame) {
+  if (draw_frame)
     CheckOutputSurfaceStatusOnImplThread();
 
+  if (result.draw_result == DrawSwapReadbackResult::DRAW_SUCCESS) {
     base::TimeDelta draw_duration = impl().timing_history.DidFinishDrawing();
 
     base::TimeDelta draw_duration_overestimate;
     base::TimeDelta draw_duration_underestimate;
     if (draw_duration > draw_duration_estimate)
       draw_duration_underestimate = draw_duration - draw_duration_estimate;
     else
       draw_duration_overestimate = draw_duration_estimate - draw_duration;
     UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDuration",
                                draw_duration,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMilliseconds(100),
                                50);
     UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationUnderestimate",
                                draw_duration_underestimate,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMilliseconds(100),
                                50);
     UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationOverestimate",
                                draw_duration_overestimate,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMilliseconds(100),
                                50);
   }
 
+  DCHECK_NE(DrawSwapReadbackResult::INVALID_RESULT, result.draw_result);
   return result;
 }
 
 void ThreadProxy::AcquireLayerTextures() {
   // Called when the main thread needs to modify a layer texture that is used
   // directly by the compositor.
   // This method will block until the next compositor draw if there is a
   // previously committed frame that is still undrawn. This is necessary to
   // ensure that the main thread does not monopolize access to the textures.
   DCHECK(IsMainThread());
@@ skipping 32 matching lines @@
 }
 
 void ThreadProxy::ScheduledActionManageTiles() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionManageTiles");
   DCHECK(impl().layer_tree_host_impl->settings().impl_side_painting);
   impl().layer_tree_host_impl->ManageTiles();
 }
 
 DrawSwapReadbackResult ThreadProxy::ScheduledActionDrawAndSwapIfPossible() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionDrawAndSwap");
+
+  // SchedulerStateMachine::DidDrawIfPossibleCompleted isn't set up to
+  // handle DRAW_ABORTED_CANT_DRAW.  Moreover, the scheduler should
+  // never generate this call when it can't draw.
+  DCHECK(impl().layer_tree_host_impl->CanDraw());
+
   bool forced_draw = false;
   bool swap_requested = true;
   bool readback_requested = false;
   return DrawSwapReadbackInternal(
       forced_draw, swap_requested, readback_requested);
 }
 
 DrawSwapReadbackResult ThreadProxy::ScheduledActionDrawAndSwapForced() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionDrawAndSwapForced");
   bool forced_draw = true;
@@ skipping 373 matching lines @@
 
   impl().timing_history.DidActivatePendingTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc