cc: Don't draw and swap if the frame will not change.

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 "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
@@ skipping 876 matching lines @@
   // 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.
 
+  // If it is a forced draw, make sure we do a draw and swap.
+  gfx::Rect readback_rect;
+  if (readback_request_on_impl_thread_)
+    readback_rect = readback_request_on_impl_thread_->rect;
+
   LayerTreeHostImpl::FrameData frame;
   bool draw_frame = false;
   bool start_ready_animations = true;
 
   if (layer_tree_host_impl_->CanDraw()) {
     // Do not start animations if we skip drawing the frame to avoid
     // checkerboarding.
-    if (layer_tree_host_impl_->PrepareToDraw(&frame) || forced_draw)
+    if (layer_tree_host_impl_->PrepareToDraw(&frame, readback_rect) ||
+        forced_draw)
       draw_frame = true;
     else
       start_ready_animations = false;
   }
 
   if (draw_frame) {
     layer_tree_host_impl_->DrawLayers(
         &frame,
         scheduler_on_impl_thread_->LastVSyncTime());
     result.did_draw = true;
@@ skipping 17 matching lines @@
     readback_request_on_impl_thread_->success = false;
     if (draw_frame) {
       layer_tree_host_impl_->Readback(readback_request_on_impl_thread_->pixels,
                                       readback_request_on_impl_thread_->rect);
       readback_request_on_impl_thread_->success =
           !layer_tree_host_impl_->IsContextLost();
     }
     readback_request_on_impl_thread_->completion.Signal();
     readback_request_on_impl_thread_ = NULL;
   } else if (draw_frame) {
-    result.did_swap = layer_tree_host_impl_->SwapBuffers();
+    result.did_swap = layer_tree_host_impl_->SwapBuffers(frame);
 
     if (frame.contains_incomplete_tile)
       DidSwapUseIncompleteTileOnImplThread();
   }
 
   // Tell the main thread that the the newly-commited frame was drawn.
   if (next_frame_is_newly_committed_frame_on_impl_thread_) {
     next_frame_is_newly_committed_frame_on_impl_thread_ = false;
     Proxy::MainThread()->PostTask(
         base::Bind(&ThreadProxy::DidCommitAndDrawFrame, main_thread_weak_ptr_));
@@ skipping 377 matching lines @@
       base::Bind(&ThreadProxy::StartScrollbarAnimationOnImplThread,
                  impl_thread_weak_ptr_),
       delay);
 }
 
 void ThreadProxy::StartScrollbarAnimationOnImplThread() {
   layer_tree_host_impl_->StartScrollbarAnimation(base::TimeTicks::Now());
 }
 
 }  // namespace cc