cc/blimp: Add a LayerTreeHostRemote implementation.

cc/blimp/layer_tree_host_remote.h

+// Copyright 2016 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_BLIMP_LAYER_TREE_HOST_REMOTE_H_
+#define CC_BLIMP_LAYER_TREE_HOST_REMOTE_H_
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "cc/base/cc_export.h"
+#include "cc/blimp/remote_compositor_bridge_client.h"
+#include "cc/debug/layer_tree_debug_state.h"
+#include "cc/trees/layer_tree_host.h"
+#include "cc/trees/layer_tree_settings.h"
+#include "cc/trees/surface_sequence_generator.h"
+#include "cc/trees/swap_promise_manager.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}  // namespace base
+
+namespace cc {
+class AnimationHost;
+class RemoteCompositorBridge;
+class LayerTreeHostClient;
+
+class CC_EXPORT LayerTreeHostRemote : public LayerTreeHost,
+                                      public RemoteCompositorBridgeClient {
+ public:
+  // The remote LayerTreeHost doesn't perform any compositing, so we don't need
+  // any resources (OutputSurface, TaskGraphRunner, etc.) needed by the

[danakj, 2016/09/30 22:37:13]

TBH commenting on the absence of these is a bit weird here, like all classes
take the things they need. This LTH impl doesn't use those so they aren't
params.

[Khushal, 2016/10/01 00:53:48]

Removed.

+  // compositor.
+  struct InitParams {
+    LayerTreeHostClient* client = nullptr;
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner;
+    std::unique_ptr<AnimationHost> animation_host;
+    std::unique_ptr<RemoteCompositorBridge> remote_compositor_bridge;
+    LayerTreeSettings const* settings = nullptr;
+
+    InitParams();
+    ~InitParams();
+  };
+
+  explicit LayerTreeHostRemote(InitParams* params);
+  ~LayerTreeHostRemote() override;
+
+  // LayerTreeHost implementation.
+  int GetId() const override;
+  int SourceFrameNumber() const override;
+  LayerTree* GetLayerTree() override;
+  const LayerTree* GetLayerTree() const override;
+  UIResourceManager* GetUIResourceManager() override;
+  TaskRunnerProvider* GetTaskRunnerProvider() const override;
+  const LayerTreeSettings& GetSettings() const override;
+  void SetSurfaceClientId(uint32_t client_id) override;
+  void SetLayerTreeMutator(std::unique_ptr<LayerTreeMutator> mutator) override;
+  void QueueSwapPromise(std::unique_ptr<SwapPromise> swap_promise) override;
+  SwapPromiseManager* GetSwapPromiseManager() override;
+  void SetHasGpuRasterizationTrigger(bool has_trigger) override;
+  void SetVisible(bool visible) override;
+  bool IsVisible() const override;
+  void SetCompositorFrameSink(
+      std::unique_ptr<CompositorFrameSink> compositor_frame_sink) override;
+  std::unique_ptr<CompositorFrameSink> ReleaseCompositorFrameSink() override;
+  void SetNeedsAnimate() override;
+  void SetNeedsUpdateLayers() override;
+  void SetNeedsCommit() override;
+  bool BeginMainFrameRequested() const override;
+  bool CommitRequested() const override;
+  void SetDeferCommits(bool defer_commits) override;
+  void LayoutAndUpdateLayers() override;
+  void Composite(base::TimeTicks frame_begin_time) override;
+  void SetNeedsRedraw() override;
+  void SetNeedsRedrawRect(const gfx::Rect& damage_rect) override;
+  void SetNextCommitForcesRedraw() override;
+  void NotifyInputThrottledUntilCommit() override;
+  void UpdateTopControlsState(TopControlsState constraints,
+                              TopControlsState current,
+                              bool animate) override;
+  const base::WeakPtr<InputHandler>& GetInputHandler() const override;
+  void DidStopFlinging() override;
+  void SetDebugState(const LayerTreeDebugState& debug_state) override;
+  const LayerTreeDebugState& GetDebugState() const override;
+  int ScheduleMicroBenchmark(
+      const std::string& benchmark_name,
+      std::unique_ptr<base::Value> value,
+      const MicroBenchmark::DoneCallback& callback) override;
+  bool SendMessageToMicroBenchmark(int id,
+                                   std::unique_ptr<base::Value> value) override;
+  SurfaceSequenceGenerator* GetSurfaceSequenceGenerator() override;
+  void SetNextCommitWaitsForActivation() override;
+  void ResetGpuRasterizationTracking() override;
+
+ protected:
+  // Protected for testing. Allows tests to inject the LayerTree.
+  LayerTreeHostRemote(InitParams* params,
+                      std::unique_ptr<LayerTree> layer_tree);
+
+ private:
+  enum class FramePipelineStage { NONE, ANIMATE, UPDATE_LAYERS, COMMIT };
+
+  // RemoteCompositorBridgeClient implementation.

[danakj, 2016/09/30 22:37:13]

nit: Im not a super fan of private inheriting functions cuz you can just upcast
and call them it feels misleading, it hides the functions with real private
things etc. Just want to say that, up to you.

[Khushal, 2016/10/01 00:53:48]

I just think that it makes it more explicit that this is meant to be private. If
they have to cast it to be able to call it, they'll know they are probably doing
something wrong.

[danakj, 2016/10/03 21:02:48]

They may cast it accidentally. It can be done implicitly.

[Khushal, 2016/10/04 01:27:09]

Can you share an example of this one? I thought that unless something takes the
base class pointer you'll have to do an explicit cast. Just want to know because
I do use this pattern a lot...

[danakj, 2016/10/04 01:40:57]

BaseClass* GetSubclass() {
  Subclass* s = ...
  return s;
}
GetSubclass()->Inherited();

or
SubClass* GetSubclass() {
  Subclass* s = ...
  return s;
}
BaseClass *b = ...
...
if (something)
  b = GetSubclass();
...
b->Inherited();


Like nothing is preventing you from putting the subclass into a variable of the
interface, and calling that, and with sufficient distance created by the ...s
above I think this becomes less trivial. You're right that you need to have some
code naming the base class somewhere for it to happen. But I'm not sure it means
someone will know they are doing something wrong so much as they will know that
they need to get the client* before using these methods, but that doesn't mean
they should be using the client interface.

And given enough time, there will be some test poking that method directly
anyway. :)

+  void BeginMainFrame() override;
+
+  base::SingleThreadTaskRunner* MainTaskRunner();
+
+  void MainFrameRequested(FramePipelineStage requested_pipeline_stage);
+  void ScheduleMainFrameIfNecessary();
+  void MainFrameComplete();
+  void DispatchDrawAndSwapCallbacks();
+
+  int id_;

[danakj, 2016/09/30 22:37:13]

const?

[Khushal, 2016/10/01 00:53:48]

Done.

+  int source_frame_number_;
+  bool visible_;
+  bool defer_commits_;
+
+  // Set to true if a main frame request is pending on the
+  // RemoteCompositorBridge.
+  bool main_frame_requested_from_bridge_;
+
+  // Set to the pipeline stage we are currently at if we are inside a main frame
+  // update.
+  FramePipelineStage current_pipeline_stage_;
+
+  // Set to the pipeline stage we need to go to for the current main frame
+  // update, if we are inside a main frame update.
+  FramePipelineStage max_pipeline_stage_for_current_frame_;
+
+  // Set to the pipeline stage requested for the next BeginMainFrame.
+  FramePipelineStage requested_pipeline_stage_for_next_frame_;
+
+  LayerTreeHostClient* client_;
+  std::unique_ptr<TaskRunnerProvider> task_runner_provider_;
+
+  // The RemoteCompositorBridge used to submit frame updates to the client.
+  std::unique_ptr<RemoteCompositorBridge> remote_compositor_bridge_;
+
+  LayerTreeSettings settings_;
+  LayerTreeDebugState debug_state_;
+
+  // The LayerTree holds the root layer and other state on the engine.
+  std::unique_ptr<LayerTree> layer_tree_;
+
+  SwapPromiseManager swap_promise_manager_;
+  SurfaceSequenceGenerator surface_sequence_generator_;
+
+  base::WeakPtr<InputHandler> input_handler_weak_ptr_;
+
+  base::WeakPtrFactory<LayerTreeHostRemote> weak_factory_;
+};
+
+}  // namespace cc
+
+#endif  // CC_BLIMP_LAYER_TREE_HOST_REMOTE_H_