Split ThreadProxy methods to ProxyMain and ProxyImpl.

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 121 matching lines @@
   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));
+  main().channel_main->FinishAllRenderingOnImpl(&completion);

[vmpstr, 2015/10/15 20:25:04]

It's a bit awkward for me that channel_main refers to the channel that
communicates with the impl side. Is "main" referring to where the channel is
located, but not where it's communicating to?

[Khushal, 2015/10/15 23:45:51]

Since the class is split into the main and impl components, each side needs an
interface to communicate with the other side. The current naming scheme is such
that ChannelMain is the interface and its implementation is located on the main
side. For Blimp, a RemoteChannelMain will implement this that lives on the
server.

We can rename it channel_main_to_impl if that makes it clearer?

[vmpstr, 2015/10/17 00:05:51]

I'm not sure, that's also very verbose. I guess we can keep it as is for now,
but if you think of something better that would be good :P

I'm almost tempted to say that main().channel->Foo(); is better than
main().channel_main->Foo(). But I think that's not verbose enough.

[Khushal, 2015/10/17 02:02:48]

main() wouldn't be there when ProxyMain comes. Then it would just be
channel_main_->Foo(). We can may be name the variable channel_ then?
Can't think of anything better right now. :(

   completion.Wait();

[vmpstr, 2015/10/15 20:25:04]

The typical thing to do is create a completion / post task / wait.

What's the story for when this isn't a post task? Should the parameter to the
function be something like a bool wait_until_done; and it can create the
completion in the channel? Or do you think it's better to keep this outside?

[Khushal, 2015/10/15 23:45:50]

Right now completion events make it explicit to methods on both side that the
main thread is blocked for this operation. And in case of the commit, since it
is done asynchronously on the impl side, it holds on to the event to decide when
to release the main thread. To hide the completion events completely inside the
channel, we'll have to move some of that logic inside the channel.

Would it be better if we had CompletionEvent as an interface instead.

CompletionEvent {
  Wait();
  Signal();
}
And the current completion event can be the implementation of this as
ThreadedCompletionEvent.

We pass the wait_until_done param to a function on ChannelMain to make a
synchronous call, which for ThreadedChannel will create this event and pass it
to ProxyImpl so the logic there remains same as now.

For Blimp we just make the network call. It shouldn't need to block the main
thread on the server since any state needed in the call at that point is
serialized and sent to the client.
The completion event implementation sent to ProxyImpl on the client will
probably just have a callback that clears any local state after an operation.
For instance, dropping the commit proto/recycling the local LTH object after the
impl side has committed the state. Is there anything I could be missing here?

[vmpstr, 2015/10/17 00:05:51]

Specifically what logic are you referring to? I mostly see

CompletionEvent event;
channel->Foo(&event);
event.Wait();

On the other end this maps to
Foo(CompletionEvent* event) {
 ...
 event->Signal();
}

If the logic is more complicated than that, we can keep it outside or whatever.
But if it's exactly this pattern over and over again, I would say that the
channel itself can do this, no?
All the more reason here to move the details of completion events into the
channel, right? If they remain outside, then who would signal the completion?
The channel, right?

[Khushal, 2015/10/17 02:02:48]

I like the idea of keeping it completely in the channel. Something like:
channel->Foo(bool wait_until_done);

And in the channel,
Foo(bool wait_until_done) {
  CompletionEvent event;
  TaskRunner->PostTask(FROM_HERE,
      base::Bind(&ThreadedChannel::DoBlockingFoo,
                 channel_weak_ptr_,
                 &completion);
  event.Wait();
}

DoBlockingFoo(CompletionEvent* event) {
  proxy_impl_->Foo();
  event->Signal();
}

With the commit, thread proxy holds on to the event to unblock it after the
commit is finished/after the sync tree is activated.
We could add callbacks for to the channel to move this logic into the channel?

channel_impl->DidActivateSyncTree() which would unblock the main thread?

 }
 
 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::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));
+  main().channel_main->SetVisibleOnImpl(&completion, visible);
   completion.Wait();
 }
 
-void ThreadProxy::SetVisibleOnImplThread(CompletionEvent* completion,
-                                         bool visible) {
+void ThreadProxy::SetVisibleOnImpl(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);
   main().channel_main->SetThrottleFrameProductionOnImpl(throttle);
@@ skipping 10 matching lines @@
   DCHECK(IsMainThread());
   layer_tree_host()->DidLoseOutputSurface();
 }
 
 void ThreadProxy::RequestNewOutputSurface() {
   DCHECK(IsMainThread());
   layer_tree_host()->RequestNewOutputSurface();
 }
 
 void ThreadProxy::SetOutputSurface(OutputSurface* output_surface) {
-  Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&ThreadProxy::InitializeOutputSurfaceOnImplThread,
-                            impl_thread_weak_ptr_, output_surface));
+  main().channel_main->InitializeOutputSurfaceOnImpl(output_surface);
 }
 
 void ThreadProxy::ReleaseOutputSurface() {
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host()->output_surface_lost());
 
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
-  Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&ThreadProxy::ReleaseOutputSurfaceOnImplThread,
-                            impl_thread_weak_ptr_, &completion));
+  main().channel_main->ReleaseOutputSurfaceOnImpl(&completion);
   completion.Wait();
 }
 
 void ThreadProxy::DidInitializeOutputSurface(
     bool success,
     const RendererCapabilities& capabilities) {
   TRACE_EVENT0("cc", "ThreadProxy::DidInitializeOutputSurface");
   DCHECK(IsMainThread());
 
   if (!success) {
     layer_tree_host()->DidFailToInitializeOutputSurface();
     return;
   }
   main().renderer_capabilities_main_thread_copy = capabilities;
   layer_tree_host()->DidInitializeOutputSurface();
 }
 
-void ThreadProxy::SetRendererCapabilitiesMainThreadCopy(
+void ThreadProxy::SetRendererCapabilitiesMainCopy(
     const RendererCapabilities& capabilities) {
   main().renderer_capabilities_main_thread_copy = capabilities;
 }
 
 bool ThreadProxy::SendCommitRequestToImplThreadIfNeeded(
     CommitPipelineStage required_stage) {
   DCHECK(IsMainThread());
   DCHECK_NE(NO_PIPELINE_STAGE, required_stage);
   bool already_posted =
       main().max_requested_pipeline_stage != NO_PIPELINE_STAGE;
@@ skipping 52 matching lines @@
     return;
   }
   if (SendCommitRequestToImplThreadIfNeeded(COMMIT_PIPELINE_STAGE)) {
     TRACE_EVENT_INSTANT0("cc", "ThreadProxy::SetNeedsCommit",
                          TRACE_EVENT_SCOPE_THREAD);
   }
 }
 
 void ThreadProxy::UpdateRendererCapabilitiesOnImplThread() {
   DCHECK(IsImplThread());
-  Proxy::MainThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::SetRendererCapabilitiesMainThreadCopy,
-                 main_thread_weak_ptr_,
-                 impl()
-                     .layer_tree_host_impl->GetRendererCapabilities()
-                     .MainThreadCapabilities()));
+  impl().channel_impl->SetRendererCapabilitiesMainCopy(
+      impl()
+          .layer_tree_host_impl->GetRendererCapabilities()
+          .MainThreadCapabilities());
 }
 
 void ThreadProxy::DidLoseOutputSurfaceOnImplThread() {
   TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
-  Proxy::MainThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::DidLoseOutputSurface, main_thread_weak_ptr_));
+  impl().channel_impl->DidLoseOutputSurface();
   impl().scheduler->DidLoseOutputSurface();
 }
 
 void ThreadProxy::CommitVSyncParameters(base::TimeTicks timebase,
                                         base::TimeDelta interval) {
   impl().scheduler->CommitVSyncParameters(timebase, interval);
 }
 
 void ThreadProxy::SetEstimatedParentDrawTime(base::TimeDelta draw_time) {
   impl().scheduler->SetEstimatedParentDrawTime(draw_time);
@@ skipping 59 matching lines @@
   // In tests the layer tree is destroyed after the scheduler is.
   if (impl().scheduler)
     impl().scheduler->SetVideoNeedsBeginFrames(needs_begin_frames);
 }
 
 void ThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
     scoped_ptr<AnimationEventsVector> events) {
   TRACE_EVENT0("cc",
                "ThreadProxy::PostAnimationEventsToMainThreadOnImplThread");
   DCHECK(IsImplThread());
-  Proxy::MainThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::SetAnimationEvents,
-                 main_thread_weak_ptr_,
-                 base::Passed(&events)));
+  impl().channel_impl->SetAnimationEvents(events.Pass());
 }
 
 bool ThreadProxy::IsInsideDraw() { return impl().inside_draw; }
 
 void ThreadProxy::SetNeedsRedraw(const gfx::Rect& damage_rect) {
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedraw");
   DCHECK(IsMainThread());
   Proxy::ImplThreadTaskRunner()->PostTask(

[vmpstr, 2015/10/15 20:25:04]

Why did you only do this for a particular set of PostTasks but not for others?

[Khushal, 2015/10/15 23:45:50]

I missed this one. Will change it in this patch.

I was trying to do it separately for these methods and then for the methods in
the commit sequence starting from setneedscommit to break it into smaller
patches.

The last patch which splits the class will include the methods that initializes
and closes ProxyImpl.

[vmpstr, 2015/10/17 00:05:51]

You can probably do all of the call sites that are simply changing from
PostTask(Foo) to channel->Foo(). I agree if there's some logic changes, then
that should be a separate patch.

[Khushal, 2015/10/17 02:02:48]

Done.
The only calls left are for initializing and closing the impl side, which would
make sense to do when the class is actually split.

       FROM_HERE,
       base::Bind(&ThreadProxy::SetNeedsRedrawRectOnImplThread,
                  impl_thread_weak_ptr_,
                  damage_rect));
 }
 
 void ThreadProxy::SetNextCommitWaitsForActivation() {
   DCHECK(IsMainThread());
   DCHECK(!blocked_main().main_thread_inside_commit);
   blocked_main().commit_waits_for_activation = true;
 }
 
 void ThreadProxy::SetDeferCommits(bool defer_commits) {
   DCHECK(IsMainThread());
   if (main().defer_commits == defer_commits)
     return;
 
   main().defer_commits = defer_commits;
   if (main().defer_commits)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ThreadProxy::SetDeferCommits", this);
   else
     TRACE_EVENT_ASYNC_END0("cc", "ThreadProxy::SetDeferCommits", this);
 
-  Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::SetDeferCommitsOnImplThread,
-                 impl_thread_weak_ptr_,
-                 defer_commits));
+  main().channel_main->SetDeferCommitsOnImpl(defer_commits);
 }
 
-void ThreadProxy::SetDeferCommitsOnImplThread(bool defer_commits) const {
+void ThreadProxy::SetDeferCommitsOnImpl(bool defer_commits) {
   DCHECK(IsImplThread());
   impl().scheduler->SetDeferCommits(defer_commits);
 }
 
 bool ThreadProxy::CommitRequested() const {
   DCHECK(IsMainThread());
   // TODO(skyostil): Split this into something like CommitRequested() and
   // CommitInProgress().
   return main().current_pipeline_stage != NO_PIPELINE_STAGE ||
          main().max_requested_pipeline_stage >= COMMIT_PIPELINE_STAGE;
@@ skipping 22 matching lines @@
 }
 
 void ThreadProxy::SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) {
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->SetViewportDamage(damage_rect);
   SetNeedsRedrawOnImplThread();
 }
 
 void ThreadProxy::MainThreadHasStoppedFlinging() {
   DCHECK(IsMainThread());
-  Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::MainThreadHasStoppedFlingingOnImplThread,
-                 impl_thread_weak_ptr_));
+  main().channel_main->MainThreadHasStoppedFlingingOnImpl();
 }
 
-void ThreadProxy::MainThreadHasStoppedFlingingOnImplThread() {
+void ThreadProxy::MainThreadHasStoppedFlingingOnImpl() {
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->MainThreadHasStoppedFlinging();
 }
 
 void ThreadProxy::NotifyInputThrottledUntilCommit() {
   DCHECK(IsMainThread());
-  Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::SetInputThrottledUntilCommitOnImplThread,
-                 impl_thread_weak_ptr_,
-                 true));
+  main().channel_main->SetInputThrottledUntilCommitOnImpl(true);
 }
 
-void ThreadProxy::SetInputThrottledUntilCommitOnImplThread(bool is_throttled) {
+void ThreadProxy::SetInputThrottledUntilCommitOnImpl(bool is_throttled) {
   DCHECK(IsImplThread());
   if (is_throttled == impl().input_throttled_until_commit)
     return;
   impl().input_throttled_until_commit = is_throttled;
   RenewTreePriority();
 }
 
 LayerTreeHost* ThreadProxy::layer_tree_host() {
   return blocked_main().layer_tree_host;
 }
@@ skipping 55 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::Stop");
   DCHECK(IsMainThread());
   DCHECK(main().started);
 
   // Synchronously finishes pending GL operations and deletes the impl.
   // The two steps are done as separate post tasks, so that tasks posted
   // by the GL implementation due to the Finish can be executed by the
   // renderer before shutting it down.
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-
     CompletionEvent completion;
-    Proxy::ImplThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ThreadProxy::FinishGLOnImplThread,
-                   impl_thread_weak_ptr_,
-                   &completion));
+    main().channel_main->FinishGLOnImpl(&completion);
     completion.Wait();
   }
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     CompletionEvent completion;
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::LayerTreeHostClosedOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion));
     completion.Wait();
   }
 
   main().weak_factory.InvalidateWeakPtrs();
   blocked_main().layer_tree_host = NULL;
   main().started = false;
 }
 
 bool ThreadProxy::SupportsImplScrolling() const {
   return true;
 }
 
-void ThreadProxy::FinishAllRenderingOnImplThread(CompletionEvent* completion) {
+void ThreadProxy::FinishAllRenderingOnImpl(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::FinishAllRenderingOnImplThread");
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->FinishAllRendering();
   completion->Signal();
 }
 
 void ThreadProxy::ScheduledActionSendBeginMainFrame() {
   unsigned int begin_frame_id = nextBeginFrameId++;
   benchmark_instrumentation::ScopedBeginFrameTask begin_frame_task(
       benchmark_instrumentation::kSendBeginFrame, begin_frame_id);
@@ skipping 15 matching lines @@
   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);
 }
 
 void ThreadProxy::SendBeginMainFrameNotExpectedSoon() {
-  Proxy::MainThreadTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&ThreadProxy::BeginMainFrameNotExpectedSoon,
-                            main_thread_weak_ptr_));
+  impl().channel_impl->BeginMainFrameNotExpectedSoon();
 }
 
 void ThreadProxy::BeginMainFrame(
     scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) {
   benchmark_instrumentation::ScopedBeginFrameTask begin_frame_task(
       benchmark_instrumentation::kDoBeginFrame,
       begin_main_frame_state->begin_frame_id);
   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("cc.BeginMainFrame");
   DCHECK(IsMainThread());
   DCHECK_EQ(NO_PIPELINE_STAGE, main().current_pipeline_stage);
@@ skipping 143 matching lines @@
 void ThreadProxy::BeginMainFrameAbortedOnImplThread(
     CommitEarlyOutReason reason) {
   TRACE_EVENT1("cc", "ThreadProxy::BeginMainFrameAbortedOnImplThread", "reason",
                CommitEarlyOutReasonToString(reason));
   DCHECK(IsImplThread());
   DCHECK(impl().scheduler);
   DCHECK(impl().scheduler->CommitPending());
   DCHECK(!impl().layer_tree_host_impl->pending_tree());
 
   if (CommitEarlyOutHandledCommit(reason)) {
-    SetInputThrottledUntilCommitOnImplThread(false);
+    SetInputThrottledUntilCommitOnImpl(false);
     impl().last_processed_begin_main_frame_args =
         impl().last_begin_main_frame_args;
   }
   impl().layer_tree_host_impl->BeginMainFrameAborted(reason);
   impl().scheduler->BeginMainFrameAborted(reason);
 }
 
 void ThreadProxy::ScheduledActionAnimate() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionAnimate");
   DCHECK(IsImplThread());
@@ skipping 28 matching lines @@
     impl().commit_completion_event->Signal();
     impl().commit_completion_event = NULL;
   }
 
   impl().scheduler->DidCommit();
 
   // Delay this step until afer the main thread has been released as it's
   // often a good bit of work to update the tree and prepare the new frame.
   impl().layer_tree_host_impl->CommitComplete();
 
-  SetInputThrottledUntilCommitOnImplThread(false);
+  SetInputThrottledUntilCommitOnImpl(false);
 
   impl().next_frame_is_newly_committed_frame = true;
 }
 
 void ThreadProxy::ScheduledActionActivateSyncTree() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionActivateSyncTree");
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->ActivateSyncTree();
 }
 
 void ThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionBeginOutputSurfaceCreation");
   DCHECK(IsImplThread());
-  Proxy::MainThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::RequestNewOutputSurface, main_thread_weak_ptr_));
+  impl().channel_impl->RequestNewOutputSurface();
 }
 
 DrawResult ThreadProxy::DrawSwapInternal(bool forced_draw) {
   TRACE_EVENT_SYNTHETIC_DELAY("cc.DrawAndSwap");
   DrawResult result;
 
   DCHECK(IsImplThread());
   DCHECK(impl().layer_tree_host_impl.get());
 
   base::AutoReset<bool> mark_inside(&impl().inside_draw, true);
@@ skipping 35 matching lines @@
 
   bool start_ready_animations = draw_frame;
   impl().layer_tree_host_impl->UpdateAnimationState(start_ready_animations);
 
   if (draw_frame)
     impl().layer_tree_host_impl->SwapBuffers(frame);
 
   // Tell the main thread that the the newly-commited frame was drawn.
   if (impl().next_frame_is_newly_committed_frame) {
     impl().next_frame_is_newly_committed_frame = false;
-    Proxy::MainThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ThreadProxy::DidCommitAndDrawFrame, main_thread_weak_ptr_));
+    impl().channel_impl->DidCommitAndDrawFrame();
   }
 
   DCHECK_NE(INVALID_RESULT, result);
   return result;
 }
 
 void ThreadProxy::ScheduledActionPrepareTiles() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionPrepareTiles");
   impl().layer_tree_host_impl->PrepareTiles();
 }
@@ skipping 73 matching lines @@
       this, scheduler_settings, impl().layer_tree_host_id,
       ImplThreadTaskRunner(), impl().external_begin_frame_source.get(),
       compositor_timing_history.Pass());
 
   DCHECK_EQ(impl().scheduler->visible(),
             impl().layer_tree_host_impl->visible());
   impl_thread_weak_ptr_ = impl().weak_factory.GetWeakPtr();
   completion->Signal();
 }
 
-void ThreadProxy::InitializeOutputSurfaceOnImplThread(
-    OutputSurface* output_surface) {
+void ThreadProxy::InitializeOutputSurfaceOnImpl(OutputSurface* output_surface) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
 
   LayerTreeHostImpl* host_impl = impl().layer_tree_host_impl.get();
   bool success = host_impl->InitializeRenderer(output_surface);
   RendererCapabilities capabilities;
   if (success) {
     capabilities =
         host_impl->GetRendererCapabilities().MainThreadCapabilities();
   }
 
-  Proxy::MainThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::DidInitializeOutputSurface,
-                 main_thread_weak_ptr_,
-                 success,
-                 capabilities));
+  impl().channel_impl->DidInitializeOutputSurface(success, capabilities);
 
   if (success)
     impl().scheduler->DidCreateAndInitializeOutputSurface();
 }
 
-void ThreadProxy::ReleaseOutputSurfaceOnImplThread(
-    CompletionEvent* completion) {
+void ThreadProxy::ReleaseOutputSurfaceOnImpl(CompletionEvent* completion) {
   DCHECK(IsImplThread());
 
   // Unlike DidLoseOutputSurfaceOnImplThread, we don't need to call
   // LayerTreeHost::DidLoseOutputSurface since it already knows.
   impl().scheduler->DidLoseOutputSurface();
   impl().layer_tree_host_impl->ReleaseOutputSurface();
   completion->Signal();
 }
 
-void ThreadProxy::FinishGLOnImplThread(CompletionEvent* completion) {
+void ThreadProxy::FinishGLOnImpl(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::FinishGLOnImplThread");
   DCHECK(IsImplThread());
   if (impl().layer_tree_host_impl->output_surface()) {
     ContextProvider* context_provider =
         impl().layer_tree_host_impl->output_surface()->context_provider();
     if (context_provider)
       context_provider->ContextGL()->Finish();
   }
   completion->Signal();
 }
@@ skipping 14 matching lines @@
 }
 
 ThreadProxy::BeginMainFrameAndCommitState::BeginMainFrameAndCommitState()
     : memory_allocation_limit_bytes(0),
       evicted_ui_resources(false) {}
 
 ThreadProxy::BeginMainFrameAndCommitState::~BeginMainFrameAndCommitState() {}
 
 bool ThreadProxy::MainFrameWillHappenForTesting() {
   DCHECK(IsMainThread());
-  CompletionEvent completion;
   bool main_frame_will_happen = false;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-    Proxy::ImplThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ThreadProxy::MainFrameWillHappenOnImplThreadForTesting,
-                   impl_thread_weak_ptr_,
-                   &completion,
-                   &main_frame_will_happen));
+    CompletionEvent completion;
+    main().channel_main->MainFrameWillHappenOnImplForTesting(
+        &completion, &main_frame_will_happen);
     completion.Wait();
   }
   return main_frame_will_happen;
 }
 
 void ThreadProxy::SetChildrenNeedBeginFrames(bool children_need_begin_frames) {
   NOTREACHED() << "Only used by SingleThreadProxy";
 }
 
-void ThreadProxy::MainFrameWillHappenOnImplThreadForTesting(
+void ThreadProxy::MainFrameWillHappenOnImplForTesting(
     CompletionEvent* completion,
     bool* main_frame_will_happen) {
   DCHECK(IsImplThread());
   if (impl().layer_tree_host_impl->output_surface()) {
     *main_frame_will_happen = impl().scheduler->MainFrameForTestingWillHappen();
   } else {
     *main_frame_will_happen = false;
   }
   completion->Signal();
 }
@@ skipping 74 matching lines @@
   impl().scheduler->WillPrepareTiles();
 }
 
 void ThreadProxy::DidPrepareTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidPrepareTiles();
 }
 
 void ThreadProxy::DidCompletePageScaleAnimationOnImplThread() {
   DCHECK(IsImplThread());
-  Proxy::MainThreadTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&ThreadProxy::DidCompletePageScaleAnimation,
-                            main_thread_weak_ptr_));
+  impl().channel_impl->DidCompletePageScaleAnimation();
 }
 
 void ThreadProxy::OnDrawForOutputSurface() {
   DCHECK(IsImplThread());
   impl().scheduler->OnDrawForOutputSurface();
 }
 
 void ThreadProxy::PostFrameTimingEventsOnImplThread(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   DCHECK(IsImplThread());
-  Proxy::MainThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::PostFrameTimingEvents, main_thread_weak_ptr_,
-                 base::Passed(composite_events.Pass()),
-                 base::Passed(main_frame_events.Pass())));
+  impl().channel_impl->PostFrameTimingEventsOnMain(composite_events.Pass(),
+                                                   main_frame_events.Pass());
 }
 
-void ThreadProxy::PostFrameTimingEvents(
+void ThreadProxy::PostFrameTimingEventsOnMain(
     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