cc: Split ThreadProxy into ProxyMain and ProxyImpl

cc/test/layer_tree_test.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_TEST_LAYER_TREE_TEST_H_
 #define CC_TEST_LAYER_TREE_TEST_H_
 
 #include "base/memory/ref_counted.h"
 #include "base/threading/thread.h"
 #include "cc/animation/animation_delegate.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 class AnimationPlayer;
 class FakeExternalBeginFrameSource;
 class FakeLayerTreeHostClient;
 class FakeOutputSurface;
 class LayerImpl;
 class LayerTreeHost;
 class LayerTreeHostClient;
 class LayerTreeHostImpl;
+class ProxyMain;
+class ProxyImpl;
 class TestContextProvider;
 class TestGpuMemoryBufferManager;
 class TestWebGraphicsContext3D;
 
 // Creates the virtual viewport layer hierarchy under the given root_layer.
 // Convenient overload of the method below that creates a scrolling layer as
 // the outer viewport scroll layer.
 void CreateVirtualViewportLayers(Layer* root_layer,
                                  const gfx::Size& inner_bounds,
                                  const gfx::Size& outer_bounds,
@@ skipping 98 matching lines @@
   virtual void SetInputThrottledUntilCommitOnImpl(bool is_throttled) {}
   virtual void SetDeferCommitsOnImpl(bool defer_commits) {}
   virtual void BeginMainFrameAbortedOnImpl(CommitEarlyOutReason reason) {}
   virtual void SetNeedsRedrawOnImpl(const gfx::Rect& damage_rect) {}
   virtual void SetNeedsCommitOnImpl() {}
   virtual void FinishAllRenderingOnImpl() {}
   virtual void SetVisibleOnImpl(bool visible) {}
   virtual void ReleaseOutputSurfaceOnImpl() {}
   virtual void FinishGLOnImpl() {}
   virtual void StartCommitOnImpl() {}
-  virtual void InitializeImplOnImpl() {}
   virtual void WillCloseLayerTreeHostOnImpl() {}
 
   // Hooks for ProxyMain
   virtual void ReceivedDidCompleteSwapBuffers() {}
   virtual void ReceivedSetRendererCapabilitiesMainCopy(
       const RendererCapabilities& capabilities) {}
   virtual void ReceivedBeginMainFrameNotExpectedSoon() {}
   virtual void ReceivedDidCommitAndDrawFrame() {}
   virtual void ReceivedSetAnimationEvents() {}
   virtual void ReceivedDidLoseOutputSurface() {}
@@ skipping 91 matching lines @@
   void DispatchDidAddAnimation();
   void DispatchCompositeImmediately();
 
   virtual void AfterTest() = 0;
   virtual void WillBeginTest();
   virtual void BeginTest() = 0;
   virtual void SetupTree();
 
   virtual void RunTest(bool threaded, bool delegating_renderer);
 
-  bool HasImplThread() { return !!impl_thread_; }
+  bool HasImplThread() const { return !!impl_thread_; }
   base::SingleThreadTaskRunner* ImplThreadTaskRunner() {
     DCHECK(proxy());
     return proxy()->ImplThreadTaskRunner() ? proxy()->ImplThreadTaskRunner()
                                            : main_task_runner_.get();
   }
   base::SingleThreadTaskRunner* MainThreadTaskRunner() {
     return main_task_runner_.get();
   }
   Proxy* proxy() const {
     return layer_tree_host_ ? layer_tree_host_->proxy() : NULL;
   }
   TaskGraphRunner* task_graph_runner() const {
     return task_graph_runner_.get();
   }
 
   bool TestEnded() const { return ended_; }
 
   LayerTreeHost* layer_tree_host();
   bool delegating_renderer() const { return delegating_renderer_; }
   FakeOutputSurface* output_surface() { return output_surface_; }
   int LastCommittedSourceFrameNumber(LayerTreeHostImpl* impl) const;
 
+  // Used these only for ProxyMain tests in threaded mode.

[Wez, 2015/11/10 01:41:50]

nit: Used -> Use?

If these are only for tests then can they be GetProxyFooForTest, so that
pre-submit will check that they are only referenced in test code?

[Khushal, 2015/11/11 04:17:47]

I don't think that's necessary. The file itself is only used in test code.
The LayerTreeTests can run in single-threaded or threaded mode. The comment is
to explain that these should only be used  in tests run for threaded mode since
only that mode uses ProxyMain and ProxyImpl. The implementation also has a
DCHECK to ensure that.

[Wez, 2015/11/12 22:30:18]

OK, acknowledged.

+  ProxyMain* GetProxyMain() const;
+  ProxyImpl* GetProxyImpl() const;
+
   void DestroyLayerTreeHost();
 
   // By default, output surface recreation is synchronous.
   void RequestNewOutputSurface() override;
   // Override this for pixel tests, where you need a real output surface.
   virtual scoped_ptr<OutputSurface> CreateOutputSurface();
   // Override this for unit tests, which should not produce pixel output.
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface();
 
   TestWebGraphicsContext3D* TestContext();
@@ skipping 78 matching lines @@
 #define SINGLE_AND_MULTI_THREAD_TEST_F(TEST_FIXTURE_NAME)            \
   SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME); \
   SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 
 // Some tests want to control when notify ready for activation occurs,
 // but this is not supported in the single-threaded case.
 #define MULTI_THREAD_BLOCKNOTIFY_TEST_F(TEST_FIXTURE_NAME) \
   MULTI_THREAD_TEST_F(TEST_FIXTURE_NAME)
 
 #endif  // CC_TEST_LAYER_TREE_TEST_H_