cc: Reland Move data to LayerTree from LayerTreeHost.

third_party/WebKit/Source/platform/testing/WebLayerTreeViewImplForTesting.cpp

 // Copyright 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 "platform/testing/WebLayerTreeViewImplForTesting.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/blink/web_layer_impl.h"
@@ skipping 49 matching lines @@
     return settings;
 }
 
 bool WebLayerTreeViewImplForTesting::hasLayer(const WebLayer& layer)
 {
     return layer.ccLayer()->layer_tree_host() == m_layerTreeHost.get();
 }
 
 void WebLayerTreeViewImplForTesting::setRootLayer(const blink::WebLayer& root)
 {
-    m_layerTreeHost->SetRootLayer(static_cast<const cc_blink::WebLayerImpl*>(&root)->layer());
+    m_layerTreeHost->GetLayerTree()->SetRootLayer(static_cast<const cc_blink::WebLayerImpl*>(&root)->layer());
 }
 
 void WebLayerTreeViewImplForTesting::clearRootLayer()
 {
-    m_layerTreeHost->SetRootLayer(scoped_refptr<cc::Layer>());
+    m_layerTreeHost->GetLayerTree()->SetRootLayer(scoped_refptr<cc::Layer>());
 }
 
 void WebLayerTreeViewImplForTesting::attachCompositorAnimationTimeline(cc::AnimationTimeline* compositorTimeline)
 {
     ASSERT(m_layerTreeHost->animation_host());
     m_layerTreeHost->animation_host()->AddAnimationTimeline(compositorTimeline);
 }
 
 void WebLayerTreeViewImplForTesting::detachCompositorAnimationTimeline(cc::AnimationTimeline* compositorTimeline)
 {
     ASSERT(m_layerTreeHost->animation_host());
     m_layerTreeHost->animation_host()->RemoveAnimationTimeline(compositorTimeline);
 }
 
 void WebLayerTreeViewImplForTesting::setViewportSize(const WebSize& unusedDeprecated, const WebSize& deviceViewportSize)
 {
     gfx::Size gfxSize(std::max(0, deviceViewportSize.width), std::max(0, deviceViewportSize.height));
-    m_layerTreeHost->SetViewportSize(gfxSize);
+    m_layerTreeHost->GetLayerTree()->SetViewportSize(gfxSize);
 }
 
 void WebLayerTreeViewImplForTesting::setViewportSize(const WebSize& deviceViewportSize)
 {
     gfx::Size gfxSize(std::max(0, deviceViewportSize.width), std::max(0, deviceViewportSize.height));
-    m_layerTreeHost->SetViewportSize(gfxSize);
+    m_layerTreeHost->GetLayerTree()->SetViewportSize(gfxSize);
 }
 
 void WebLayerTreeViewImplForTesting::setDeviceScaleFactor(float deviceScaleFactor)
 {
-    m_layerTreeHost->SetDeviceScaleFactor(deviceScaleFactor);
+    m_layerTreeHost->GetLayerTree()->SetDeviceScaleFactor(deviceScaleFactor);
 }
 
 void WebLayerTreeViewImplForTesting::setBackgroundColor(WebColor color)
 {
-    m_layerTreeHost->set_background_color(color);
+    m_layerTreeHost->GetLayerTree()->set_background_color(color);
 }
 
 void WebLayerTreeViewImplForTesting::setHasTransparentBackground(bool transparent)
 {
-    m_layerTreeHost->set_has_transparent_background(transparent);
+    m_layerTreeHost->GetLayerTree()->set_has_transparent_background(transparent);
 }
 
 void WebLayerTreeViewImplForTesting::setVisible(bool visible)
 {
     m_layerTreeHost->SetVisible(visible);
 }
 
 void WebLayerTreeViewImplForTesting::setPageScaleFactorAndLimits(
     float pageScaleFactor,
     float minimum,
     float maximum)
 {
-    m_layerTreeHost->SetPageScaleFactorAndLimits(pageScaleFactor, minimum, maximum);
+    m_layerTreeHost->GetLayerTree()->SetPageScaleFactorAndLimits(pageScaleFactor, minimum, maximum);
 }
 
 void WebLayerTreeViewImplForTesting::startPageScaleAnimation(
     const blink::WebPoint& scroll,
     bool useAnchor,
     float newPageScale,
     double durationSec) {}
 
 void WebLayerTreeViewImplForTesting::setNeedsAnimate()
 {
@@ skipping 29 matching lines @@
 {
     ASSERT_NOT_REACHED();
 }
 
 void WebLayerTreeViewImplForTesting::registerViewportLayers(
     const blink::WebLayer* overscrollElasticityLayer,
     const blink::WebLayer* pageScaleLayer,
     const blink::WebLayer* innerViewportScrollLayer,
     const blink::WebLayer* outerViewportScrollLayer)
 {
-    m_layerTreeHost->RegisterViewportLayers(
+    m_layerTreeHost->GetLayerTree()->RegisterViewportLayers(
         // The scroll elasticity layer will only exist when using pinch virtual
         // viewports.
         overscrollElasticityLayer
             ? static_cast<const cc_blink::WebLayerImpl*>(overscrollElasticityLayer)->layer()
             : nullptr,
         static_cast<const cc_blink::WebLayerImpl*>(pageScaleLayer)->layer(),
         static_cast<const cc_blink::WebLayerImpl*>(innerViewportScrollLayer)->layer(),
         // The outer viewport layer will only exist when using pinch virtual
         // viewports.
         outerViewportScrollLayer
             ? static_cast<const cc_blink::WebLayerImpl*>(outerViewportScrollLayer)->layer()
             : nullptr);
 }
 
 void WebLayerTreeViewImplForTesting::clearViewportLayers()
 {
-    m_layerTreeHost->RegisterViewportLayers(scoped_refptr<cc::Layer>(),
+    m_layerTreeHost->GetLayerTree()->RegisterViewportLayers(scoped_refptr<cc::Layer>(),
         scoped_refptr<cc::Layer>(),
         scoped_refptr<cc::Layer>(),
         scoped_refptr<cc::Layer>());
 }
 
 void WebLayerTreeViewImplForTesting::registerSelection(const blink::WebSelection& selection)
 {
 }
 
 void WebLayerTreeViewImplForTesting::clearSelection()
 {
 }
 
 void WebLayerTreeViewImplForTesting::setEventListenerProperties(
     blink::WebEventListenerClass eventClass,
     blink::WebEventListenerProperties properties)
 {
     // Equality of static_cast is checked in render_widget_compositor.cc.
-    m_layerTreeHost->SetEventListenerProperties(
+    m_layerTreeHost->GetLayerTree()->SetEventListenerProperties(
         static_cast<cc::EventListenerClass>(eventClass),
         static_cast<cc::EventListenerProperties>(properties));
 }
 
 blink::WebEventListenerProperties
 WebLayerTreeViewImplForTesting::eventListenerProperties(blink::WebEventListenerClass eventClass) const
 {
     // Equality of static_cast is checked in render_widget_compositor.cc.
     return static_cast<blink::WebEventListenerProperties>(
-        m_layerTreeHost->event_listener_properties(
+        m_layerTreeHost->GetLayerTree()->event_listener_properties(
             static_cast<cc::EventListenerClass>(eventClass)));
 }
 
 void WebLayerTreeViewImplForTesting::setHaveScrollEventHandlers(bool haveEentHandlers)
 {
-    m_layerTreeHost->SetHaveScrollEventHandlers(haveEentHandlers);
+    m_layerTreeHost->GetLayerTree()->SetHaveScrollEventHandlers(haveEentHandlers);
 }
 
 bool WebLayerTreeViewImplForTesting::haveScrollEventHandlers() const
 {
-    return m_layerTreeHost->have_scroll_event_handlers();
+    return m_layerTreeHost->GetLayerTree()->have_scroll_event_handlers();
 }
 
 } // namespace blink