Remove m_layerTreeView from WebViewImpl.

sky/engine/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 132 matching lines @@
     , m_spellCheckerClientImpl(this)
     , m_fixedLayoutSizeLock(false)
     , m_doingDragAndDrop(false)
     , m_ignoreInputEvents(false)
     , m_compositorDeviceScaleFactorOverride(0)
     , m_rootLayerScale(1)
     , m_suppressNextKeypressEvent(false)
     , m_imeAcceptEvents(true)
     , m_isTransparent(false)
     , m_tabsToLinks(false)
-    , m_layerTreeView(0)
     , m_rootLayer(0)
     , m_rootGraphicsLayer(0)
     , m_rootTransformLayer(0)
-    , m_graphicsLayerFactory(adoptPtr(new GraphicsLayerFactoryChromium(this)))
-    , m_isAcceleratedCompositingActive(false)
-    , m_layerTreeViewCommitsDeferred(false)
-    , m_layerTreeViewClosed(false)
+    , m_graphicsLayerFactory(adoptPtr(new GraphicsLayerFactoryChromium()))
     , m_matchesHeuristicsForGpuRasterization(false)
     , m_recreatingGraphicsContext(false)
     , m_flingModifier(0)
     , m_flingSourceDevice(false)
     , m_showFPSCounter(false)
     , m_showPaintRects(false)
     , m_showDebugBorders(false)
     , m_continuousPaintingEnabled(false)
     , m_showScrollBottleneckRects(false)
     , m_baseBackgroundColor(Color::white)
     , m_backgroundColorOverride(Color::transparent)
     , m_userGestureObserved(false)
 {
     Page::PageClients pageClients;
     pageClients.chromeClient = &m_chromeClientImpl;
     pageClients.editorClient = &m_editorClientImpl;
     pageClients.spellCheckerClient = &m_spellCheckerClientImpl;
 
     m_page = adoptPtr(new Page(pageClients, m_client->services()));
 
     setDeviceScaleFactor(m_client->screenInfo().deviceScaleFactor);
     setVisibilityState(m_client->visibilityState(), true);
 
     m_client->initializeLayerTreeView();
-    // FIXME(sky): Get rid of this member variable. It's unused.
-    m_layerTreeView = nullptr;
 }
 
 WebViewImpl::~WebViewImpl()
 {
     ASSERT(!m_page);
 }
 
 WebLocalFrameImpl* WebViewImpl::mainFrameImpl()
 {
     return m_page ? WebLocalFrameImpl::fromFrame(m_page->mainFrame()) : 0;
@@ skipping 217 matching lines @@
     OwnPtr<WebGestureCurve> curve = adoptPtr(Platform::current()->createFlingAnimationCurve(parameters.sourceDevice, WebFloatPoint(parameters.delta), parameters.cumulativeScroll));
     ASSERT(curve);
     m_gestureAnimation = WebActiveGestureAnimation::createWithTimeOffset(curve.release(), this, parameters.startTime);
     scheduleAnimation();
 }
 
 bool WebViewImpl::endActiveFlingAnimation()
 {
     if (m_gestureAnimation) {
         m_gestureAnimation.clear();
-        if (m_layerTreeView)
-            m_layerTreeView->didStopFlinging();
         return true;
     }
     return false;
 }
 
 void WebViewImpl::setShowFPSCounter(bool show)
 {
-    if (m_layerTreeView) {
-        TRACE_EVENT0("blink", "WebViewImpl::setShowFPSCounter");
-        m_layerTreeView->setShowFPSCounter(show);
-    }
     m_showFPSCounter = show;
 }
 
 void WebViewImpl::setShowPaintRects(bool show)
 {
-    if (m_layerTreeView) {
-        TRACE_EVENT0("blink", "WebViewImpl::setShowPaintRects");
-        m_layerTreeView->setShowPaintRects(show);
-    }
     m_showPaintRects = show;
 }
 
 void WebViewImpl::setShowDebugBorders(bool show)
 {
-    if (m_layerTreeView)
-        m_layerTreeView->setShowDebugBorders(show);
     m_showDebugBorders = show;
 }
 
 void WebViewImpl::setContinuousPaintingEnabled(bool enabled)
 {
-    if (m_layerTreeView) {
-        TRACE_EVENT0("blink", "WebViewImpl::setContinuousPaintingEnabled");
-        m_layerTreeView->setContinuousPaintingEnabled(enabled);
-    }
     m_continuousPaintingEnabled = enabled;
     m_client->scheduleAnimation();
 }
 
 void WebViewImpl::setShowScrollBottleneckRects(bool show)
 {
-    if (m_layerTreeView)
-        m_layerTreeView->setShowScrollBottleneckRects(show);
     m_showScrollBottleneckRects = show;
 }
 
 void WebViewImpl::getSelectionRootBounds(WebRect& bounds) const
 {
     const LocalFrame* frame = focusedCoreFrame();
     if (!frame)
         return;
 
     Element* root = frame->selection().rootEditableElementOrDocumentElement();
@@ skipping 461 matching lines @@
 {
 }
 
 void WebViewImpl::layout()
 {
     TRACE_EVENT0("blink", "WebViewImpl::layout");
     if (!localFrameRootTemporary())
         return;
 
     PageWidgetDelegate::layout(m_page.get(), localFrameRootTemporary()->frame());
-    updateLayerTreeBackgroundColor();
 
     for (size_t i = 0; i < m_linkHighlights.size(); ++i)
         m_linkHighlights[i]->updateGeometry();
 }
 
 void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect)
 {
-    // This should only be used when compositing is not being used for this
-    // WebView, and it is painting into the recording of its parent.
-    ASSERT(!isAcceleratedCompositingActive());
-
     double paintStart = currentTime();
     PageWidgetDelegate::paint(m_page.get(), canvas, rect, isTransparent() ? PageWidgetDelegate::Translucent : PageWidgetDelegate::Opaque);
     double paintEnd = currentTime();
     double pixelsPerSec = (rect.width * rect.height) / (paintEnd - paintStart);
     Platform::current()->histogramCustomCounts("Renderer4.SoftwarePaintDurationMS", (paintEnd - paintStart) * 1000, 0, 120, 30);
     Platform::current()->histogramCustomCounts("Renderer4.SoftwarePaintMegapixPerSecond", pixelsPerSec / 1000000, 10, 210, 30);
 }
 
-#if OS(ANDROID)
-void WebViewImpl::paintCompositedDeprecated(WebCanvas* canvas, const WebRect& rect)
-{
-    // Note: This method exists on OS(ANDROID) and will hopefully be
-    //       removed once the link disambiguation feature renders using
-    //       the compositor.
-    ASSERT(isAcceleratedCompositingActive());
-
-    FrameView* view = page()->mainFrame()->view();
-    PaintBehavior oldPaintBehavior = view->paintBehavior();
-    view->setPaintBehavior(oldPaintBehavior | PaintBehaviorFlattenCompositingLayers);
-
-    PageWidgetDelegate::paint(m_page.get(), canvas, rect, isTransparent() ? PageWidgetDelegate::Translucent : PageWidgetDelegate::Opaque);
-
-    view->setPaintBehavior(oldPaintBehavior);
-}
-#endif
-
-void WebViewImpl::compositeAndReadbackAsync(WebCompositeAndReadbackAsyncCallback* callback)
-{
-    ASSERT(isAcceleratedCompositingActive());
-    m_layerTreeView->compositeAndReadbackAsync(callback);
-}
-
 bool WebViewImpl::isTrackingRepaints() const
 {
     if (!page())
         return false;
     FrameView* view = page()->mainFrame()->view();
     return view->isTrackingPaintInvalidations();
 }
 
 void WebViewImpl::themeChanged()
 {
     if (!page())
         return;
     FrameView* view = page()->mainFrame()->view();
 
     WebRect damagedRect(0, 0, m_size.width, m_size.height);
     view->invalidateRect(damagedRect);
 }
 
-void WebViewImpl::clearCompositedSelectionBounds()
-{
-    if (m_layerTreeView)
-        m_layerTreeView->clearSelection();
-}
-
 bool WebViewImpl::hasHorizontalScrollbar()
 {
     // FIXME(sky): Remove
     return false;
 }
 
 bool WebViewImpl::hasVerticalScrollbar()
 {
     // FIXME(sky): Remove
     return false;
@@ skipping 509 matching lines @@
     case WebTextDirectionRightToLeft:
         editor.setBaseWritingDirection(RightToLeftWritingDirection);
         break;
 
     default:
         notImplemented();
         break;
     }
 }
 
-bool WebViewImpl::isAcceleratedCompositingActive() const
-{
-    return m_isAcceleratedCompositingActive;
-}
-
-void WebViewImpl::willCloseLayerTreeView()
-{
-    setIsAcceleratedCompositingActive(false);
-    m_layerTreeView = 0;
-    m_layerTreeViewClosed = true;
-}
-
 // WebView --------------------------------------------------------------------
 
 WebSettingsImpl* WebViewImpl::settingsImpl()
 {
     if (!m_webSettings)
         m_webSettings = adoptPtr(new WebSettingsImpl(&m_page->settings()));
     ASSERT(m_webSettings);
     return m_webSettings.get();
 }
 
@@ skipping 129 matching lines @@
 
     return page()->deviceScaleFactor();
 }
 
 void WebViewImpl::setDeviceScaleFactor(float scaleFactor)
 {
     if (!page())
         return;
 
     page()->setDeviceScaleFactor(scaleFactor);
-
-    if (m_layerTreeView)
-        updateLayerTreeDeviceScaleFactor();
 }
 
 void WebViewImpl::updateMainFrameLayoutSize()
 {
     if (m_fixedLayoutSizeLock || !mainFrameImpl())
         return;
 
     RefPtr<FrameView> view = mainFrameImpl()->frameView();
     if (!view)
         return;
@@ skipping 130 matching lines @@
 void WebViewImpl::sendResizeEventAndRepaint()
 {
     // FIXME: This is wrong. The FrameView is responsible sending a resizeEvent
     // as part of layout. Layout is also responsible for sending invalidations
     // to the embedder. This method and all callers may be wrong. -- eseidel.
     if (localFrameRootTemporary()->frameView()) {
         // Enqueues the resize event.
         localFrameRootTemporary()->frame()->document()->enqueueResizeEvent();
     }
 
-    if (!isAcceleratedCompositingActive()) {
-        WebRect damagedRect(0, 0, m_size.width, m_size.height);
-        m_client->didInvalidateRect(damagedRect);
-    }
+    WebRect damagedRect(0, 0, m_size.width, m_size.height);
+    m_client->didInvalidateRect(damagedRect);
 }
 
 void WebViewImpl::setCompositorDeviceScaleFactorOverride(float deviceScaleFactor)
 {
-    if (m_compositorDeviceScaleFactorOverride == deviceScaleFactor)
-        return;
     m_compositorDeviceScaleFactorOverride = deviceScaleFactor;
-    if (page() && m_layerTreeView)
-        updateLayerTreeDeviceScaleFactor();
 }
 
 void WebViewImpl::setRootLayerTransform(const WebSize& rootLayerOffset, float rootLayerScale)
 {
     if (m_rootLayerScale == rootLayerScale && m_rootLayerOffset == rootLayerOffset)
         return;
     m_rootLayerScale = rootLayerScale;
     m_rootLayerOffset = rootLayerOffset;
     if (mainFrameImpl())
         mainFrameImpl()->setInputEventsTransformForEmulation(m_rootLayerOffset, m_rootLayerScale);
@@ skipping 11 matching lines @@
 
     // Future frames check this to know whether to be transparent.
     m_isTransparent = isTransparent;
 }
 
 bool WebViewImpl::isTransparent() const
 {
     return m_isTransparent;
 }
 
+// FIXME(sky): This is an android webview feature. Remove it.
 void WebViewImpl::setBaseBackgroundColor(WebColor color)
 {
     layout();
 
     if (m_baseBackgroundColor == color)
         return;
 
     m_baseBackgroundColor = color;
 
     if (m_page->mainFrame())
         m_page->mainFrame()->view()->setBaseBackgroundColor(color);
-
-    updateLayerTreeBackgroundColor();
 }
 
 void WebViewImpl::setIsActive(bool active)
 {
     if (page())
         page()->focusController().setActive(active);
 }
 
 bool WebViewImpl::isActive() const
 {
@@ skipping 19 matching lines @@
 void WebViewImpl::didCommitLoad(bool isNewNavigation, bool isNavigationWithinPage)
 {
     // Make sure link highlight from previous page is cleared.
     m_linkHighlights.clear();
     endActiveFlingAnimation();
     m_userGestureObserved = false;
     if (!isNavigationWithinPage)
         UserGestureIndicator::clearProcessedUserGestureSinceLoad();
 }
 
-void WebViewImpl::didRemoveAllPendingStylesheet(WebLocalFrameImpl* webframe)
-{
-    if (webframe != mainFrameImpl())
-        return;
-
-    // If we have no more stylesheets to load and we're past the body tag,
-    // we should have something to paint and should start as soon as possible.
-    // FIXME(sky): This logic is probably wrong now.
-    resumeTreeViewCommits();
-}
-
-void WebViewImpl::resumeTreeViewCommits()
-{
-    if (m_layerTreeViewCommitsDeferred) {
-        if (m_layerTreeView)
-            m_layerTreeView->setDeferCommits(false);
-        m_layerTreeViewCommitsDeferred = false;
-    }
-}
-
 void WebViewImpl::layoutUpdated(WebLocalFrameImpl* webframe)
 {
     if (!m_client)
         return;
-
-    // If we finished a layout while in deferred commit mode,
-    // that means it's time to start producing frames again so un-defer.
-    resumeTreeViewCommits();
-
     m_client->didUpdateLayout();
 }
 
 void WebViewImpl::setIgnoreInputEvents(bool newValue)
 {
     ASSERT(m_ignoreInputEvents != newValue);
     m_ignoreInputEvents = newValue;
 }
 
 void WebViewImpl::setBackgroundColorOverride(WebColor color)
 {
     m_backgroundColorOverride = color;
-    updateLayerTreeBackgroundColor();
 }
 
 void WebViewImpl::setOverlayLayer(GraphicsLayer* layer)
 {
     if (!m_rootGraphicsLayer)
         return;
 
     // FIXME(bokan): This path goes away after virtual viewport pinch is enabled everywhere.
     if (!m_rootTransformLayer)
         m_rootTransformLayer = m_page->mainFrame()->view()->renderView()->compositor()->ensureRootTransformLayer();
@@ skipping 40 matching lines @@
 }
 
 void WebViewImpl::setRootGraphicsLayer(GraphicsLayer* layer)
 {
     suppressInvalidations(true);
 
     m_rootGraphicsLayer = layer;
     m_rootLayer = layer ? layer->platformLayer() : 0;
     m_rootTransformLayer = 0;
 
-    setIsAcceleratedCompositingActive(layer != 0);
-
     updateRootLayerTransform();
-
-    if (m_layerTreeView) {
-        if (m_rootLayer) {
-            m_layerTreeView->setRootLayer(*m_rootLayer);
-            // We register viewport layers here since there may not be a layer
-            // tree view prior to this point.
-            GraphicsLayer* rootScrollLayer = compositor()->scrollLayer();
-            ASSERT(rootScrollLayer);
-            WebLayer* pageScaleLayer = rootScrollLayer->parent() ? rootScrollLayer->parent()->platformLayer() : 0;
-            m_layerTreeView->registerViewportLayers(pageScaleLayer, rootScrollLayer->platformLayer(), 0);
-        } else {
-            m_layerTreeView->clearRootLayer();
-            m_layerTreeView->clearViewportLayers();
-        }
-    }
-
     suppressInvalidations(false);
 }
 
-void WebViewImpl::scheduleCompositingLayerSync()
-{
-    m_layerTreeView->setNeedsAnimate();
-}
-
 void WebViewImpl::invalidateRect(const IntRect& rect)
 {
-    if (!m_isAcceleratedCompositingActive) {
-        m_client->didInvalidateRect(rect);
-    }
+    m_client->didInvalidateRect(rect);
 }
 
 GraphicsLayerFactory* WebViewImpl::graphicsLayerFactory() const
 {
     return m_graphicsLayerFactory.get();
 }
 
 RenderLayerCompositor* WebViewImpl::compositor() const
 {
     if (!page() || !page()->mainFrame())
         return 0;
 
     if (!page()->mainFrame()->document() || !page()->mainFrame()->document()->renderView())
         return 0;
 
     return page()->mainFrame()->document()->renderView()->compositor();
 }
 
-void WebViewImpl::registerForAnimations(WebLayer* layer)
-{
-    if (m_layerTreeView)
-        m_layerTreeView->registerForAnimations(layer);
-}
-
 GraphicsLayer* WebViewImpl::rootGraphicsLayer()
 {
     return m_rootGraphicsLayer;
 }
 
 void WebViewImpl::scheduleAnimation()
 {
-    if (isAcceleratedCompositingActive()) {
-        ASSERT(m_layerTreeView);
-        m_layerTreeView->setNeedsAnimate();
-        return;
-    }
     m_client->scheduleAnimation();
 }
 
-void WebViewImpl::setIsAcceleratedCompositingActive(bool active)
-{
-    // In the middle of shutting down; don't try to spin back up a compositor.
-    // FIXME: compositing startup/shutdown should be refactored so that it
-    // turns on explicitly rather than lazily, which causes this awkwardness.
-    if (m_layerTreeViewClosed)
-        return;
-
-    ASSERT(!active || m_layerTreeView);
-    Platform::current()->histogramEnumeration("GPU.setIsAcceleratedCompositingActive", active * 2 + m_isAcceleratedCompositingActive, 4);
-
-    if (m_isAcceleratedCompositingActive == active)
-        return;
-
-    if (!m_client)
-        return;
-
-    if (!active) {
-        m_isAcceleratedCompositingActive = false;
-        if (!m_layerTreeViewCommitsDeferred) {
-            ASSERT(m_layerTreeView);
-            // This means that we're transitioning to a new page. Suppress commits until WebKit generates invalidations so
-            // we don't attempt to paint too early in the next page load.
-            m_layerTreeView->setDeferCommits(true);
-            m_layerTreeViewCommitsDeferred = true;
-        }
-    } else {
-        TRACE_EVENT0("blink", "WebViewImpl::setIsAcceleratedCompositingActive(true)");
-        m_layerTreeView->setRootLayer(*m_rootLayer);
-
-        bool visible = page()->visibilityState() == PageVisibilityStateVisible;
-        m_layerTreeView->setVisible(visible);
-        updateLayerTreeDeviceScaleFactor();
-        updateLayerTreeBackgroundColor();
-        m_layerTreeView->setHasTransparentBackground(isTransparent());
-        m_isAcceleratedCompositingActive = true;
-        m_layerTreeView->setShowFPSCounter(m_showFPSCounter);
-        m_layerTreeView->setShowPaintRects(m_showPaintRects);
-        m_layerTreeView->setShowDebugBorders(m_showDebugBorders);
-        m_layerTreeView->setContinuousPaintingEnabled(m_continuousPaintingEnabled);
-        m_layerTreeView->setShowScrollBottleneckRects(m_showScrollBottleneckRects);
-        m_layerTreeView->heuristicsForGpuRasterizationUpdated(m_matchesHeuristicsForGpuRasterization);
-    }
-}
-
 void WebViewImpl::updateMainFrameScrollPosition(const IntPoint& scrollPosition, bool programmaticScroll)
 {
     // FIXME(sky): Remove
 }
 
-void WebViewImpl::updateLayerTreeBackgroundColor()
-{
-    if (!m_layerTreeView)
-        return;
-
-    m_layerTreeView->setBackgroundColor(alphaChannel(m_backgroundColorOverride) ? m_backgroundColorOverride : backgroundColor());
-}
-
-void WebViewImpl::updateLayerTreeDeviceScaleFactor()
-{
-    ASSERT(page());
-    ASSERT(m_layerTreeView);
-
-    float deviceScaleFactor = m_compositorDeviceScaleFactorOverride ? m_compositorDeviceScaleFactorOverride : page()->deviceScaleFactor();
-    m_layerTreeView->setDeviceScaleFactor(deviceScaleFactor);
-}
-
 void WebViewImpl::updateRootLayerTransform()
 {
     // If we don't have a root graphics layer, we won't bother trying to find
     // or update the transform layer.
     if (!m_rootGraphicsLayer)
         return;
 
     // FIXME(bokan): m_rootTransformLayer is always set here in pinch virtual viewport. This can go away once
     // that's default everywhere.
     if (!m_rootTransformLayer)
@@ skipping 32 matching lines @@
     return true;
 }
 
 void WebViewImpl::setVisibilityState(WebPageVisibilityState visibilityState,
                                      bool isInitialState) {
     if (!page())
         return;
 
     ASSERT(visibilityState == WebPageVisibilityStateVisible || visibilityState == WebPageVisibilityStateHidden);
     m_page->setVisibilityState(static_cast<PageVisibilityState>(static_cast<int>(visibilityState)), isInitialState);
-
-    if (m_layerTreeView) {
-        bool visible = visibilityState == WebPageVisibilityStateVisible;
-        m_layerTreeView->setVisible(visible);
-    }
 }
 
 bool WebViewImpl::shouldDisableDesktopWorkarounds()
 {
     return true;
 }
 
 } // namespace blink