cc: Move data to LayerTree from LayerTreeHost.

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 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 "content/renderer/gpu/render_widget_compositor.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 645 matching lines @@
 
 void RenderWidgetCompositor::SetNeedsCommit() {
   layer_tree_host_->SetNeedsCommit();
 }
 
 void RenderWidgetCompositor::NotifyInputThrottledUntilCommit() {
   layer_tree_host_->NotifyInputThrottledUntilCommit();
 }
 
 const cc::Layer* RenderWidgetCompositor::GetRootLayer() const {
-  return layer_tree_host_->root_layer();
+  return layer_tree_host_->GetLayerTree()->root_layer();
 }
 
 int RenderWidgetCompositor::ScheduleMicroBenchmark(
     const std::string& name,
     std::unique_ptr<base::Value> value,
     const base::Callback<void(std::unique_ptr<base::Value>)>& callback) {
   return layer_tree_host_->ScheduleMicroBenchmark(name, std::move(value),
                                                   callback);
 }
 
 bool RenderWidgetCompositor::SendMessageToMicroBenchmark(
     int id,
     std::unique_ptr<base::Value> value) {
   return layer_tree_host_->SendMessageToMicroBenchmark(id, std::move(value));
 }
 
 void RenderWidgetCompositor::setRootLayer(const blink::WebLayer& layer) {
-  layer_tree_host_->SetRootLayer(
+  layer_tree_host_->GetLayerTree()->SetRootLayer(
       static_cast<const cc_blink::WebLayerImpl*>(&layer)->layer());
 }
 
 void RenderWidgetCompositor::clearRootLayer() {
-  layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
+  layer_tree_host_->GetLayerTree()->SetRootLayer(scoped_refptr<cc::Layer>());
 }
 
 void RenderWidgetCompositor::attachCompositorAnimationTimeline(
     cc::AnimationTimeline* compositor_timeline) {
   DCHECK(layer_tree_host_->animation_host());
   layer_tree_host_->animation_host()->AddAnimationTimeline(compositor_timeline);
 }
 
 void RenderWidgetCompositor::detachCompositorAnimationTimeline(
     cc::AnimationTimeline* compositor_timeline) {
   DCHECK(layer_tree_host_->animation_host());
   layer_tree_host_->animation_host()->RemoveAnimationTimeline(
       compositor_timeline);
 }
 
 void RenderWidgetCompositor::setViewportSize(
     const WebSize& device_viewport_size) {
-  layer_tree_host_->SetViewportSize(device_viewport_size);
+  layer_tree_host_->GetLayerTree()->SetViewportSize(device_viewport_size);
 }
 
 WebFloatPoint RenderWidgetCompositor::adjustEventPointForPinchZoom(
     const WebFloatPoint& point) const {
   return point;
 }
 
 void RenderWidgetCompositor::setDeviceScaleFactor(float device_scale) {
-  layer_tree_host_->SetDeviceScaleFactor(device_scale);
+  layer_tree_host_->GetLayerTree()->SetDeviceScaleFactor(device_scale);
 }
 
 void RenderWidgetCompositor::setBackgroundColor(blink::WebColor color) {
-  layer_tree_host_->set_background_color(color);
+  layer_tree_host_->GetLayerTree()->set_background_color(color);
 }
 
 void RenderWidgetCompositor::setHasTransparentBackground(bool transparent) {
-  layer_tree_host_->set_has_transparent_background(transparent);
+  layer_tree_host_->GetLayerTree()->set_has_transparent_background(transparent);
 }
 
 void RenderWidgetCompositor::setVisible(bool visible) {
   if (never_visible_)
     return;
 
   layer_tree_host_->SetVisible(visible);
 }
 
 void RenderWidgetCompositor::setPageScaleFactorAndLimits(
     float page_scale_factor, float minimum, float maximum) {
-  layer_tree_host_->SetPageScaleFactorAndLimits(
+  layer_tree_host_->GetLayerTree()->SetPageScaleFactorAndLimits(
       page_scale_factor, minimum, maximum);
 }
 
 void RenderWidgetCompositor::startPageScaleAnimation(
     const blink::WebPoint& destination,
     bool use_anchor,
     float new_page_scale,
     double duration_sec) {
   base::TimeDelta duration = base::TimeDelta::FromMicroseconds(
       duration_sec * base::Time::kMicrosecondsPerSecond);
-  layer_tree_host_->StartPageScaleAnimation(
-      gfx::Vector2d(destination.x, destination.y),
-      use_anchor,
-      new_page_scale,
+  layer_tree_host_->GetLayerTree()->StartPageScaleAnimation(
+      gfx::Vector2d(destination.x, destination.y), use_anchor, new_page_scale,
       duration);
 }
 
 bool RenderWidgetCompositor::hasPendingPageScaleAnimation() const {
-  return layer_tree_host_->HasPendingPageScaleAnimation();
+  return layer_tree_host_->GetLayerTree()->HasPendingPageScaleAnimation();
 }
 
 void RenderWidgetCompositor::heuristicsForGpuRasterizationUpdated(
     bool matches_heuristics) {
   layer_tree_host_->SetHasGpuRasterizationTrigger(matches_heuristics);
 }
 
 void RenderWidgetCompositor::setNeedsAnimate() {
   layer_tree_host_->SetNeedsAnimate();
   layer_tree_host_->SetNeedsUpdateLayers();
 }
 
 void RenderWidgetCompositor::setNeedsBeginFrame() {
   layer_tree_host_->SetNeedsAnimate();
 }
 
 void RenderWidgetCompositor::setNeedsCompositorUpdate() {
   layer_tree_host_->SetNeedsUpdateLayers();
 }
 
 void RenderWidgetCompositor::didStopFlinging() {
   layer_tree_host_->DidStopFlinging();
 }
 
 void RenderWidgetCompositor::registerViewportLayers(
     const blink::WebLayer* overscrollElasticityLayer,
     const blink::WebLayer* pageScaleLayer,
     const blink::WebLayer* innerViewportScrollLayer,
     const blink::WebLayer* outerViewportScrollLayer) {
-  layer_tree_host_->RegisterViewportLayers(
+  layer_tree_host_->GetLayerTree()->RegisterViewportLayers(
       // TODO(bokan): This check can probably be removed now, but it looks
       // like overscroll elasticity may still be NULL until VisualViewport
       // registers its layers.
       // The scroll elasticity layer will only exist when using pinch virtual
       // viewports.
       overscrollElasticityLayer
           ? static_cast<const cc_blink::WebLayerImpl*>(
-                overscrollElasticityLayer)->layer()
+                overscrollElasticityLayer)
+                ->layer()
           : NULL,
       static_cast<const cc_blink::WebLayerImpl*>(pageScaleLayer)->layer(),
       static_cast<const cc_blink::WebLayerImpl*>(innerViewportScrollLayer)
           ->layer(),
       // TODO(bokan): This check can probably be removed now, but it looks
       // like overscroll elasticity may still be NULL until VisualViewport
       // registers its layers.
       // The outer viewport layer will only exist when using pinch virtual
       // viewports.
       outerViewportScrollLayer
           ? static_cast<const cc_blink::WebLayerImpl*>(outerViewportScrollLayer)
                 ->layer()
           : NULL);
 }
 
 void RenderWidgetCompositor::clearViewportLayers() {
-  layer_tree_host_->RegisterViewportLayers(
+  layer_tree_host_->GetLayerTree()->RegisterViewportLayers(
       scoped_refptr<cc::Layer>(), scoped_refptr<cc::Layer>(),
       scoped_refptr<cc::Layer>(), scoped_refptr<cc::Layer>());
 }
 
 void RenderWidgetCompositor::registerSelection(
     const blink::WebSelection& selection) {
-  layer_tree_host_->RegisterSelection(ConvertWebSelection(selection));
+  layer_tree_host_->GetLayerTree()->RegisterSelection(
+      ConvertWebSelection(selection));
 }
 
 void RenderWidgetCompositor::clearSelection() {
   cc::LayerSelection empty_selection;
-  layer_tree_host_->RegisterSelection(empty_selection);
+  layer_tree_host_->GetLayerTree()->RegisterSelection(empty_selection);
 }
 
 void RenderWidgetCompositor::setMutatorClient(
     std::unique_ptr<blink::WebCompositorMutatorClient> client) {
   TRACE_EVENT0("compositor-worker", "RenderWidgetCompositor::setMutatorClient");
   layer_tree_host_->SetLayerTreeMutator(std::move(client));
 }
 
 static_assert(static_cast<cc::EventListenerClass>(
                   blink::WebEventListenerClass::TouchStartOrMove) ==
@@ skipping 17 matching lines @@
                   cc::EventListenerProperties::kBlocking,
               "EventListener and WebEventListener enums must match");
 static_assert(static_cast<cc::EventListenerProperties>(
                   blink::WebEventListenerProperties::BlockingAndPassive) ==
                   cc::EventListenerProperties::kBlockingAndPassive,
               "EventListener and WebEventListener enums must match");
 
 void RenderWidgetCompositor::setEventListenerProperties(
     blink::WebEventListenerClass eventClass,
     blink::WebEventListenerProperties properties) {
-  layer_tree_host_->SetEventListenerProperties(
+  layer_tree_host_->GetLayerTree()->SetEventListenerProperties(
       static_cast<cc::EventListenerClass>(eventClass),
       static_cast<cc::EventListenerProperties>(properties));
 }
 
 blink::WebEventListenerProperties
 RenderWidgetCompositor::eventListenerProperties(
     blink::WebEventListenerClass event_class) const {
   return static_cast<blink::WebEventListenerProperties>(
-      layer_tree_host_->event_listener_properties(
+      layer_tree_host_->GetLayerTree()->event_listener_properties(
           static_cast<cc::EventListenerClass>(event_class)));
 }
 
 void RenderWidgetCompositor::setHaveScrollEventHandlers(bool has_handlers) {
-  layer_tree_host_->SetHaveScrollEventHandlers(has_handlers);
+  layer_tree_host_->GetLayerTree()->SetHaveScrollEventHandlers(has_handlers);
 }
 
 bool RenderWidgetCompositor::haveScrollEventHandlers() const {
-  return layer_tree_host_->have_scroll_event_handlers();
+  return layer_tree_host_->GetLayerTree()->have_scroll_event_handlers();
 }
 
 void CompositeAndReadbackAsyncCallback(
     blink::WebCompositeAndReadbackAsyncCallback* callback,
     std::unique_ptr<cc::CopyOutputResult> result) {
   if (result->HasBitmap()) {
     std::unique_ptr<SkBitmap> result_bitmap = result->TakeBitmap();
     callback->didCompositeAndReadback(*result_bitmap);
   } else {
     callback->didCompositeAndReadback(SkBitmap());
@@ skipping 107 matching lines @@
 void RenderWidgetCompositor::updateTopControlsState(
     WebTopControlsState constraints,
     WebTopControlsState current,
     bool animate) {
   layer_tree_host_->UpdateTopControlsState(ConvertTopControlsState(constraints),
                                            ConvertTopControlsState(current),
                                            animate);
 }
 
 void RenderWidgetCompositor::setTopControlsHeight(float height, bool shrink) {
-    layer_tree_host_->SetTopControlsHeight(height, shrink);
+  layer_tree_host_->GetLayerTree()->SetTopControlsHeight(height, shrink);
 }
 
 void RenderWidgetCompositor::setTopControlsShownRatio(float ratio) {
-  layer_tree_host_->SetTopControlsShownRatio(ratio);
+  layer_tree_host_->GetLayerTree()->SetTopControlsShownRatio(ratio);
 }
 
 void RenderWidgetCompositor::WillBeginMainFrame() {
   delegate_->WillBeginCompositorFrame();
 }
 
 void RenderWidgetCompositor::DidBeginMainFrame() {
 }
 
 void RenderWidgetCompositor::BeginMainFrame(const cc::BeginFrameArgs& args) {
@@ skipping 121 matching lines @@
   if (!deserialized->ParseFromArray(proto.data(), signed_size)) {
     LOG(ERROR) << "Unable to parse compositor proto.";
     return;
   }
 
   remote_proto_channel_receiver_->OnProtoReceived(std::move(deserialized));
 }
 
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
-  layer_tree_host_->SetPaintedDeviceScaleFactor(device_scale);
+  layer_tree_host_->GetLayerTree()->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 }  // namespace content