Unified BeginFrame scheduling

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 75 matching lines @@
   DCHECK(IsMainThread());
   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),
+      begin_frame_requested(false),
       started(false),
       manage_tiles_pending(false),
       can_cancel_commit(true),
       defer_commits(false),
       weak_factory(proxy) {}
 
 ThreadProxy::MainThreadOnly::~MainThreadOnly() {}
 
 ThreadProxy::MainThreadOrBlockedMainThread::MainThreadOrBlockedMainThread(
     LayerTreeHost* host)
@@ skipping 1075 matching lines @@
 }
 
 base::TimeDelta ThreadProxy::CommitToActivateDurationEstimate() {
   return impl().timing_history.CommitToActivateDurationEstimate();
 }
 
 void ThreadProxy::DidBeginImplFrameDeadline() {
   impl().layer_tree_host_impl->ResetCurrentFrameTimeForNextFrame();
 }
 
+void ThreadProxy::SendBeginFrame(const BeginFrameArgs& args) {
+  DCHECK(IsImplThread());
+  Proxy::MainThreadTaskRunner()->PostTask(

[brianderson, 2014/08/21 00:14:00]

It would be nice if we could send directly Renderers from the Impl thread but,
since we are moving to SingleThreadProxy Browsers everywhere, this is fine.

[simonhong, 2014/08/21 00:36:49]

Is ChromeOS also a target for SingleThreadProxy?
It is currently set to threaded mode explicitly.

[simonhong, 2014/08/26 08:24:48]

This also removed.

+      FROM_HERE,
+      base::Bind(&ThreadProxy::SendBeginFrameOnMainThread,
+                 main_thread_weak_ptr_,
+                 args));
+}
+
+void ThreadProxy::SendBeginFrameOnMainThread(const BeginFrameArgs& args) {
+  DCHECK(IsMainThread());
+  DCHECK(main().begin_frame_requested);
+  main().begin_frame_requested = false;
+  layer_tree_host()->SendBeginFrame(args);
+}
+
 void ThreadProxy::ReadyToFinalizeTextureUpdates() {
   DCHECK(IsImplThread());
   impl().scheduler->NotifyReadyToCommit();
 }
 
 void ThreadProxy::DidCommitAndDrawFrame() {
   DCHECK(IsMainThread());
   layer_tree_host()->DidCommitAndDrawFrame();
 }
 
@@ skipping 128 matching lines @@
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::CommitPendingOnImplThreadForTesting,
                    impl_thread_weak_ptr_,
                    &commit_pending_request));
     commit_pending_request.completion.Wait();
   }
   return commit_pending_request.commit_pending;
 }
 
+void ThreadProxy::BeginFrameRequested() {
+  DCHECK(IsMainThread());
+  if (main().begin_frame_requested)
+    return;
+
+  main().begin_frame_requested = true;
+
+  TRACE_EVENT0("cc", "ThreadProxy::BeginFrameRequested");
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::BeginFrameRequestedOnImplThread,
+                 impl_thread_weak_ptr_));
+}
+
+void ThreadProxy::BeginFrameRequestedOnImplThread() const {
+  DCHECK(IsImplThread());
+  impl().scheduler->BeginFrameRequested();
+}
+
 void ThreadProxy::CommitPendingOnImplThreadForTesting(
     CommitPendingRequest* request) {
   DCHECK(IsImplThread());
   if (impl().layer_tree_host_impl->output_surface())
     request->commit_pending = impl().scheduler->CommitPending();
   else
     request->commit_pending = false;
   request->completion.Signal();
 }
 
@@ skipping 65 matching lines @@
 
   impl().timing_history.DidActivateSyncTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc