Remove CompositeAndReadback from LayerTreeHost(Impl) and the Proxys.

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 31 matching lines @@
   }
 
  private:
   cc::LayerTreeHost* layer_tree_host_;
 };
 
 }  // namespace
 
 namespace cc {
 
-struct ThreadProxy::ReadbackRequest {
-  CompletionEvent completion;
-  bool success;
-  void* pixels;
-  gfx::Rect rect;
-};
-
 struct ThreadProxy::CommitPendingRequest {
   CompletionEvent completion;
   bool commit_pending;
 };
 
 struct ThreadProxy::SchedulerStateRequest {
   CompletionEvent completion;
   scoped_ptr<base::Value> state;
 };
 
@@ skipping 16 matching lines @@
   DCHECK(this->layer_tree_host());
 }
 
 ThreadProxy::MainThreadOnly::MainThreadOnly(ThreadProxy* proxy,
                                             int layer_tree_host_id)
     : layer_tree_host_id(layer_tree_host_id),
       animate_requested(false),
       commit_requested(false),
       commit_request_sent_to_impl_thread(false),
       started(false),
-      in_composite_and_readback(false),
       manage_tiles_pending(false),
       can_cancel_commit(true),
       defer_commits(false),
       weak_factory(proxy) {}
 
 ThreadProxy::MainThreadOnly::~MainThreadOnly() {}
 
 ThreadProxy::MainThreadOrBlockedMainThread::MainThreadOrBlockedMainThread(
     LayerTreeHost* host)
     : layer_tree_host(host),
       commit_waits_for_activation(false),
       main_thread_inside_commit(false) {}
 
 ThreadProxy::MainThreadOrBlockedMainThread::~MainThreadOrBlockedMainThread() {}
 
 PrioritizedResourceManager*
 ThreadProxy::MainThreadOrBlockedMainThread::contents_texture_manager() {
   return layer_tree_host->contents_texture_manager();
 }
 
 ThreadProxy::CompositorThreadOnly::CompositorThreadOnly(ThreadProxy* proxy,
                                                         int layer_tree_host_id)
     : layer_tree_host_id(layer_tree_host_id),
       contents_texture_manager(NULL),
-      begin_main_frame_sent_completion_event(NULL),
-      readback_request(NULL),
       commit_completion_event(NULL),
       completion_event_for_commit_held_on_tree_activation(NULL),
       next_frame_is_newly_committed_frame(false),
       inside_draw(false),
       input_throttled_until_commit(false),
       animations_frozen_until_next_draw(false),
       did_commit_after_animating(false),
       renew_tree_priority_pending(false),
       weak_factory(proxy) {
 }
 
 ThreadProxy::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 ThreadProxy::~ThreadProxy() {
   TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(!main().started);
 }
 
-bool ThreadProxy::CompositeAndReadback(void* pixels, const gfx::Rect& rect) {
-  TRACE_EVENT0("cc", "ThreadProxy::CompositeAndReadback");
-  DCHECK(IsMainThread());
-  DCHECK(layer_tree_host());
-
-  if (main().defer_commits) {
-    TRACE_EVENT0("cc", "CompositeAndReadback_DeferCommit");
-    return false;
-  }
-
-  if (!layer_tree_host()->InitializeOutputSurfaceIfNeeded()) {
-    TRACE_EVENT_INSTANT0("cc",
-                         "CompositeAndReadback_EarlyOut_LR_Uninitialized",
-                         TRACE_EVENT_SCOPE_THREAD);
-    return false;
-  }
-
-  // Perform a synchronous commit with an associated readback.
-  ReadbackRequest request;
-  request.rect = rect;
-  request.pixels = pixels;
-  {
-    DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-    CompletionEvent begin_main_frame_sent_completion;
-    Proxy::ImplThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ThreadProxy::ForceCommitForReadbackOnImplThread,
-                   impl_thread_weak_ptr_,
-                   &begin_main_frame_sent_completion,
-                   &request));
-    begin_main_frame_sent_completion.Wait();
-  }
-
-  main().in_composite_and_readback = true;
-  // This is the forced commit.
-  // Note: The Impl thread also queues a separate BeginMainFrame on the
-  // main thread, which will be called after this CompositeAndReadback
-  // completes, to replace the forced commit.
-  BeginMainFrame(scoped_ptr<BeginMainFrameAndCommitState>());
-  main().in_composite_and_readback = false;
-
-  // Composite and readback requires a second commit to undo any changes
-  // that it made.
-  main().can_cancel_commit = false;
-
-  request.completion.Wait();
-  return request.success;
-}
-
-void ThreadProxy::ForceCommitForReadbackOnImplThread(
-    CompletionEvent* begin_main_frame_sent_completion,
-    ReadbackRequest* request) {
-  TRACE_EVENT0("cc", "ThreadProxy::ForceCommitForReadbackOnImplThread");
-  DCHECK(IsImplThread());
-  DCHECK(!impl().begin_main_frame_sent_completion_event);
-  DCHECK(!impl().readback_request);
-
-  if (!impl().layer_tree_host_impl) {
-    begin_main_frame_sent_completion->Signal();
-    request->success = false;
-    request->completion.Signal();
-    return;
-  }
-
-  impl().readback_request = request;
-
-  impl().scheduler->SetNeedsForcedCommitForReadback();
-  if (impl().scheduler->IsBeginMainFrameSent()) {
-    begin_main_frame_sent_completion->Signal();
-    return;
-  }
-
-  impl().begin_main_frame_sent_completion_event =
-      begin_main_frame_sent_completion;
-}
-
 void ThreadProxy::FinishAllRendering() {
   DCHECK(Proxy::IsMainThread());
   DCHECK(!main().defer_commits);
 
   // Make sure all GL drawing is finished on the impl thread.
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::FinishAllRenderingOnImplThread,
@@ skipping 553 matching lines @@
       impl().layer_tree_host_impl->memory_allocation_priority_cutoff();
   begin_main_frame_state->evicted_ui_resources =
       impl().layer_tree_host_impl->EvictedUIResourcesExist();
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::BeginMainFrame,
                  main_thread_weak_ptr_,
                  base::Passed(&begin_main_frame_state)));
   devtools_instrumentation::DidRequestMainThreadFrame(
       impl().layer_tree_host_id);
-  if (impl().begin_main_frame_sent_completion_event) {
-    impl().begin_main_frame_sent_completion_event->Signal();
-    impl().begin_main_frame_sent_completion_event = NULL;
-  }
   impl().timing_history.DidBeginMainFrame();
 }
 
 void ThreadProxy::BeginMainFrame(
     scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) {
   TRACE_EVENT0("cc", "ThreadProxy::BeginMainFrame");
   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("cc.BeginMainFrame");
   DCHECK(IsMainThread());
 
   if (!layer_tree_host())
@@ skipping 18 matching lines @@
   // the paint, main().commit_requested will be set to false to allow new commit
   // requests to be scheduled.
   main().commit_requested = true;
   main().commit_request_sent_to_impl_thread = true;
 
   // On the other hand, the AnimationRequested flag needs to be cleared
   // here so that any animation requests generated by the apply or animate
   // callbacks will trigger another frame.
   main().animate_requested = false;
 
-  if (!main().in_composite_and_readback && !layer_tree_host()->visible()) {
+  if (!layer_tree_host()->visible()) {
     main().commit_requested = false;
     main().commit_request_sent_to_impl_thread = false;
 
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NotVisible", TRACE_EVENT_SCOPE_THREAD);
     bool did_handle = false;
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::BeginMainFrameAbortedOnImplThread,
                    impl_thread_weak_ptr_,
                    did_handle));
     return;
   }
 
-  if (begin_main_frame_state) {
-    layer_tree_host()->ApplyScrollAndScale(
-        *begin_main_frame_state->scroll_info);
-  }
+  layer_tree_host()->ApplyScrollAndScale(*begin_main_frame_state->scroll_info);
 
   layer_tree_host()->WillBeginMainFrame();
 
-  if (begin_main_frame_state) {
-    layer_tree_host()->UpdateClientAnimations(
-        begin_main_frame_state->monotonic_frame_begin_time);
-    layer_tree_host()->AnimateLayers(
-        begin_main_frame_state->monotonic_frame_begin_time);
-    blocked_main().last_monotonic_frame_begin_time =
-        begin_main_frame_state->monotonic_frame_begin_time;
-  }
+  layer_tree_host()->UpdateClientAnimations(
+      begin_main_frame_state->monotonic_frame_begin_time);
+  layer_tree_host()->AnimateLayers(
+      begin_main_frame_state->monotonic_frame_begin_time);
+  blocked_main().last_monotonic_frame_begin_time =
+      begin_main_frame_state->monotonic_frame_begin_time;
 
   // Unlink any backings that the impl thread has evicted, so that we know to
   // re-paint them in UpdateLayers.
   if (blocked_main().contents_texture_manager()) {
     blocked_main().contents_texture_manager()->UnlinkAndClearEvictedBackings();
 
-    if (begin_main_frame_state) {
-      blocked_main().contents_texture_manager()->SetMaxMemoryLimitBytes(
-          begin_main_frame_state->memory_allocation_limit_bytes);
-      blocked_main().contents_texture_manager()->SetExternalPriorityCutoff(
-          begin_main_frame_state->memory_allocation_priority_cutoff);
-    }
+    blocked_main().contents_texture_manager()->SetMaxMemoryLimitBytes(
+        begin_main_frame_state->memory_allocation_limit_bytes);
+    blocked_main().contents_texture_manager()->SetExternalPriorityCutoff(
+        begin_main_frame_state->memory_allocation_priority_cutoff);
   }
 
   // Recreate all UI resources if there were evicted UI resources when the impl
   // thread initiated the commit.
-  bool evicted_ui_resources = begin_main_frame_state
-                                  ? begin_main_frame_state->evicted_ui_resources
-                                  : false;
-  if (evicted_ui_resources)
+  if (begin_main_frame_state->evicted_ui_resources)
     layer_tree_host()->RecreateUIResources();
 
   layer_tree_host()->Layout();
   TRACE_EVENT_SYNTHETIC_DELAY_END("cc.BeginMainFrame");
 
   // Clear the commit flag after updating animations and layout here --- objects
   // that only layout when painted will trigger another SetNeedsCommit inside
   // UpdateLayers.
   main().commit_requested = false;
   main().commit_request_sent_to_impl_thread = false;
-  bool can_cancel_this_commit = main().can_cancel_commit &&
-                                !main().in_composite_and_readback &&
-                                !evicted_ui_resources;
+  bool can_cancel_this_commit =
+      main().can_cancel_commit && !begin_main_frame_state->evicted_ui_resources;
   main().can_cancel_commit = true;
 
   scoped_ptr<ResourceUpdateQueue> queue =
       make_scoped_ptr(new ResourceUpdateQueue);
 
   bool updated = layer_tree_host()->UpdateLayers(queue.get());
 
   layer_tree_host()->WillCommit();
 
   // Before calling animate, we set main().animate_requested to false. If it is
@@ skipping 204 matching lines @@
 
 void ThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionBeginOutputSurfaceCreation");
   DCHECK(IsImplThread());
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::CreateAndInitializeOutputSurface,
                  main_thread_weak_ptr_));
 }
 
-DrawSwapReadbackResult ThreadProxy::DrawSwapReadbackInternal(
-    bool forced_draw,
-    bool swap_requested,
-    bool readback_requested) {
+DrawSwapReadbackResult ThreadProxy::DrawSwapInternal(bool forced_draw) {
   TRACE_EVENT_SYNTHETIC_DELAY("cc.DrawAndSwap");
   DrawSwapReadbackResult result;
 
   DCHECK(IsImplThread());
   DCHECK(impl().layer_tree_host_impl.get());
 
   impl().timing_history.DidStartDrawing();
   base::TimeDelta draw_duration_estimate = DrawDurationEstimate();
   base::AutoReset<bool> mark_inside(&impl().inside_draw, true);
 
   if (impl().did_commit_after_animating) {
     impl().layer_tree_host_impl->Animate(impl().animation_time);
     impl().did_commit_after_animating = false;
   }
 
   if (impl().layer_tree_host_impl->pending_tree())
     impl().layer_tree_host_impl->pending_tree()->UpdateDrawProperties();
 
   // This method is called on a forced draw, regardless of whether we are able
   // to produce a frame, as the calling site on main thread is blocked until its
   // request completes, and we signal completion here. If CanDraw() is false, we
   // will indicate success=false to the caller, but we must still signal
   // completion to avoid deadlock.
 
   // We guard PrepareToDraw() with CanDraw() because it always returns a valid
   // frame, so can only be used when such a frame is possible. Since
   // 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()) {
-    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;
-    } else {
-      result.draw_result = DrawSwapReadbackResult::DRAW_ABORTED_CANT_READBACK;
-    }
+    result.draw_result = impl().layer_tree_host_impl->PrepareToDraw(&frame);
+    draw_frame = forced_draw ||
+                 result.draw_result == DrawSwapReadbackResult::DRAW_SUCCESS;
   } 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) {
     // Without impl-side painting, the animated layer that is checkerboarding
     // will continue to checkerboard until the next commit. If this layer
     // continues to move during the commit, it may continue to checkerboard
     // after the commit since the region rasterized during the commit will not
     // match the region that is currently visible; eventually this
     // checkerboarding will be displayed when we force a draw. To avoid this,
     // we freeze animations until we successfully draw.
     impl().animations_frozen_until_next_draw = true;
   } else {
     DCHECK_NE(DrawSwapReadbackResult::DRAW_SUCCESS, result.draw_result);
   }
   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) {
-      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);
+  if (draw_frame) {
     result.did_request_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_request_swap) {
       DCHECK(!frame.has_no_damage);
       SetSwapUsedIncompleteTileOnImplThread(frame.contains_incomplete_tile);
     }
   }
 
   // Tell the main thread that the the newly-commited frame was drawn.
@@ skipping 45 matching lines @@
 
 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);
+  return DrawSwapInternal(forced_draw);
 }
 
 DrawSwapReadbackResult ThreadProxy::ScheduledActionDrawAndSwapForced() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionDrawAndSwapForced");
   bool forced_draw = true;
-  bool swap_requested = true;
-  bool readback_requested = false;
-  return DrawSwapReadbackInternal(
-      forced_draw, swap_requested, readback_requested);
+  return DrawSwapInternal(forced_draw);
 }
 
 DrawSwapReadbackResult ThreadProxy::ScheduledActionDrawAndReadback() {
-  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionDrawAndReadback");
-  bool forced_draw = true;
-  bool swap_requested = false;
-  bool readback_requested = true;
-  return DrawSwapReadbackInternal(
-      forced_draw, swap_requested, readback_requested);
+  NOTREACHED();
+  return DrawSwapReadbackResult();
 }
 
 void ThreadProxy::DidAnticipatedDrawTimeChange(base::TimeTicks time) {
   if (impl().current_resource_update_controller)
     impl().current_resource_update_controller->PerformMoreUpdates(time);
 }
 
 base::TimeDelta ThreadProxy::DrawDurationEstimate() {
   return impl().timing_history.DrawDurationEstimate();
 }
@@ skipping 338 matching lines @@
 
   impl().timing_history.DidActivatePendingTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc