cc: Merge LayerTree into the 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 <cmath>
 #include <limits>
@@ skipping 572 matching lines @@
   DCHECK(!layer_tree_host_->IsVisible());
   never_visible_ = true;
 }
 
 const base::WeakPtr<cc::InputHandler>&
 RenderWidgetCompositor::GetInputHandler() {
   return layer_tree_host_->GetInputHandler();
 }
 
 void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
-  layer_tree_host_->GetLayerTree()->SetNeedsDisplayOnAllLayers();
+  layer_tree_host_->SetNeedsDisplayOnAllLayers();
 }
 
 void RenderWidgetCompositor::SetRasterizeOnlyVisibleContent() {
   cc::LayerTreeDebugState current = layer_tree_host_->GetDebugState();
   current.rasterize_only_visible_content = true;
   layer_tree_host_->SetDebugState(current);
 }
 
 void RenderWidgetCompositor::SetNeedsRedrawRect(gfx::Rect damage_rect) {
   layer_tree_host_->SetNeedsRedrawRect(damage_rect);
@@ skipping 26 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_->GetLayerTree()->root_layer();
+  return layer_tree_host_->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_->GetLayerTree()->SetRootLayer(
+  layer_tree_host_->SetRootLayer(
       static_cast<const cc_blink::WebLayerImpl*>(&layer)->layer());
 }
 
 void RenderWidgetCompositor::clearRootLayer() {
-  layer_tree_host_->GetLayerTree()->SetRootLayer(scoped_refptr<cc::Layer>());
+  layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
 }
 
 cc::AnimationHost* RenderWidgetCompositor::compositorAnimationHost() {
   return animation_host_.get();
 }
 
 void RenderWidgetCompositor::setViewportSize(
     const WebSize& device_viewport_size) {
-  layer_tree_host_->GetLayerTree()->SetViewportSize(device_viewport_size);
+  layer_tree_host_->SetViewportSize(device_viewport_size);
 }
 
 WebSize RenderWidgetCompositor::getViewportSize() const {
-  return layer_tree_host_->GetLayerTree()->device_viewport_size();
+  return layer_tree_host_->device_viewport_size();
 }
 
 WebFloatPoint RenderWidgetCompositor::adjustEventPointForPinchZoom(
     const WebFloatPoint& point) const {
   return point;
 }
 
 void RenderWidgetCompositor::setDeviceScaleFactor(float device_scale) {
-  layer_tree_host_->GetLayerTree()->SetDeviceScaleFactor(device_scale);
+  layer_tree_host_->SetDeviceScaleFactor(device_scale);
 }
 
 void RenderWidgetCompositor::setBackgroundColor(blink::WebColor color) {
-  layer_tree_host_->GetLayerTree()->set_background_color(color);
+  layer_tree_host_->set_background_color(color);
 }
 
 void RenderWidgetCompositor::setHasTransparentBackground(bool transparent) {
-  layer_tree_host_->GetLayerTree()->set_has_transparent_background(transparent);
+  layer_tree_host_->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_->GetLayerTree()->SetPageScaleFactorAndLimits(
-      page_scale_factor, minimum, maximum);
+  layer_tree_host_->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_->GetLayerTree()->StartPageScaleAnimation(
+  layer_tree_host_->StartPageScaleAnimation(
       gfx::Vector2d(destination.x, destination.y), use_anchor, new_page_scale,
       duration);
 }
 
 bool RenderWidgetCompositor::hasPendingPageScaleAnimation() const {
-  return layer_tree_host_->GetLayerTree()->HasPendingPageScaleAnimation();
+  return layer_tree_host_->HasPendingPageScaleAnimation();
 }
 
 void RenderWidgetCompositor::heuristicsForGpuRasterizationUpdated(
     bool matches_heuristics) {
   layer_tree_host_->SetHasGpuRasterizationTrigger(matches_heuristics);
 }
 
 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_->GetLayerTree()->RegisterViewportLayers(
+  layer_tree_host_->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()
           : 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_->GetLayerTree()->RegisterViewportLayers(
+  layer_tree_host_->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_->GetLayerTree()->RegisterSelection(
-      ConvertWebSelection(selection));
+  layer_tree_host_->RegisterSelection(ConvertWebSelection(selection));
 }
 
 void RenderWidgetCompositor::clearSelection() {
   cc::LayerSelection empty_selection;
-  layer_tree_host_->GetLayerTree()->RegisterSelection(empty_selection);
+  layer_tree_host_->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));
 }
 
 void RenderWidgetCompositor::forceRecalculateRasterScales() {
   layer_tree_host_->SetNeedsRecalculateRasterScales();
@@ skipping 21 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_->GetLayerTree()->SetEventListenerProperties(
+  layer_tree_host_->SetEventListenerProperties(
       static_cast<cc::EventListenerClass>(eventClass),
       static_cast<cc::EventListenerProperties>(properties));
 }
 
 void RenderWidgetCompositor::updateTouchRectsForSubframeIfNecessary() {
   if (!is_for_oopif_)
     return;
 
   // If this is an oopif sub-frame compositor, we won't be getting TouchRects
   // from ScrollingCoordinator, so to make sure touch events are handled
   // properly, mark the entire root layer as a TouchRect.
   // TODO(wjmaclean): remove this when ScrollingCoordinator is made per-frame,
   // as opposed to per-page.
   using blink::WebEventListenerProperties;
   using blink::WebEventListenerClass;
 
   blink::WebEventListenerProperties touch_start_properties =
       eventListenerProperties(WebEventListenerClass::TouchStartOrMove);
   blink::WebEventListenerProperties touch_end_cancel_properties =
       eventListenerProperties(WebEventListenerClass::TouchEndOrCancel);
   bool has_touch_handlers =
       touch_start_properties == WebEventListenerProperties::Blocking ||
       touch_start_properties ==
           WebEventListenerProperties::BlockingAndPassive ||
       touch_end_cancel_properties == WebEventListenerProperties::Blocking ||
       touch_end_cancel_properties ==
           WebEventListenerProperties::BlockingAndPassive;
 
-  cc::Layer* root_layer = layer_tree_host_->GetLayerTree()->root_layer();
+  cc::Layer* root_layer = layer_tree_host_->root_layer();
   cc::Region touch_handler_region;
   if (has_touch_handlers)
     touch_handler_region = gfx::Rect(gfx::Point(), root_layer->bounds());
   root_layer->SetTouchEventHandlerRegion(touch_handler_region);
 }
 
 blink::WebEventListenerProperties
 RenderWidgetCompositor::eventListenerProperties(
     blink::WebEventListenerClass event_class) const {
   return static_cast<blink::WebEventListenerProperties>(
-      layer_tree_host_->GetLayerTree()->event_listener_properties(
+      layer_tree_host_->event_listener_properties(
           static_cast<cc::EventListenerClass>(event_class)));
 }
 
 void RenderWidgetCompositor::setHaveScrollEventHandlers(bool has_handlers) {
-  layer_tree_host_->GetLayerTree()->SetHaveScrollEventHandlers(has_handlers);
+  layer_tree_host_->SetHaveScrollEventHandlers(has_handlers);
 }
 
 bool RenderWidgetCompositor::haveScrollEventHandlers() const {
-  return layer_tree_host_->GetLayerTree()->have_scroll_event_handlers();
+  return layer_tree_host_->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 108 matching lines @@
     WebBrowserControlsState constraints,
     WebBrowserControlsState current,
     bool animate) {
   layer_tree_host_->UpdateBrowserControlsState(
       ConvertBrowserControlsState(constraints),
       ConvertBrowserControlsState(current), animate);
 }
 
 void RenderWidgetCompositor::setBrowserControlsHeight(float height,
                                                       bool shrink) {
-  layer_tree_host_->GetLayerTree()->SetBrowserControlsHeight(height, shrink);
+  layer_tree_host_->SetBrowserControlsHeight(height, shrink);
 }
 
 void RenderWidgetCompositor::setBrowserControlsShownRatio(float ratio) {
-  layer_tree_host_->GetLayerTree()->SetBrowserControlsShownRatio(ratio);
+  layer_tree_host_->SetBrowserControlsShownRatio(ratio);
 }
 
 void RenderWidgetCompositor::setBottomControlsHeight(float height) {
-  layer_tree_host_->GetLayerTree()->SetBottomControlsHeight(height);
+  layer_tree_host_->SetBottomControlsHeight(height);
 }
 
 void RenderWidgetCompositor::WillBeginMainFrame() {
   delegate_->WillBeginCompositorFrame();
 }
 
 void RenderWidgetCompositor::DidBeginMainFrame() {
 }
 
 void RenderWidgetCompositor::BeginMainFrame(const cc::BeginFrameArgs& args) {
@@ skipping 92 matching lines @@
 }
 
 void RenderWidgetCompositor::SetFrameSinkId(
     const cc::FrameSinkId& frame_sink_id) {
   frame_sink_id_ = frame_sink_id;
   layer_tree_host_->SetFrameSinkId(frame_sink_id);
 }
 
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
-  layer_tree_host_->GetLayerTree()->SetPaintedDeviceScaleFactor(device_scale);
+  layer_tree_host_->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 void RenderWidgetCompositor::SetDeviceColorSpace(
     const gfx::ColorSpace& color_space) {
-  layer_tree_host_->GetLayerTree()->SetDeviceColorSpace(color_space);
+  layer_tree_host_->SetDeviceColorSpace(color_space);
 }
 
 void RenderWidgetCompositor::SetIsForOopif(bool is_for_oopif) {
   is_for_oopif_ = is_for_oopif;
 }
 
 }  // namespace content