Add basic framework for splitting thread proxy.

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 53 matching lines @@
       main_thread_only_vars_unsafe_(this, layer_tree_host->id()),
       main_thread_or_blocked_vars_unsafe_(layer_tree_host),
       compositor_thread_vars_unsafe_(
           this,
           layer_tree_host->id(),
           layer_tree_host->rendering_stats_instrumentation(),
           external_begin_frame_source.Pass()) {
   TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(this->layer_tree_host());
+  // TODO(khushalsagar): Move this to LayerTreeHost#InitializeThreaded once
+  // ThreadProxy is split. LayerTreeHost creates the channel and passes it to
+  // ProxyMain#SetChannel.
+  SetChannel(ThreadedChannel::Create(this, main_task_runner, impl_task_runner));
 }
 
 ThreadProxy::MainThreadOnly::MainThreadOnly(ThreadProxy* proxy,
                                             int layer_tree_host_id)
     : layer_tree_host_id(layer_tree_host_id),
       max_requested_pipeline_stage(NO_PIPELINE_STAGE),
       current_pipeline_stage(NO_PIPELINE_STAGE),
       final_pipeline_stage(NO_PIPELINE_STAGE),
       started(false),
       prepare_tiles_pending(false),
@@ skipping 32 matching lines @@
 }
 
 ThreadProxy::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 ThreadProxy::~ThreadProxy() {
   TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(!main().started);
 }
 
+void ThreadProxy::SetChannel(scoped_ptr<ThreadedChannel> threaded_channel) {
+  threaded_channel_ = threaded_channel.Pass();
+  main().channel_main = threaded_channel_.get();
+}
+
 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,
                  impl_thread_weak_ptr_,
                  &completion));
   completion.Wait();
 }
 
 bool ThreadProxy::IsStarted() const {
   DCHECK(Proxy::IsMainThread());
   return main().started;
 }
 
 bool ThreadProxy::CommitToActiveTree() const {
   // With ThreadProxy, we use a pending tree and activate it once it's ready to
   // draw to allow input to modify the active tree and draw during raster.
   return false;
 }
 
 void ThreadProxy::SetLayerTreeHostClientReady() {
   TRACE_EVENT0("cc", "ThreadProxy::SetLayerTreeHostClientReady");
-  Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::SetLayerTreeHostClientReadyOnImplThread,
-                 impl_thread_weak_ptr_));
+  main().channel_main->SetLayerTreeHostClientReadyOnImpl();
 }
 
-void ThreadProxy::SetLayerTreeHostClientReadyOnImplThread() {
+void ThreadProxy::SetLayerTreeHostClientReadyOnImpl() {
   TRACE_EVENT0("cc", "ThreadProxy::SetLayerTreeHostClientReadyOnImplThread");
   impl().scheduler->SetCanStart();
 }
 
 void ThreadProxy::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "ThreadProxy::SetVisible", "visible", visible);
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
   CompletionEvent completion;
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::SetVisibleOnImplThread,
                  impl_thread_weak_ptr_,
                  &completion,
                  visible));
   completion.Wait();
 }
 
 void ThreadProxy::SetVisibleOnImplThread(CompletionEvent* completion,
                                          bool visible) {
   TRACE_EVENT1("cc", "ThreadProxy::SetVisibleOnImplThread", "visible", visible);
   impl().layer_tree_host_impl->SetVisible(visible);
   impl().scheduler->SetVisible(visible);
   completion->Signal();
 }
 
 void ThreadProxy::SetThrottleFrameProduction(bool throttle) {
   TRACE_EVENT1("cc", "ThreadProxy::SetThrottleFrameProduction", "throttle",
                throttle);
-  Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::SetThrottleFrameProductionOnImplThread,
-                 impl_thread_weak_ptr_, throttle));
+  main().channel_main->SetThrottleFrameProductionOnImpl(throttle);
 }
 
-void ThreadProxy::SetThrottleFrameProductionOnImplThread(bool throttle) {
+void ThreadProxy::SetThrottleFrameProductionOnImpl(bool throttle) {
   TRACE_EVENT1("cc", "ThreadProxy::SetThrottleFrameProductionOnImplThread",
                "throttle", throttle);
   impl().scheduler->SetThrottleFrameProduction(throttle);
 }
 
 void ThreadProxy::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurface");
   DCHECK(IsMainThread());
   layer_tree_host()->DidLoseOutputSurface();
 }
@@ skipping 141 matching lines @@
 
 void ThreadProxy::DidSwapBuffersOnImplThread() {
   impl().scheduler->DidSwapBuffers();
 }
 
 void ThreadProxy::DidSwapBuffersCompleteOnImplThread() {
   TRACE_EVENT0("cc,benchmark",
                "ThreadProxy::DidSwapBuffersCompleteOnImplThread");
   DCHECK(IsImplThread());
   impl().scheduler->DidSwapBuffersComplete();
-  Proxy::MainThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::DidCompleteSwapBuffers, main_thread_weak_ptr_));
+  impl().channel_impl->DidCompleteSwapBuffers();
 }
 
 void ThreadProxy::WillBeginImplFrame(const BeginFrameArgs& args) {
   impl().layer_tree_host_impl->WillBeginImplFrame(args);
   if (impl().last_processed_begin_main_frame_args.IsValid()) {
     // Last processed begin main frame args records the frame args that we sent
     // to the main thread for the last frame that we've processed. If that is
     // set, that means the current frame is one past the frame in which we've
     // finished the processing.
     impl().layer_tree_host_impl->RecordMainFrameTiming(
@@ skipping 638 matching lines @@
 
 void ThreadProxy::SetAnimationEvents(scoped_ptr<AnimationEventsVector> events) {
   TRACE_EVENT0("cc", "ThreadProxy::SetAnimationEvents");
   DCHECK(IsMainThread());
   layer_tree_host()->SetAnimationEvents(events.Pass());
 }
 
 void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeImplOnImplThread");
   DCHECK(IsImplThread());
+
+  // TODO(khushalsagar): ThreadedChannel will create ProxyImpl here and pass a
+  // reference to itself.
+  impl().channel_impl = threaded_channel_.get();
+
   impl().layer_tree_host_impl =
       layer_tree_host()->CreateLayerTreeHostImpl(this);
 
   SchedulerSettings scheduler_settings(
       layer_tree_host()->settings().ToSchedulerSettings());
 
   scoped_ptr<CompositorTimingHistory> compositor_timing_history(
       new CompositorTimingHistory(CompositorTimingHistory::RENDERER_UMA,
                                   impl().rendering_stats_instrumentation));
 
@@ skipping 213 matching lines @@
 }
 
 void ThreadProxy::PostFrameTimingEvents(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   DCHECK(IsMainThread());
   layer_tree_host()->RecordFrameTimingEvents(composite_events.Pass(),
                                              main_frame_events.Pass());
 }
 
+base::WeakPtr<ProxyMain> ThreadProxy::GetMainWeakPtr() {
+  return main_thread_weak_ptr_;
+}
+
+base::WeakPtr<ProxyImpl> ThreadProxy::GetImplWeakPtr() {
+  return impl_thread_weak_ptr_;
+}
+
 }  // namespace cc