cc: Abstract the LayerTreeHost.

cc/trees/layer_tree_host.cc

 // 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.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 111 matching lines @@
 }
 
 }  // namespace
 
 LayerTreeHost::InitParams::InitParams() {
 }
 
 LayerTreeHost::InitParams::~InitParams() {
 }
 
-std::unique_ptr<LayerTreeHost> LayerTreeHost::CreateThreaded(
+std::unique_ptr<LayerTreeHostInterface> LayerTreeHost::CreateThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     InitParams* params) {
   DCHECK(params->main_task_runner.get());
   DCHECK(impl_task_runner.get());
   DCHECK(params->settings);
   std::unique_ptr<LayerTreeHost> layer_tree_host(
       new LayerTreeHost(params, CompositorMode::THREADED));
   layer_tree_host->InitializeThreaded(
       params->main_task_runner, impl_task_runner,
       std::move(params->external_begin_frame_source));
-  return layer_tree_host;
+  return std::move(layer_tree_host);
 }
 
 std::unique_ptr<LayerTreeHost> LayerTreeHost::CreateSingleThreaded(
     LayerTreeHostSingleThreadClient* single_thread_client,
     InitParams* params) {
   DCHECK(params->settings);
   std::unique_ptr<LayerTreeHost> layer_tree_host(
       new LayerTreeHost(params, CompositorMode::SINGLE_THREADED));
   layer_tree_host->InitializeSingleThreaded(
       single_thread_client, params->main_task_runner,
       std::move(params->external_begin_frame_source));
   return layer_tree_host;
 }
 
-std::unique_ptr<LayerTreeHost> LayerTreeHost::CreateRemoteServer(
+std::unique_ptr<LayerTreeHostInterface> LayerTreeHost::CreateRemoteServer(
     RemoteProtoChannel* remote_proto_channel,
     InitParams* params) {
   DCHECK(params->main_task_runner.get());
   DCHECK(params->settings);
   DCHECK(remote_proto_channel);
   TRACE_EVENT0("cc.remote", "LayerTreeHost::CreateRemoteServer");
 
   // Using an external begin frame source is not supported on the server in
   // remote mode.
   DCHECK(!params->settings->use_external_begin_frame_source);
   DCHECK(!params->external_begin_frame_source);
   DCHECK(params->image_serialization_processor);
 
   std::unique_ptr<LayerTreeHost> layer_tree_host(
       new LayerTreeHost(params, CompositorMode::REMOTE));
   layer_tree_host->InitializeRemoteServer(remote_proto_channel,
                                           params->main_task_runner);
-  return layer_tree_host;
+  return std::move(layer_tree_host);
 }
 
-std::unique_ptr<LayerTreeHost> LayerTreeHost::CreateRemoteClient(
+std::unique_ptr<LayerTreeHostInterface> LayerTreeHost::CreateRemoteClient(
     RemoteProtoChannel* remote_proto_channel,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     InitParams* params) {
   DCHECK(params->main_task_runner.get());
   DCHECK(params->settings);
   DCHECK(remote_proto_channel);
 
   // Using an external begin frame source is not supported in remote mode.
   // TODO(khushalsagar): Add support for providing an external begin frame
   // source on the client LayerTreeHost. crbug/576962
   DCHECK(!params->settings->use_external_begin_frame_source);
   DCHECK(!params->external_begin_frame_source);
   DCHECK(params->image_serialization_processor);
 
   std::unique_ptr<LayerTreeHost> layer_tree_host(
       new LayerTreeHost(params, CompositorMode::REMOTE));
   layer_tree_host->InitializeRemoteClient(
       remote_proto_channel, params->main_task_runner, impl_task_runner);
-  return layer_tree_host;
+  return std::move(layer_tree_host);
 }
 
 LayerTreeHost::LayerTreeHost(InitParams* params, CompositorMode mode)
     : LayerTreeHost(
           params,
           mode,
           base::MakeUnique<LayerTree>(std::move(params->animation_host),
                                       this)) {}
 
 LayerTreeHost::LayerTreeHost(InitParams* params,
@@ skipping 142 matching lines @@
 
   if (proxy_) {
     DCHECK(task_runner_provider_->IsMainThread());
     proxy_->Stop();
 
     // Proxy must be destroyed before the Task Runner Provider.
     proxy_ = nullptr;
   }
 }
 
+int LayerTreeHost::GetId() const {
+  return id_;
+}
+
+int LayerTreeHost::SourceFrameNumber() const {
+  return source_frame_number_;
+}
+
+LayerTree* LayerTreeHost::GetLayerTree() {
+  return layer_tree_.get();
+}
+
+const LayerTree* LayerTreeHost::GetLayerTree() const {
+  return layer_tree_.get();
+}
+
+TaskRunnerProvider* LayerTreeHost::GetTaskRunnerProvider() const {
+  return task_runner_provider_.get();
+}
+
+const LayerTreeSettings& LayerTreeHost::GetSettings() const {
+  return settings_;
+}
+
 void LayerTreeHost::WillBeginMainFrame() {
-  devtools_instrumentation::WillBeginMainThreadFrame(id(),
-                                                     source_frame_number());
+  devtools_instrumentation::WillBeginMainThreadFrame(GetId(),
+                                                     SourceFrameNumber());
   client_->WillBeginMainFrame();
 }
 
 void LayerTreeHost::DidBeginMainFrame() {
   client_->DidBeginMainFrame();
 }
 
 void LayerTreeHost::BeginMainFrameNotExpectedSoon() {
   client_->BeginMainFrameNotExpectedSoon();
 }
 
 void LayerTreeHost::BeginMainFrame(const BeginFrameArgs& args) {
   client_->BeginMainFrame(args);
 }
 
 void LayerTreeHost::DidStopFlinging() {
   proxy_->MainThreadHasStoppedFlinging();
 }
 
+const LayerTreeDebugState& LayerTreeHost::GetDebugState() const {
+  return debug_state_;
+}
+
 void LayerTreeHost::RequestMainFrameUpdate() {
   client_->UpdateLayerTreeHost();
 }
 
 // This function commits the LayerTreeHost to an impl tree. When modifying
 // this function, keep in mind that the function *runs* on the impl thread! Any
 // code that is logically a main thread operation, e.g. deletion of a Layer,
 // should be delayed until the LayerTreeHost::CommitComplete, which will run
 // after the commit, but on the main thread.
 void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
   DCHECK(!IsRemoteServer());
   DCHECK(task_runner_provider_->IsImplThread());
 
   bool is_new_trace;
   TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
   if (is_new_trace &&
       frame_viewer_instrumentation::IsTracingLayerTreeSnapshots() &&
       layer_tree_->root_layer()) {
     LayerTreeHostCommon::CallFunctionForEveryLayer(
         layer_tree_.get(), [](Layer* layer) { layer->DidBeginTracing(); });
   }
 
   LayerTreeImpl* sync_tree = host_impl->sync_tree();
 
   if (next_commit_forces_redraw_) {
     sync_tree->ForceRedrawNextActivation();
     next_commit_forces_redraw_ = false;
   }
 
-  sync_tree->set_source_frame_number(source_frame_number());
+  sync_tree->set_source_frame_number(SourceFrameNumber());
 
   if (layer_tree_->needs_full_tree_sync())
     TreeSynchronizer::SynchronizeTrees(layer_tree_->root_layer(), sync_tree);
 
   layer_tree_->PushPropertiesTo(sync_tree);
 
   sync_tree->PassSwapPromises(std::move(swap_promise_list_));
   swap_promise_list_.clear();
 
   host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
@@ skipping 217 matching lines @@
   layer_tree_->SetPageScaleFromImplSide(page_scale);
 }
 
 void LayerTreeHost::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
   proxy_->SetVisible(visible);
 }
 
+bool LayerTreeHost::IsVisible() const {
+  return visible_;
+}
+
 void LayerTreeHost::NotifyInputThrottledUntilCommit() {
   proxy_->NotifyInputThrottledUntilCommit();
 }
 
 void LayerTreeHost::LayoutAndUpdateLayers() {
   DCHECK(IsSingleThreaded());
   // This function is only valid when not using the scheduler.
   DCHECK(!settings_.single_thread_proxy_scheduler);
   RequestMainFrameUpdate();
   UpdateLayers();
@@ skipping 56 matching lines @@
       layer_tree_->outer_viewport_scroll_layer(),
       layer_tree_->overscroll_elasticity_layer(),
       layer_tree_->elastic_overscroll(), layer_tree_->page_scale_factor(),
       layer_tree_->device_scale_factor(),
       gfx::Rect(layer_tree_->device_viewport_size()), identity_transform,
       layer_tree_->property_trees());
 }
 
 bool LayerTreeHost::DoUpdateLayers(Layer* root_layer) {
   TRACE_EVENT1("cc", "LayerTreeHost::DoUpdateLayers", "source_frame_number",
-               source_frame_number());
+               SourceFrameNumber());
 
   layer_tree_->UpdateHudLayer(debug_state_.ShowHudInfo());
   UpdateHudLayer();
 
   Layer* root_scroll =
       PropertyTreeBuilder::FindFirstScrollableLayer(root_layer);
   Layer* page_scale_layer = layer_tree_->page_scale_layer();
   if (!page_scale_layer && root_scroll)
     page_scale_layer = root_scroll->parent();
 
@@ skipping 113 matching lines @@
       SetNeedsUpdateLayers();
     }
   }
 
   // This needs to happen after scroll deltas have been sent to prevent top
   // controls from clamping the layout viewport both on the compositor and
   // on the main thread.
   ApplyViewportDeltas(info);
 }
 
+const base::WeakPtr<InputHandler>& LayerTreeHost::GetInputHandler() const {
+  return input_handler_weak_ptr_;
+}
+
 void LayerTreeHost::UpdateTopControlsState(TopControlsState constraints,
                                            TopControlsState current,
                                            bool animate) {
   // Top controls are only used in threaded or remote mode.
   DCHECK(IsThreaded() || IsRemoteServer());
   proxy_->UpdateTopControlsState(constraints, current, animate);
 }
 
 void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
   AnimationHost* animation_host = layer_tree_->animation_host();
@@ skipping 111 matching lines @@
   std::vector<std::unique_ptr<SwapPromise>> to_return;
   to_return.swap(swap_promise_list_);
   return to_return;
 }
 
 void LayerTreeHost::OnCommitForSwapPromises() {
   for (const auto& swap_promise : swap_promise_list_)
     swap_promise->OnCommit();
 }
 
-void LayerTreeHost::set_surface_client_id(uint32_t client_id) {
+void LayerTreeHost::SetSurfaceClientId(uint32_t client_id) {
   surface_client_id_ = client_id;
 }
 
 SurfaceSequence LayerTreeHost::CreateSurfaceSequence() {
   return SurfaceSequence(surface_client_id_, next_surface_sequence_++);
 }
 
 void LayerTreeHost::SetLayerTreeMutator(
     std::unique_ptr<LayerTreeMutator> mutator) {
   proxy_->SetMutator(std::move(mutator));
@@ skipping 103 matching lines @@
   has_gpu_rasterization_trigger_ = proto.has_gpu_rasterization_trigger();
   content_is_suitable_for_gpu_rasterization_ =
       proto.content_is_suitable_for_gpu_rasterization();
   id_ = proto.id();
   next_commit_forces_redraw_ = proto.next_commit_forces_redraw();
 
   surface_client_id_ = proto.surface_client_id();
   next_surface_sequence_ = proto.next_surface_sequence();
 }
 
-AnimationHost* LayerTreeHost::animation_host() const {
-  return layer_tree_->animation_host();
-}
-
 }  // namespace cc