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 10 matching lines @@
     CommitPipelineStage current_pipeline_stage;
     // The commit pipeline stage at which processing for the current commit
     // will stop. Only valid while we are executing the pipeline (i.e.,
     // |current_pipeline_stage| is set to a pipeline stage).
     CommitPipelineStage final_pipeline_stage;
 
     bool started;
     bool prepare_tiles_pending;
     bool defer_commits;
 
+    bool commit_waits_for_activation;
+
     RendererCapabilities renderer_capabilities_main_thread_copy;
 
     // TODO(khushalsagar): Make this scoped_ptr<ChannelMain> when ProxyMain
     // and ProxyImpl are split.
     ChannelMain* channel_main;
 
     base::WeakPtrFactory<ThreadProxy> weak_factory;
   };
 
   // Accessed on the main thread, or when main thread is blocked.
   struct MainThreadOrBlockedMainThread {
     explicit MainThreadOrBlockedMainThread(LayerTreeHost* host);
     ~MainThreadOrBlockedMainThread();
 
     LayerTreeHost* layer_tree_host;
-    bool commit_waits_for_activation;
-    bool main_thread_inside_commit;
   };
 
   struct CompositorThreadOnly {
     CompositorThreadOnly(
         ThreadProxy* proxy,
         int layer_tree_host_id,
         RenderingStatsInstrumentation* rendering_stats_instrumentation,
         scoped_ptr<BeginFrameSource> external_begin_frame_source);
     ~CompositorThreadOnly();
 
@@ skipping 123 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(
+      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) 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,
+      BlockedMainCommitState* blocked_main_commit_state) 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();
 
+  // Set when the main thread is waiting on a commit to finish.
+  // Use accessors instead of this variable directly.
+  // TODO(khushalsagar) : Move to ProxyImpl once ThreadProxy is split.
+  BlockedMainCommitState* blocked_main_commit_state_vars_unsafe_;
+  const BlockedMainCommitState* blocked_commit_state() const;
+  void set_blocked_commit_state(
+      BlockedMainCommitState* blocked_main_commit_state);
+
   // 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_