Split ThreadProxy methods to ProxyMain and ProxyImpl.

cc/trees/thread_proxy.h

 // 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.
 
 #ifndef CC_TREES_THREAD_PROXY_H_
 #define CC_TREES_THREAD_PROXY_H_
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 33 matching lines @@
                               NON_EXPORTED_BASE(SchedulerClient) {
  public:
   static scoped_ptr<Proxy> Create(
       LayerTreeHost* layer_tree_host,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
       scoped_ptr<BeginFrameSource> external_begin_frame_source);
 
   ~ThreadProxy() override;
 
-  struct BeginMainFrameAndCommitState {
-    BeginMainFrameAndCommitState();
-    ~BeginMainFrameAndCommitState();
-
-    unsigned int begin_frame_id;
-    BeginFrameArgs begin_frame_args;
-    scoped_ptr<ScrollAndScaleSet> scroll_info;
-    size_t memory_allocation_limit_bytes;
-    bool evicted_ui_resources;
-  };
-
   // Commits between the main and impl threads are processed through a pipeline
   // with the following stages. For efficiency we can early out at any stage if
   // we decide that no further processing is necessary.
   enum CommitPipelineStage {
     NO_PIPELINE_STAGE,
     ANIMATE_PIPELINE_STAGE,
     UPDATE_LAYERS_PIPELINE_STAGE,
     COMMIT_PIPELINE_STAGE,
   };
 
@@ skipping 170 matching lines @@
   void ScheduledActionBeginOutputSurfaceCreation() override;
   void ScheduledActionPrepareTiles() override;
   void ScheduledActionInvalidateOutputSurface() override;
   void SendBeginFramesToChildren(const BeginFrameArgs& args) override;
   void SendBeginMainFrameNotExpectedSoon() override;
 
   // ProxyMain implementation
   base::WeakPtr<ProxyMain> GetMainWeakPtr() override;
   void SetChannel(scoped_ptr<ThreadedChannel> threaded_channel) override;
   void DidCompleteSwapBuffers() override;
+  void SetRendererCapabilitiesMainCopy(

[vmpstr, 2015/10/26 17:57:36]

I'm a bit hesitant about these becoming public. Can we instead make the channel
classes friends of this one? That would limit the exposure of these functions
that should not be called directly.

[Khushal, 2015/10/26 20:56:02]

Done. Added ThreadProxyForTest as a friend class as well.

+      const RendererCapabilities& capabilities) override;
+  void BeginMainFrameNotExpectedSoon() override;
+  void DidCommitAndDrawFrame() override;
+  void SetAnimationEvents(scoped_ptr<AnimationEventsVector> queue) override;
+  void DidLoseOutputSurface() override;
+  void RequestNewOutputSurface() override;
+  void DidInitializeOutputSurface(
+      bool success,
+      const RendererCapabilities& capabilities) override;
+  void DidCompletePageScaleAnimation() override;
+  void PostFrameTimingEventsOnMain(
+      scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
+      scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events)
+      override;
+  void BeginMainFrame(
+      scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) override;
 
   // ProxyImpl implementation
   base::WeakPtr<ProxyImpl> GetImplWeakPtr() override;
   void SetThrottleFrameProductionOnImpl(bool throttle) override;
   void UpdateTopControlsStateOnImpl(TopControlsState constraints,
                                     TopControlsState current,
                                     bool animate) override;
+  void InitializeOutputSurfaceOnImpl(OutputSurface* output_surface) override;
+  void MainThreadHasStoppedFlingingOnImpl() override;
+  void SetInputThrottledUntilCommitOnImpl(bool is_throttled) override;
+  void SetDeferCommitsOnImpl(bool defer_commits) const override;
+  void FinishAllRenderingOnImpl(CompletionEvent* completion) override;
+  void SetVisibleOnImpl(CompletionEvent* completion, bool visible) override;
+  void ReleaseOutputSurfaceOnImpl(CompletionEvent* completion) override;
+  void FinishGLOnImpl(CompletionEvent* completion) override;
+  void MainFrameWillHappenOnImplForTesting(
+      CompletionEvent* completion,
+      bool* main_frame_will_happen) override;
+  void SetNeedsCommitOnImpl() override;
+  void SetNeedsRedrawOnImpl(const gfx::Rect& damage_rect) override;
+  void BeginMainFrameAbortedOnImpl(CommitEarlyOutReason reason) override;
+  void StartCommitOnImpl(CompletionEvent* completion) override;
 
  protected:
   ThreadProxy(
       LayerTreeHost* layer_tree_host,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
       scoped_ptr<BeginFrameSource> external_begin_frame_source);
 
  private:
   // Called on main thread.
-  void SetRendererCapabilitiesMainThreadCopy(
-      const RendererCapabilities& capabilities);
-  void BeginMainFrame(
-      scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state);
-  void BeginMainFrameNotExpectedSoon();
-  void DidCommitAndDrawFrame();
-  void SetAnimationEvents(scoped_ptr<AnimationEventsVector> queue);
-  void DidLoseOutputSurface();
-  void RequestNewOutputSurface();
-  void DidInitializeOutputSurface(bool success,
-                                  const RendererCapabilities& capabilities);
+
   // Returns |true| if the request was actually sent, |false| if one was
   // already outstanding.
   bool SendCommitRequestToImplThreadIfNeeded(
       CommitPipelineStage required_stage);
-  void DidCompletePageScaleAnimation();
 
   // Called on impl thread.
   struct SchedulerStateRequest;
 
-  void StartCommitOnImplThread(CompletionEvent* completion);
-  void BeginMainFrameAbortedOnImplThread(CommitEarlyOutReason reason);
-  void FinishAllRenderingOnImplThread(CompletionEvent* completion);
   void InitializeImplOnImplThread(CompletionEvent* completion);
-  void SetVisibleOnImplThread(CompletionEvent* completion, bool visible);
-  void HasInitializedOutputSurfaceOnImplThread(
-      CompletionEvent* completion,
-      bool* has_initialized_output_surface);
-  void DeleteContentsTexturesOnImplThread(CompletionEvent* completion);
-  void InitializeOutputSurfaceOnImplThread(OutputSurface* output_surface);
-  void ReleaseOutputSurfaceOnImplThread(CompletionEvent* completion);
-  void FinishGLOnImplThread(CompletionEvent* completion);
   void LayerTreeHostClosedOnImplThread(CompletionEvent* completion);
   DrawResult DrawSwapInternal(bool forced_draw);
-  void MainFrameWillHappenOnImplThreadForTesting(CompletionEvent* completion,
-                                                 bool* main_frame_will_happen);
-  void SetSwapUsedIncompleteTileOnImplThread(bool used_incomplete_tile);
-  void MainThreadHasStoppedFlingingOnImplThread();
-  void SetInputThrottledUntilCommitOnImplThread(bool is_throttled);
-  void SetDeferCommitsOnImplThread(bool defer_commits) const;
-  void PostFrameTimingEvents(
-      scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
-      scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events);
 
   LayerTreeHost* layer_tree_host();
   const LayerTreeHost* layer_tree_host() const;
 
   // Use accessors instead of this variable directly.
   MainThreadOnly main_thread_only_vars_unsafe_;
   MainThreadOnly& main();
 
   // Use accessors instead of this variable directly.
   MainThreadOrBlockedMainThread main_thread_or_blocked_vars_unsafe_;
   MainThreadOrBlockedMainThread& blocked_main();
 
   // Use accessors instead of this variable directly.
   CompositorThreadOnly compositor_thread_vars_unsafe_;
   CompositorThreadOnly& impl();
 
   // TODO(khushalsagar): Remove this. Temporary variable to hold the channel.
   scoped_ptr<ThreadedChannel> threaded_channel_;
 
   base::WeakPtr<ThreadProxy> main_thread_weak_ptr_;
   base::WeakPtr<ThreadProxy> impl_thread_weak_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadProxy);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_THREAD_PROXY_H_