cc:: Add remote mode to the compositor

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/layers/layer_settings.h"
 #include "cc/test/proxy_impl_for_test.h"
 #include "cc/test/proxy_main_for_test.h"
+#include "cc/test/remote_proto_channel_bridge.h"
 #include "cc/test/test_hooks.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 RemoteChannelHostClientForTesting;
+class RemoteChannelHostForTesting;
+class RemoteChannelImplForTest;
 class TestContextProvider;
 class TestGpuMemoryBufferManager;
 class TestTaskGraphRunner;
 class TestWebGraphicsContext3D;
+class ThreadedChannelForTest;
 
 // 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,
                                  const gfx::Size& scroll_bounds,
                                  LayerTreeHost* host,
                                  const LayerSettings& layer_settings);
@@ skipping 80 matching lines @@
   void DispatchSetVisible(bool visible);
   void DispatchSetNextCommitForcesRedraw();
   void DispatchDidAddAnimation();
   void DispatchCompositeImmediately();
 
   virtual void AfterTest() = 0;
   virtual void WillBeginTest();
   virtual void BeginTest() = 0;
   virtual void SetupTree();
 
-  // TODO(khushalsagar): Add mode for running remote channel tests.
   virtual void RunTest(CompositorMode mode, bool delegating_renderer);
 
   bool HasImplThread() const { return !!impl_thread_; }
   base::SingleThreadTaskRunner* ImplThreadTaskRunner() {
     DCHECK(task_runner_provider());
     base::SingleThreadTaskRunner* impl_thread_task_runner =
         task_runner_provider()->ImplThreadTaskRunner();
     return impl_thread_task_runner ? impl_thread_task_runner
                                    : main_task_runner_.get();
   }
   base::SingleThreadTaskRunner* MainThreadTaskRunner() {
     return main_task_runner_.get();
   }
   Proxy* proxy() const {
     return layer_tree_host_ ? layer_tree_host_->proxy() : NULL;
   }
   TaskRunnerProvider* task_runner_provider() const {
     return layer_tree_host_ ? layer_tree_host_->task_runner_provider()
                             : nullptr;
   }
   TaskGraphRunner* task_graph_runner() const;
   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;
 
-  // Use these only for ProxyMain tests in threaded mode.
-  // TODO(khushalsagar): Update these when adding support for remote channel
-  // tests.
+  // Use these only for tests in threaded or remote mode.
   ProxyMainForTest* GetProxyMainForTest() const;
   ProxyImplForTest* GetProxyImplForTest() const;
 
+  // Use this only for tests in threaded mode.
+  ThreadedChannelForTest* GetThreadedChannelForTest() const;
+
+  // Use this only for tests in remote mode.
+  RemoteChannelImplForTest* GetRemoteChannelImplForTest() const;
+
   void DestroyLayerTreeHost();
+  void DestroyRemoteChannelHost();
 
   // 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();
 
   TestGpuMemoryBufferManager* GetTestGpuMemoryBufferManager() {
     return gpu_memory_buffer_manager_.get();
   }
 
+  bool IsRemoteTest() const;
+
  private:
+  void DidShutdown() override;
+
   LayerTreeSettings settings_;
   LayerSettings layer_settings_;
 
   CompositorMode mode_;
 
   scoped_ptr<LayerTreeHostClientForTesting> client_;
   scoped_ptr<LayerTreeHost> layer_tree_host_;
+  scoped_ptr<RemoteChannelHostClientForTesting> remote_channel_host_client_;
+  scoped_ptr<RemoteChannelHostForTesting> remote_channel_host_for_testing_;
   FakeOutputSurface* output_surface_;
   FakeExternalBeginFrameSource* external_begin_frame_source_;
+  RemoteProtoChannelBridge remote_proto_channel_bridge_;

[vmpstr, 2016/01/07 19:08:12]

What's this?

[Khushal, 2016/01/08 21:17:19]

Its just a helper class to send protos directly between the RemoteProtoChannels
for the compositor on the server and client. Mocks out the external network
layer for the tests.
Updated this in the comments.

 
   bool beginning_;
   bool end_when_begin_returns_;
   bool timed_out_;
   bool scheduled_;
   bool started_;
   bool ended_;
   bool delegating_renderer_;
   bool verify_property_trees_;
 
@@ skipping 37 matching lines @@
 #define MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
   TEST_F(TEST_FIXTURE_NAME, RunMultiThread_DelegatingRenderer) {   \
     RunTest(CompositorMode::Threaded, true);                       \
   }                                                                \
   class MultiThreadDelegatingImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 
 #define MULTI_THREAD_TEST_F(TEST_FIXTURE_NAME)            \
   MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME); \
   MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 
+// The Remote mode tests don't need to run for delegated renderer.
+#define REMOTE_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
+  TEST_F(TEST_FIXTURE_NAME, RunRemote_DirectRenderer) {  \
+    RunTest(CompositorMode::Remote, false);              \
+  }                                                      \
+  class RemoteDirectImplNeedsSemicolon##TEST_FIXTURE_NAME {}
+
 #define SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
   SINGLE_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME);                \
   MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 
 #define SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
   SINGLE_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME);                \
   MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 
 #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_