cc: Control defer_commits logic by Scheduler

cc/trees/single_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/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/context_provider.h"
@@ skipping 26 matching lines @@
     LayerTreeHostSingleThreadClient* client,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_ptr<BeginFrameSource> external_begin_frame_source)
     : Proxy(main_task_runner, NULL),
       layer_tree_host_(layer_tree_host),
       client_(client),
       timing_history_(layer_tree_host->rendering_stats_instrumentation()),
       next_frame_is_newly_committed_frame_(false),
       inside_draw_(false),
       defer_commits_(false),
-      commit_was_deferred_(false),
       commit_requested_(false),
       inside_synchronous_composite_(false),
       output_surface_creation_requested_(false),
       external_begin_frame_source_(external_begin_frame_source.Pass()),
       weak_factory_(this) {
   TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy");
   DCHECK(Proxy::IsMainThread());
   DCHECK(layer_tree_host);
 }
 
@@ skipping 235 matching lines @@
     return;
   if (defer_commits_ == defer_commits)
     return;
 
   if (defer_commits)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "SingleThreadProxy::SetDeferCommits", this);
   else
     TRACE_EVENT_ASYNC_END0("cc", "SingleThreadProxy::SetDeferCommits", this);
 
   defer_commits_ = defer_commits;
-  if (!defer_commits_ && commit_was_deferred_) {
-    commit_was_deferred_ = false;
-    BeginMainFrame();
-  }
+  scheduler_on_impl_thread_->SetDeferCommits(defer_commits);
+
+  // When defer commit is turned off, we should start new BeginMainFrame to
+  // handle previous deferred BeginMainFrame.
+  if (!defer_commits)
+    SetNeedsCommit();
 }
 
 bool SingleThreadProxy::CommitRequested() const {
   DCHECK(Proxy::IsMainThread());
   return commit_requested_;
 }
 
 bool SingleThreadProxy::BeginMainFrameRequested() const {
   DCHECK(Proxy::IsMainThread());
   // If there is no scheduler, then there can be no pending begin frame,
@@ skipping 336 matching lines @@
   // ThreadProxy::SetNeedsCommit where SetNeedsCommit will not cause a
   // synchronous commit.
   MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&SingleThreadProxy::BeginMainFrame,
                  weak_factory_.GetWeakPtr()));
 }
 
 void SingleThreadProxy::BeginMainFrame() {
   if (defer_commits_) {
-    DCHECK(!commit_was_deferred_);
-    commit_was_deferred_ = true;
-    layer_tree_host_->DidDeferCommit();
+    TRACE_EVENT_INSTANT0("cc", "EarlyOut_DeferCommits",
+                         TRACE_EVENT_SCOPE_THREAD);
+    BeginMainFrameAbortedOnImplThread();
     return;
   }
 
   // This checker assumes NotifyReadyToCommit in this stack causes a synchronous
   // commit.
   ScopedAbortRemainingSwapPromises swap_promise_checker(layer_tree_host_);
 
   if (!layer_tree_host_->visible()) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NotVisible", TRACE_EVENT_SCOPE_THREAD);
     BeginMainFrameAbortedOnImplThread();
@@ skipping 119 matching lines @@
 
 void SingleThreadProxy::DidBeginImplFrameDeadline() {
   layer_tree_host_impl_->ResetCurrentBeginFrameArgsForNextFrame();
 }
 
 void SingleThreadProxy::SendBeginFramesToChildren(const BeginFrameArgs& args) {
   layer_tree_host_->SendBeginFramesToChildren(args);
 }
 
 }  // namespace cc