Remove the ACCELERATED_COMPOSITING flag

author abucur@adobe.com <abucur@adobe.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>

Thu, 30 Jan 2014 10:22:36 +0000 (10:22 +0000)

committer abucur@adobe.com <abucur@adobe.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>

Thu, 30 Jan 2014 10:22:36 +0000 (10:22 +0000)
author abucur@adobe.com <abucur@adobe.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 30 Jan 2014 10:22:36 +0000 (10:22 +0000)
committer abucur@adobe.com <abucur@adobe.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 30 Jan 2014 10:22:36 +0000 (10:22 +0000)
diff --git a/Source/WTF/ChangeLog b/Source/WTF/ChangeLog

index a1721c6cf0b33ac49ec50e41961a8cd8adabfe61..ddd89bed7bfaf801b8f0d4d12d5230409f1023a2 100644 (file)
--- a/Source/WTF/ChangeLog
+++ b/Source/WTF/ChangeLog
@@ -1,3 +1,18 @@
+2014-01-30  Andrei Bucur  <abucur@adobe.com>
+
+        Remove the ACCELERATED_COMPOSITING flag
+        https://bugs.webkit.org/show_bug.cgi?id=127833
+
+        Reviewed by Antti Koivisto.
+
+        Remove the USE(ACCELERATED_COMPOSITING) conditionals from the code base and make AC
+        mandatory.
+
+        * wtf/OwnPtrCommon.h:
+        * wtf/Platform.h:
+        * wtf/efl/OwnPtrEfl.cpp:
+        (WTF::deleteOwnedPtr):
+
  2014-01-28  Michael Saboff  <msaboff@apple.com>
  
          Merge the jsCStack branch
diff --git a/Source/WTF/wtf/OwnPtrCommon.h b/Source/WTF/wtf/OwnPtrCommon.h

index c31847b8b81cbceebaa0aba46f9d465bd106aa7a..a19621e13a960a33caef0ca6523c7c1265d4d45e 100644 (file)
--- a/Source/WTF/wtf/OwnPtrCommon.h
+++ b/Source/WTF/wtf/OwnPtrCommon.h
@@ -39,10 +39,8 @@ typedef struct _Eo_Opaque Evas_Object;
  #else
  typedef struct _Evas_Object Evas_Object;
  #endif
-#if USE(ACCELERATED_COMPOSITING)
  typedef struct _Evas_GL Evas_GL;
  #endif
-#endif
  
  namespace WTF {
  
@@ -60,10 +58,8 @@ namespace WTF {
      WTF_EXPORT_PRIVATE void deleteOwnedPtr(Eina_Hash*);
      WTF_EXPORT_PRIVATE void deleteOwnedPtr(Eina_Module*);
      WTF_EXPORT_PRIVATE void deleteOwnedPtr(Evas_Object*);
-#if USE(ACCELERATED_COMPOSITING)
      WTF_EXPORT_PRIVATE void deleteOwnedPtr(Evas_GL*);
  #endif
-#endif
  
  } // namespace WTF
  
diff --git a/Source/WTF/wtf/Platform.h b/Source/WTF/wtf/Platform.h

index a0da5591489d183578fd31ed598f0ffe8f263a9b..dd112e3ed72caf26614aa386b356d2a8eb108f93 100644 (file)
--- a/Source/WTF/wtf/Platform.h
+++ b/Source/WTF/wtf/Platform.h
@@ -854,11 +854,6 @@
  #endif
  #endif
  
-/* Accelerated compositing */
-#if PLATFORM(MAC) || PLATFORM(IOS) || (PLATFORM(WIN) && !USE(WINGDI) && !PLATFORM(WIN_CAIRO))
-#define WTF_USE_ACCELERATED_COMPOSITING 1
-#endif
-
  #if ENABLE(WEBGL) && !defined(WTF_USE_3D_GRAPHICS)
  #define WTF_USE_3D_GRAPHICS 1
  #endif
@@ -875,7 +870,7 @@
  #define GST_API_VERSION_1 1
  #endif
  
-#if USE(ACCELERATED_COMPOSITING) && PLATFORM(WIN_CAIRO)
+#if PLATFORM(WIN_CAIRO)
  #define WTF_USE_TEXTURE_MAPPER 1
  #endif
  
diff --git a/Source/WTF/wtf/efl/OwnPtrEfl.cpp b/Source/WTF/wtf/efl/OwnPtrEfl.cpp

index 4b289f8598c13de8b517c80c362103dfc03c602f..2634bcfc9c55a81434e05957d4fff8bbf406f7ba 100644 (file)
--- a/Source/WTF/wtf/efl/OwnPtrEfl.cpp
+++ b/Source/WTF/wtf/efl/OwnPtrEfl.cpp
@@ -32,10 +32,7 @@
  #include <Ecore_IMF.h>
  #include <Eina.h>
  #include <Evas.h>
-
-#if USE(ACCELERATED_COMPOSITING)
  #include <Evas_GL.h>
-#endif
  
  namespace WTF {
  
@@ -69,12 +66,10 @@ void deleteOwnedPtr(Ecore_IMF_Context* ptr)
          ecore_imf_context_del(ptr);
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  void deleteOwnedPtr(Evas_GL* ptr)
  {
      if (ptr)
          evas_gl_free(ptr);
  }
-#endif
  
  }
diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog

index d79fa3f72f6a9342fe616a89a3f385fcb0d8aa19..8b00978504f1755c7b805615c9328fa0c4d7afd4 100644 (file)
--- a/Source/WebCore/ChangeLog
+++ b/Source/WebCore/ChangeLog
@@ -1,3 +1,434 @@
+2014-01-30  Andrei Bucur  <abucur@adobe.com>
+
+        Remove the ACCELERATED_COMPOSITING flag
+        https://bugs.webkit.org/show_bug.cgi?id=127833
+
+        Reviewed by Antti Koivisto.
+
+        Remove the USE(ACCELERATED_COMPOSITING) conditionals from the code base and make AC
+        mandatory.
+
+        Tests: No new tests, no functional change.
+
+        * css/MediaQueryEvaluator.cpp:
+        (WebCore::transform_3dMediaFeatureEval):
+        * css/StyleResolver.cpp:
+        (WebCore::StyleResolver::canShareStyleWithElement):
+        * dom/Document.cpp:
+        (WebCore::Document::setVisualUpdatesAllowed):
+        (WebCore::Document::recalcStyle):
+        (WebCore::Document::createRenderTree):
+        (WebCore::Document::documentWillBecomeInactive):
+        (WebCore::Document::documentDidResumeFromPageCache):
+        (WebCore::Document::windowScreenDidChange):
+        * dom/PseudoElement.cpp:
+        (WebCore::PseudoElement::~PseudoElement):
+        * history/CachedFrame.cpp:
+        (WebCore::CachedFrameBase::CachedFrameBase):
+        (WebCore::CachedFrameBase::restore):
+        (WebCore::CachedFrame::CachedFrame):
+        * history/CachedFrame.h:
+        * history/CachedPage.cpp:
+        (WebCore::CachedPage::restore):
+        * history/CachedPage.h:
+        * history/PageCache.cpp:
+        (WebCore::PageCache::PageCache):
+        (WebCore::PageCache::markPagesForDeviceScaleChanged):
+        * history/PageCache.h:
+        * html/HTMLCanvasElement.cpp:
+        (WebCore::HTMLCanvasElement::getContext):
+        (WebCore::HTMLCanvasElement::reset):
+        (WebCore::HTMLCanvasElement::paintsIntoCanvasBuffer):
+        (WebCore::HTMLCanvasElement::createImageBuffer):
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::parseAttribute):
+        * html/HTMLMediaElement.h:
+        * html/canvas/CanvasRenderingContext.h:
+        * html/canvas/CanvasRenderingContext2D.cpp:
+        (WebCore::CanvasRenderingContext2D::didDraw):
+        * html/canvas/CanvasRenderingContext2D.h:
+        * html/canvas/WebGLRenderingContext.cpp:
+        (WebCore::WebGLRenderingContext::markContextChanged):
+        (WebCore::WebGLRenderingContext::reshape):
+        (WebCore::WebGLRenderingContext::platformLayer):
+        * html/canvas/WebGLRenderingContext.h:
+        * inspector/InspectorController.cpp:
+        (WebCore::InspectorController::InspectorController):
+        * inspector/InspectorInstrumentation.cpp:
+        (WebCore::InspectorInstrumentation::didCommitLoadImpl):
+        (WebCore::InspectorInstrumentation::pseudoElementDestroyedImpl):
+        * inspector/InspectorInstrumentation.h:
+        (WebCore::InspectorInstrumentation::pseudoElementDestroyed):
+        * inspector/InspectorLayerTreeAgent.cpp:
+        * inspector/InstrumentingAgents.cpp:
+        (WebCore::InstrumentingAgents::InstrumentingAgents):
+        (WebCore::InstrumentingAgents::reset):
+        * inspector/InstrumentingAgents.h:
+        * loader/EmptyClients.h:
+        * page/ChromeClient.h:
+        * page/Frame.cpp:
+        (WebCore::Frame::layerTreeAsText):
+        (WebCore::Frame::deviceOrPageScaleFactorChanged):
+        * page/Frame.h:
+        * page/FrameView.cpp:
+        (WebCore::FrameView::setFrameRect):
+        (WebCore::FrameView::scheduleLayerFlushAllowingThrottling):
+        (WebCore::FrameView::hasCompositedContent):
+        (WebCore::FrameView::hasCompositedContentIncludingDescendants):
+        (WebCore::FrameView::hasCompositingAncestor):
+        (WebCore::FrameView::enterCompositingMode):
+        (WebCore::FrameView::isEnclosedInCompositingLayer):
+        (WebCore::FrameView::flushCompositingStateIncludingSubframes):
+        (WebCore::FrameView::isSoftwareRenderable):
+        (WebCore::FrameView::layout):
+        (WebCore::FrameView::contentsInCompositedLayer):
+        (WebCore::FrameView::scrollContentsFastPath):
+        (WebCore::FrameView::scrollContentsSlowPath):
+        (WebCore::FrameView::setIsOverlapped):
+        (WebCore::FrameView::delegatesScrollingDidChange):
+        (WebCore::FrameView::scrollPositionChanged):
+        (WebCore::FrameView::updateCompositingLayersAfterScrolling):
+        (WebCore::FrameView::visibleContentsResized):
+        (WebCore::FrameView::addedOrRemovedScrollbar):
+        (WebCore::FrameView::disableLayerFlushThrottlingTemporarilyForInteraction):
+        (WebCore::FrameView::updateLayerFlushThrottlingInAllFrames):
+        (WebCore::FrameView::adjustTiledBackingCoverage):
+        (WebCore::FrameView::hasExtendedBackground):
+        (WebCore::FrameView::extendedBackgroundRect):
+        (WebCore::FrameView::setBackgroundExtendsBeyondPage):
+        (WebCore::FrameView::performPostLayoutTasks):
+        (WebCore::FrameView::paintContents):
+        (WebCore::FrameView::setTracksRepaints):
+        (WebCore::FrameView::resetTrackedRepaints):
+        (WebCore::FrameView::setScrollingPerformanceLoggingEnabled):
+        (WebCore::FrameView::setExposedRect):
+        * page/FrameView.h:
+        * page/Page.cpp:
+        (WebCore::Page::setPageScaleFactor):
+        (WebCore::Page::setDeviceScaleFactor):
+        * page/Settings.cpp:
+        (WebCore::Settings::setBackgroundShouldExtendBeyondPage):
+        * page/animation/AnimationBase.cpp:
+        (WebCore::AnimationBase::freezeAtTime):
+        * page/animation/AnimationController.cpp:
+        (WebCore::AnimationController::supportsAcceleratedAnimationOfProperty):
+        * page/animation/CSSPropertyAnimation.cpp:
+        (WebCore::CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap):
+        (WebCore::CSSPropertyAnimation::blendProperties):
+        (WebCore::CSSPropertyAnimation::animationOfPropertyIsAccelerated):
+        * page/animation/CSSPropertyAnimation.h:
+        * page/animation/CompositeAnimation.cpp:
+        (WebCore::CompositeAnimation::updateTransitions):
+        * page/animation/ImplicitAnimation.cpp:
+        (WebCore::ImplicitAnimation::animate):
+        (WebCore::ImplicitAnimation::startAnimation):
+        (WebCore::ImplicitAnimation::pauseAnimation):
+        (WebCore::ImplicitAnimation::endAnimation):
+        (WebCore::ImplicitAnimation::timeToNextService):
+        * page/animation/KeyframeAnimation.cpp:
+        (WebCore::KeyframeAnimation::animate):
+        (WebCore::KeyframeAnimation::startAnimation):
+        (WebCore::KeyframeAnimation::pauseAnimation):
+        (WebCore::KeyframeAnimation::endAnimation):
+        (WebCore::KeyframeAnimation::timeToNextService):
+        * page/ios/FrameIOS.mm:
+        (WebCore::Frame::viewportOffsetChanged):
+        (WebCore::Frame::containsTiledBackingLayers):
+        * page/scrolling/AsyncScrollingCoordinator.cpp:
+        (WebCore::AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScroll):
+        * page/scrolling/ScrollingCoordinator.cpp:
+        (WebCore::ScrollingCoordinator::coordinatesScrollingForFrameView):
+        (WebCore::ScrollingCoordinator::computeNonFastScrollableRegion):
+        (WebCore::ScrollingCoordinator::verticalScrollbarLayerForScrollableArea):
+        (WebCore::ScrollingCoordinator::scrollLayerForFrameView):
+        (WebCore::ScrollingCoordinator::headerLayerForFrameView):
+        (WebCore::ScrollingCoordinator::footerLayerForFrameView):
+        (WebCore::ScrollingCoordinator::counterScrollingLayerForFrameView):
+        (WebCore::ScrollingCoordinator::hasVisibleSlowRepaintViewportConstrainedObjects):
+        * page/scrolling/ScrollingCoordinator.h:
+        * platform/ScrollView.cpp:
+        (WebCore::positionScrollCornerLayer):
+        (WebCore::ScrollView::positionScrollbarLayers):
+        (WebCore::ScrollView::paintScrollbars):
+        (WebCore::ScrollView::paint):
+        * platform/ScrollableArea.cpp:
+        (WebCore::ScrollableArea::invalidateScrollbar):
+        (WebCore::ScrollableArea::invalidateScrollCorner):
+        (WebCore::ScrollableArea::horizontalScrollbarLayerDidChange):
+        (WebCore::ScrollableArea::hasLayerForHorizontalScrollbar):
+        (WebCore::ScrollableArea::hasLayerForVerticalScrollbar):
+        (WebCore::ScrollableArea::hasLayerForScrollCorner):
+        * platform/ScrollableArea.h:
+        * platform/ScrollbarTheme.h:
+        * platform/efl/EflScreenUtilities.cpp:
+        (WebCore::applyFallbackCursor):
+        * platform/graphics/GraphicsContext3D.h:
+        * platform/graphics/GraphicsContext3DPrivate.cpp:
+        (WebCore::GraphicsContext3DPrivate::~GraphicsContext3DPrivate):
+        (WebCore::GraphicsContext3DPrivate::paintToTextureMapper):
+        * platform/graphics/GraphicsContext3DPrivate.h:
+        * platform/graphics/GraphicsLayer.cpp:
+        * platform/graphics/GraphicsLayer.h:
+        * platform/graphics/GraphicsLayerAnimation.cpp:
+        * platform/graphics/GraphicsLayerAnimation.h:
+        * platform/graphics/GraphicsLayerClient.h:
+        * platform/graphics/GraphicsLayerFactory.h:
+        * platform/graphics/GraphicsLayerUpdater.cpp:
+        * platform/graphics/GraphicsLayerUpdater.h:
+        * platform/graphics/ImageBuffer.cpp:
+        * platform/graphics/ImageBuffer.h:
+        * platform/graphics/MediaPlayer.cpp:
+        (WebCore::MediaPlayer::platformLayer):
+        (WebCore::MediaPlayer::supportsAcceleratedRendering):
+        * platform/graphics/MediaPlayer.h:
+        * platform/graphics/MediaPlayerPrivate.h:
+        * platform/graphics/PlatformLayer.h:
+        * platform/graphics/TextTrackRepresentation.cpp:
+        * platform/graphics/TextTrackRepresentation.h:
+        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp:
+        (WebCore::MediaPlayerPrivateAVFoundation::currentRenderingMode):
+        (WebCore::MediaPlayerPrivateAVFoundation::preferredRenderingMode):
+        (WebCore::MediaPlayerPrivateAVFoundation::setUpVideoRendering):
+        (WebCore::MediaPlayerPrivateAVFoundation::tearDownVideoRendering):
+        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h:
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:
+        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::platformLayer):
+        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::acceleratedRenderingStateChanged):
+        * platform/graphics/ca/GraphicsLayerCA.cpp:
+        * platform/graphics/ca/GraphicsLayerCA.h:
+        * platform/graphics/ca/LayerFlushScheduler.cpp:
+        * platform/graphics/ca/LayerFlushScheduler.h:
+        * platform/graphics/ca/LayerFlushSchedulerClient.h:
+        * platform/graphics/ca/PlatformCAAnimation.h:
+        * platform/graphics/ca/PlatformCAFilters.h:
+        * platform/graphics/ca/PlatformCALayer.h:
+        * platform/graphics/ca/PlatformCALayerClient.h:
+        * platform/graphics/ca/mac/LayerFlushSchedulerMac.cpp:
+        * platform/graphics/ca/mac/PlatformCAAnimationMac.mm:
+        (PlatformCAAnimation::copyTimingFunctionsFrom):
+        * platform/graphics/ca/mac/PlatformCAFiltersMac.mm:
+        * platform/graphics/ca/mac/PlatformCALayerMac.h:
+        * platform/graphics/ca/mac/PlatformCALayerMac.mm:
+        (PlatformCALayerMac::enumerateRectsBeingDrawn):
+        * platform/graphics/ca/win/AbstractCACFLayerTreeHost.h:
+        * platform/graphics/ca/win/CACFLayerTreeHost.cpp:
+        * platform/graphics/ca/win/CACFLayerTreeHost.h:
+        * platform/graphics/ca/win/CACFLayerTreeHostClient.h:
+        * platform/graphics/ca/win/LayerChangesFlusher.cpp:
+        * platform/graphics/ca/win/LayerChangesFlusher.h:
+        * platform/graphics/ca/win/LegacyCACFLayerTreeHost.cpp:
+        * platform/graphics/ca/win/LegacyCACFLayerTreeHost.h:
+        * platform/graphics/ca/win/PlatformCAAnimationWin.cpp:
+        (PlatformCAAnimation::copyTimingFunctionsFrom):
+        * platform/graphics/ca/win/PlatformCAFiltersWin.cpp:
+        * platform/graphics/ca/win/PlatformCALayerWin.cpp:
+        (PlatformCALayerWin::createCompatibleLayer):
+        * platform/graphics/ca/win/PlatformCALayerWin.h:
+        * platform/graphics/ca/win/PlatformCALayerWinInternal.cpp:
+        (PlatformCALayerWinInternal::drawTile):
+        * platform/graphics/ca/win/PlatformCALayerWinInternal.h:
+        * platform/graphics/ca/win/WKCACFViewLayerTreeHost.cpp:
+        * platform/graphics/ca/win/WKCACFViewLayerTreeHost.h:
+        * platform/graphics/cairo/DrawingBufferCairo.cpp:
+        (WebCore::DrawingBuffer::paintCompositedResultsToCanvas):
+        * platform/graphics/cairo/GraphicsContext3DCairo.cpp:
+        (WebCore::GraphicsContext3D::platformLayer):
+        * platform/graphics/cairo/ImageBufferCairo.cpp:
+        (WebCore::ImageBuffer::platformLayer):
+        * platform/graphics/efl/GraphicsContext3DEfl.cpp:
+        (WebCore::GraphicsContext3D::platformLayer):
+        * platform/graphics/efl/GraphicsContext3DPrivate.cpp:
+        * platform/graphics/efl/GraphicsContext3DPrivate.h:
+        * platform/graphics/gpu/DrawingBuffer.h:
+        * platform/graphics/gpu/LoopBlinnMathUtils.cpp:
+        * platform/graphics/gpu/TilingData.cpp:
+        * platform/graphics/gpu/mac/DrawingBufferMac.mm:
+        (WebCore::DrawingBuffer::frontColorBuffer):
+        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:
+        (WebCore::MediaPlayerPrivateGStreamerBase::triggerRepaint):
+        (WebCore::MediaPlayerPrivateGStreamerBase::paint):
+        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h:
+        * platform/graphics/ios/MediaPlayerPrivateIOS.h:
+        * platform/graphics/ios/MediaPlayerPrivateIOS.mm:
+        (WebCore::MediaPlayerPrivateIOS::supportsAcceleratedRendering):
+        * platform/graphics/mac/MediaPlayerPrivateQTKit.h:
+        * platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
+        (WebCore::MediaPlayerPrivateQTKit::createQTMovieLayer):
+        (WebCore::MediaPlayerPrivateQTKit::destroyQTMovieLayer):
+        (WebCore::MediaPlayerPrivateQTKit::preferredRenderingMode):
+        (WebCore::MediaPlayerPrivateQTKit::platformLayer):
+        (WebCore::MediaPlayerPrivateQTKit::setClosedCaptionsVisible):
+        (WebCore::MediaPlayerPrivateQTKit::layerHostChanged):
+        (WebCore::MediaPlayerPrivateQTKit::acceleratedRenderingStateChanged):
+        (-[WebCoreMovieObserver layerHostChanged:]):
+        * platform/graphics/mac/WebGLLayer.h:
+        * platform/graphics/mac/WebGLLayer.mm:
+        * platform/graphics/mac/WebLayer.h:
+        * platform/graphics/mac/WebLayer.mm:
+        * platform/graphics/mac/WebTiledLayer.h:
+        * platform/graphics/mac/WebTiledLayer.mm:
+        * platform/graphics/opengl/GLDefs.h:
+        * platform/graphics/opengl/GLPlatformContext.cpp:
+        * platform/graphics/opengl/GLPlatformContext.h:
+        * platform/graphics/opengl/GLPlatformSurface.cpp:
+        * platform/graphics/opengl/GLPlatformSurface.h:
+        * platform/graphics/surfaces/GLTransportSurface.cpp:
+        * platform/graphics/surfaces/GLTransportSurface.h:
+        * platform/graphics/surfaces/glx/GLXConfigSelector.h:
+        * platform/graphics/surfaces/glx/GLXContext.cpp:
+        * platform/graphics/surfaces/glx/GLXContext.h:
+        * platform/graphics/surfaces/glx/GLXSurface.cpp:
+        * platform/graphics/surfaces/glx/GLXSurface.h:
+        * platform/graphics/texmap/TextureMapper.cpp:
+        * platform/graphics/texmap/TextureMapper.h:
+        * platform/graphics/texmap/TextureMapperBackingStore.cpp:
+        * platform/graphics/texmap/TextureMapperBackingStore.h:
+        * platform/graphics/texmap/TextureMapperFPSCounter.cpp:
+        * platform/graphics/texmap/TextureMapperFPSCounter.h:
+        * platform/graphics/texmap/TextureMapperGL.cpp:
+        * platform/graphics/texmap/TextureMapperGL.h:
+        * platform/graphics/texmap/TextureMapperLayer.cpp:
+        * platform/graphics/texmap/TextureMapperLayer.h:
+        * platform/graphics/texmap/TextureMapperShaderProgram.cpp:
+        * platform/graphics/texmap/TextureMapperSurfaceBackingStore.cpp:
+        * platform/graphics/texmap/TextureMapperSurfaceBackingStore.h:
+        * platform/graphics/texmap/TextureMapperTile.cpp:
+        * platform/graphics/texmap/TextureMapperTile.h:
+        * platform/graphics/texmap/TextureMapperTiledBackingStore.cpp:
+        * platform/graphics/texmap/TextureMapperTiledBackingStore.h:
+        * platform/graphics/win/GraphicsContext3DWin.cpp:
+        (WebCore::GraphicsContext3D::platformLayer):
+        * platform/graphics/win/MediaPlayerPrivateFullscreenWindow.cpp:
+        (WebCore::MediaPlayerPrivateFullscreenWindow::createWindow):
+        (WebCore::MediaPlayerPrivateFullscreenWindow::wndProc):
+        * platform/graphics/win/MediaPlayerPrivateFullscreenWindow.h:
+        * platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp:
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::LayerClient::platformCALayerLayoutSublayersOfLayer):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::MediaPlayerPrivateQuickTimeVisualContext):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::supportsFullscreen):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::platformMedia):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::platformLayer):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::naturalSize):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::paint):
+        (WebCore::CreateCGImageFromPixelBuffer):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::retrieveCurrentImage):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::currentRenderingMode):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::preferredRenderingMode):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::setUpVideoRendering):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::tearDownVideoRendering):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::hasSetUpVideoRendering):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::retrieveAndResetMovieTransform):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::createLayerForMovie):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::destroyLayerForMovie):
+        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::setPrivateBrowsingMode):
+        * platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h:
+        * platform/graphics/win/WKCAImageQueue.cpp:
+        * platform/graphics/win/WKCAImageQueue.h:
+        * platform/mac/ScrollbarThemeMac.h:
+        * platform/mac/ScrollbarThemeMac.mm:
+        * plugins/PluginViewBase.h:
+        * rendering/FlowThreadController.cpp:
+        (WebCore::FlowThreadController::updateRenderFlowThreadLayersIfNeeded):
+        * rendering/FlowThreadController.h:
+        * rendering/RenderBox.cpp:
+        (WebCore::RenderBox::styleWillChange):
+        (WebCore::isCandidateForOpaquenessTest):
+        (WebCore::layersUseImage):
+        (WebCore::RenderBox::imageChanged):
+        * rendering/RenderBoxModelObject.cpp:
+        (WebCore::RenderBoxModelObject::suspendAnimations):
+        (WebCore::RenderBoxModelObject::fixedBackgroundPaintsInLocalCoordinates):
+        * rendering/RenderBoxModelObject.h:
+        * rendering/RenderElement.cpp:
+        (WebCore::RenderElement::adjustStyleDifference):
+        (WebCore::RenderElement::setStyle):
+        (WebCore::RenderElement::styleWillChange):
+        * rendering/RenderEmbeddedObject.cpp:
+        (WebCore::RenderEmbeddedObject::allowsAcceleratedCompositing):
+        * rendering/RenderEmbeddedObject.h:
+        * rendering/RenderFlowThread.cpp:
+        (WebCore::RenderFlowThread::RenderFlowThread):
+        (WebCore::RenderFlowThread::layout):
+        (WebCore::RenderFlowThread::updateAllLayerToRegionMappings):
+        * rendering/RenderFlowThread.h:
+        * rendering/RenderFullScreen.cpp:
+        * rendering/RenderImage.cpp:
+        (WebCore::RenderImage::imageDimensionsChanged):
+        (WebCore::RenderImage::notifyFinished):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::RenderLayer):
+        (WebCore::RenderLayer::~RenderLayer):
+        (WebCore::RenderLayer::canRender3DTransforms):
+        (WebCore::RenderLayer::paintsWithFilters):
+        (WebCore::RenderLayer::updateLayerPositions):
+        (WebCore::RenderLayer::updateDescendantsAreContiguousInStackingOrderRecursive):
+        (WebCore::RenderLayer::currentTransform):
+        (WebCore::RenderLayer::updateDescendantDependentFlags):
+        (WebCore::RenderLayer::checkIfDescendantClippingContextNeedsUpdate):
+        (WebCore::RenderLayer::shouldRepaintAfterLayout):
+        (WebCore::RenderLayer::enclosingFilterRepaintLayer):
+        (WebCore::RenderLayer::setFilterBackendNeedsRepaintingInRect):
+        (WebCore::RenderLayer::clippingRootForPainting):
+        (WebCore::RenderLayer::addChild):
+        (WebCore::RenderLayer::removeChild):
+        (WebCore::RenderLayer::removeOnlyThisLayer):
+        (WebCore::RenderLayer::scrollTo):
+        (WebCore::RenderLayer::updateCompositingLayersAfterScroll):
+        (WebCore::RenderLayer::invalidateScrollbarRect):
+        (WebCore::RenderLayer::invalidateScrollCornerRect):
+        (WebCore::RenderLayer::positionOverflowControls):
+        (WebCore::RenderLayer::updateScrollInfoAfterLayout):
+        (WebCore::RenderLayer::paintOverflowControls):
+        (WebCore::shouldDoSoftwarePaint):
+        (WebCore::RenderLayer::paintLayer):
+        (WebCore::RenderLayer::calculateClipRects):
+        * rendering/RenderLayer.h:
+        * rendering/RenderLayerBacking.cpp:
+        * rendering/RenderLayerBacking.h:
+        * rendering/RenderLayerCompositor.cpp:
+        * rendering/RenderLayerCompositor.h:
+        * rendering/RenderNamedFlowThread.cpp:
+        (WebCore::RenderNamedFlowThread::collectsGraphicsLayersUnderRegions):
+        * rendering/RenderNamedFlowThread.h:
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::containerForRepaint):
+        (WebCore::RenderObject::repaintUsingContainer):
+        * rendering/RenderTreeAsText.cpp:
+        (WebCore::write):
+        * rendering/RenderVideo.cpp:
+        (WebCore::RenderVideo::updatePlayer):
+        (WebCore::RenderVideo::acceleratedRenderingStateChanged):
+        * rendering/RenderVideo.h:
+        * rendering/RenderView.cpp:
+        (WebCore::RenderView::paintBoxDecorations):
+        (WebCore::RenderView::repaintRootContents):
+        (WebCore::RenderView::repaintRectangleInViewAndCompositedLayers):
+        (WebCore::RenderView::repaintViewAndCompositedLayers):
+        (WebCore::RenderView::setMaximalOutlineSize):
+        (WebCore::RenderView::compositor):
+        (WebCore::RenderView::setIsInWindow):
+        * rendering/RenderView.h:
+        * rendering/RenderWidget.cpp:
+        (WebCore::RenderWidget::setWidgetGeometry):
+        (WebCore::RenderWidget::requiresAcceleratedCompositing):
+        * rendering/RenderWidget.h:
+        * rendering/style/RenderStyle.cpp:
+        (WebCore::RenderStyle::changeRequiresLayout):
+        (WebCore::RenderStyle::changeRequiresLayerRepaint):
+        (WebCore::RenderStyle::changeRequiresRecompositeLayer):
+        (WebCore::RenderStyle::diff):
+        * rendering/style/RenderStyle.h:
+        * rendering/style/RenderStyleConstants.h:
+        * rendering/style/StyleRareNonInheritedData.cpp:
+        (WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):
+        (WebCore::StyleRareNonInheritedData::operator==):
+        * rendering/style/StyleRareNonInheritedData.h:
+        * testing/Internals.cpp:
+        (WebCore::Internals::resetToConsistentState):
+        (WebCore::Internals::setHeaderHeight):
+        (WebCore::Internals::setFooterHeight):
+
  2014-01-30  Krzysztof Czech  <k.czech@samsung.com>
  
          AX: Clean up AccessibilityRenderObject
diff --git a/Source/WebCore/css/MediaQueryEvaluator.cpp b/Source/WebCore/css/MediaQueryEvaluator.cpp

index 1d176edf14cca359cdb23532dcfd21bee0367428..d3956155e4d7ed2e3d6deec4d6ce494ab6c05feb 100644 (file)
--- a/Source/WebCore/css/MediaQueryEvaluator.cpp
+++ b/Source/WebCore/css/MediaQueryEvaluator.cpp
@@ -55,7 +55,7 @@
  #include "StyleResolver.h"
  #include <wtf/HashMap.h>
  
-#if ENABLE(3D_RENDERING) && USE(ACCELERATED_COMPOSITING)
+#if ENABLE(3D_RENDERING)
  #include "RenderLayerCompositor.h"
  #endif
  
@@ -571,10 +571,8 @@ static bool transform_3dMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* f
  
  #if ENABLE(3D_RENDERING)
      bool threeDEnabled = false;
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* view = frame->contentRenderer())
          threeDEnabled = view->compositor().canRender3DTransforms();
-#endif
  
      returnValueIfNoParameter = threeDEnabled;
      have3dRendering = threeDEnabled ? 1 : 0;
diff --git a/Source/WebCore/css/StyleResolver.cpp b/Source/WebCore/css/StyleResolver.cpp

index 827388f29d6d275bb5998a7557a96c3fbb699812..9172b0f1fd419c47c4242690c7f99c9ae6b0404a 100644 (file)
--- a/Source/WebCore/css/StyleResolver.cpp
+++ b/Source/WebCore/css/StyleResolver.cpp
@@ -680,7 +680,6 @@ bool StyleResolver::canShareStyleWithElement(StyledElement* element) const
      if (style->transitions() || style->animations())
          return false;
  
-#if USE(ACCELERATED_COMPOSITING)
      // Turn off style sharing for elements that can gain layers for reasons outside of the style system.
      // See comments in RenderObject::setStyle().
      if (element->hasTagName(iframeTag) || element->hasTagName(frameTag) || element->hasTagName(embedTag) || element->hasTagName(objectTag) || element->hasTagName(appletTag) || element->hasTagName(canvasTag))
@@ -690,8 +689,6 @@ bool StyleResolver::canShareStyleWithElement(StyledElement* element) const
      // With proxying, the media elements are backed by a RenderEmbeddedObject.
      if ((element->hasTagName(videoTag) || element->hasTagName(audioTag)) && toHTMLMediaElement(element)->shouldUseVideoPluginProxy())
          return false;
-#endif
-
  #endif
  
      if (elementHasDirectionAuto(element))
diff --git a/Source/WebCore/dom/Document.cpp b/Source/WebCore/dom/Document.cpp

index 9c28c6b2f70b8ed6714f7051bdce7c040321742a..7d70dcc3ee8ed7a0627d4e389bf014d92120aa74 100644 (file)
--- a/Source/WebCore/dom/Document.cpp
+++ b/Source/WebCore/dom/Document.cpp
@@ -114,6 +114,7 @@
  #include "PointerLockController.h"
  #include "PopStateEvent.h"
  #include "ProcessingInstruction.h"
+#include "RenderLayerCompositor.h"
  #include "RenderView.h"
  #include "RenderWidget.h"
  #include "ResourceLoadScheduler.h"
@@ -152,10 +153,6 @@
  #include <wtf/TemporaryChange.h>
  #include <wtf/text/StringBuffer.h>
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "RenderLayerCompositor.h"
-#endif
-
  #if ENABLE(SHARED_WORKERS)
  #include "SharedWorkerRepository.h"
  #endif
@@ -1242,10 +1239,8 @@ void Document::setVisualUpdatesAllowed(bool visualUpdatesAllowed)
          }
      }
  
-#if USE(ACCELERATED_COMPOSITING)
      if (view())
          view()->updateCompositingLayersAfterLayout();
-#endif
  
      if (RenderView* renderView = this->renderView())
          renderView->repaintViewAndCompositedLayers();
@@ -1751,9 +1746,7 @@ void Document::recalcStyle(Style::Change change)
  
          Style::resolveTree(*this, change);
  
-#if USE(ACCELERATED_COMPOSITING)
          frameView.updateCompositingLayersAfterStyleChange();
-#endif
  
          clearNeedsStyleRecalc();
          clearChildNeedsStyleRecalc();
@@ -1956,9 +1949,7 @@ void Document::createRenderTree()
      m_renderView = createRenderer<RenderView>(*this, RenderStyle::create());
      Node::setRenderer(m_renderView.get());
  
-#if USE(ACCELERATED_COMPOSITING)
      renderView()->setIsInWindow(true);
-#endif
  
      recalcStyle(Style::Force);
  }
@@ -4077,10 +4068,8 @@ void Document::setInPageCache(bool flag)
  
  void Document::documentWillBecomeInactive()
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (renderView())
          renderView()->setIsInWindow(false);
-#endif
  }
  
  void Document::documentWillSuspendForPageCache()
@@ -4106,10 +4095,8 @@ void Document::documentDidResumeFromPageCache()
      for (Vector<Element*>::iterator i = elements.begin(); i != end; ++i)
          (*i)->documentDidResumeFromPageCache();
  
-#if USE(ACCELERATED_COMPOSITING)
      if (renderView())
          renderView()->setIsInWindow(true);
-#endif
  
      ASSERT(page());
      page()->lockAllOverlayScrollbarsToHidden(false);
@@ -5008,12 +4995,10 @@ void Document::windowScreenDidChange(PlatformDisplayID displayID)
          m_scriptedAnimationController->windowScreenDidChange(displayID);
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* view = renderView()) {
          if (view->usesCompositing())
              view->compositor().windowScreenDidChange(displayID);
      }
-#endif
  }
  
  String Document::displayStringModifiedByEncoding(const String& str) const
diff --git a/Source/WebCore/dom/PseudoElement.cpp b/Source/WebCore/dom/PseudoElement.cpp

index 29259e2ec80d46a8f74922275be50c02c073155f..ce5bf2cfe524dc05c4bf66f9cf0e45d2d45f869e 100644 (file)
--- a/Source/WebCore/dom/PseudoElement.cpp
+++ b/Source/WebCore/dom/PseudoElement.cpp
@@ -67,9 +67,7 @@ PseudoElement::PseudoElement(Element& host, PseudoId pseudoId)
  PseudoElement::~PseudoElement()
  {
      ASSERT(!m_hostElement);
-#if USE(ACCELERATED_COMPOSITING)
      InspectorInstrumentation::pseudoElementDestroyed(document().page(), this);
-#endif
  }
  
  PassRefPtr<RenderStyle> PseudoElement::customStyleForRenderer()
diff --git a/Source/WebCore/history/CachedFrame.cpp b/Source/WebCore/history/CachedFrame.cpp

index 1f61671d75b2c6acc79d0bce2387ea537472583b..721e9e3cfc2f187aee5f3fc2a00ad4dd6667f7b9 100644 (file)
--- a/Source/WebCore/history/CachedFrame.cpp
+++ b/Source/WebCore/history/CachedFrame.cpp
@@ -43,6 +43,7 @@
  #include "Logging.h"
  #include "MainFrame.h"
  #include "Page.h"
+#include "PageCache.h"
  #include "PageTransitionEvent.h"
  #include "ScriptController.h"
  #include "SerializedScriptValue.h"
@@ -58,10 +59,6 @@
  #include "ChromeClient.h"
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "PageCache.h"
-#endif
-
  namespace WebCore {
  
  DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, cachedFrameCounter, ("CachedFrame"));
@@ -73,9 +70,7 @@ CachedFrameBase::CachedFrameBase(Frame& frame)
      , m_mousePressNode(frame.eventHandler().mousePressNode())
      , m_url(frame.document()->url())
      , m_isMainFrame(!frame.tree().parent())
-#if USE(ACCELERATED_COMPOSITING)
      , m_isComposited(frame.view()->hasCompositedContent())
-#endif
  {
  }
  
@@ -112,10 +107,8 @@ void CachedFrameBase::restore()
      // cached page.
      frame.script().updatePlatformScriptObjects();
  
-#if USE(ACCELERATED_COMPOSITING)
      if (m_isComposited)
          frame.view()->restoreBackingStores();
-#endif
  
      frame.loader().client().didRestoreFromPageCache();
  
@@ -188,10 +181,8 @@ CachedFrame::CachedFrame(Frame& frame)
  
      frame.loader().client().savePlatformDataToCachedFrame(this);
  
-#if USE(ACCELERATED_COMPOSITING)
      if (m_isComposited && pageCache()->shouldClearBackingStores())
          frame.view()->clearBackingStores();
-#endif
  
      // documentWillSuspendForPageCache() can set up a layout timer on the FrameView, so clear timers after that.
      frame.clearTimers();
diff --git a/Source/WebCore/history/CachedFrame.h b/Source/WebCore/history/CachedFrame.h

index e9f367bbd42f5384c0282938bb70582e7b20fdd2..feae1df20b7b4da9b9dc1467fcba72aefac7e42f 100644 (file)
--- a/Source/WebCore/history/CachedFrame.h
+++ b/Source/WebCore/history/CachedFrame.h
@@ -61,9 +61,7 @@ protected:
      std::unique_ptr<ScriptCachedFrameData> m_cachedFrameScriptData;
      std::unique_ptr<CachedFramePlatformData> m_cachedFramePlatformData;
      bool m_isMainFrame;
-#if USE(ACCELERATED_COMPOSITING)
      bool m_isComposited;
-#endif
      
      Vector<std::unique_ptr<CachedFrame>> m_childFrames;
  };
diff --git a/Source/WebCore/history/CachedPage.cpp b/Source/WebCore/history/CachedPage.cpp

index cad18497eb225c7c13233f6f15eaca3142e33f95..0b45b5fdb2943bde5d0433ea7d13360f84c847aa 100644 (file)
--- a/Source/WebCore/history/CachedPage.cpp
+++ b/Source/WebCore/history/CachedPage.cpp
@@ -101,11 +101,9 @@ void CachedPage::restore(Page& page)
              frame->document()->visitedLinkState().invalidateStyleForAllLinks();
      }
  
-#if USE(ACCELERATED_COMPOSITING)
      if (m_needsDeviceScaleChanged) {
          page.mainFrame().deviceOrPageScaleFactorChanged();
      }
-#endif
  
      if (m_needsFullStyleRecalc)
          page.setNeedsRecalcStyleInAllFrames();
diff --git a/Source/WebCore/history/CachedPage.h b/Source/WebCore/history/CachedPage.h

index bb83e0fff88100ff200aa1667147f54e7e475787..c977dddd4d19c2de63d70a12e1d848de474a302d 100644 (file)
--- a/Source/WebCore/history/CachedPage.h
+++ b/Source/WebCore/history/CachedPage.h
@@ -56,9 +56,7 @@ public:
      void markForCaptionPreferencesChanged() { m_needsCaptionPreferencesChanged = true; }
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
      void markForDeviceScaleChanged() { m_needsDeviceScaleChanged = true; }
-#endif
  
  private:
      void destroy();
diff --git a/Source/WebCore/history/PageCache.cpp b/Source/WebCore/history/PageCache.cpp

index 57ec24efb6e92b8c44bbc7d19b99dd087f3f53a2..d78fa128d284c7d1f29e56360b3ad975b8b22ac4 100644 (file)
--- a/Source/WebCore/history/PageCache.cpp
+++ b/Source/WebCore/history/PageCache.cpp
@@ -306,9 +306,7 @@ PageCache::PageCache()
      , m_size(0)
      , m_head(0)
      , m_tail(0)
-#if USE(ACCELERATED_COMPOSITING)
      , m_shouldClearBackingStores(false)
-#endif
  {
  }
      
@@ -434,8 +432,6 @@ void PageCache::markPagesForFullStyleRecalc(Page* page)
      }
  }
  
-
-#if USE(ACCELERATED_COMPOSITING)
  void PageCache::markPagesForDeviceScaleChanged(Page* page)
  {
      for (HistoryItem* current = m_head; current; current = current->m_next) {
@@ -444,7 +440,6 @@ void PageCache::markPagesForDeviceScaleChanged(Page* page)
              cachedPage->markForDeviceScaleChanged();
      }
  }
-#endif
  
  #if ENABLE(VIDEO_TRACK)
  void PageCache::markPagesForCaptionPreferencesChanged()
diff --git a/Source/WebCore/history/PageCache.h b/Source/WebCore/history/PageCache.h

index ebab10c1ecca0a3c215a893a38eaac3a1291338a..2821a5a74386900691424a9d145075b2ac663c75 100644 (file)
--- a/Source/WebCore/history/PageCache.h
+++ b/Source/WebCore/history/PageCache.h
@@ -68,11 +68,9 @@ namespace WebCore {
          void markPagesForCaptionPreferencesChanged();
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
          bool shouldClearBackingStores() const { return m_shouldClearBackingStores; }
          void setShouldClearBackingStores(bool flag) { m_shouldClearBackingStores = flag; }
          void markPagesForDeviceScaleChanged(Page*);
-#endif
  
      private:
          PageCache(); // Use pageCache() instead.
@@ -92,9 +90,7 @@ namespace WebCore {
          HistoryItem* m_head;
          HistoryItem* m_tail;
          
-#if USE(ACCELERATED_COMPOSITING)
          bool m_shouldClearBackingStores;
-#endif
       };
  
      // Function to obtain the global page cache.
diff --git a/Source/WebCore/html/HTMLCanvasElement.cpp b/Source/WebCore/html/HTMLCanvasElement.cpp

index 518a3423330d2d29647948ecb6f9e80caaa0c4d4..600e2919e80f28bb76ae3499b5874b2c8180de81 100644 (file)
--- a/Source/WebCore/html/HTMLCanvasElement.cpp
+++ b/Source/WebCore/html/HTMLCanvasElement.cpp
@@ -212,7 +212,7 @@ CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, Canvas
                  usesDashbardCompatibilityMode = settings->usesDashboardBackwardCompatibilityMode();
  #endif
              m_context = CanvasRenderingContext2D::create(this, document().inQuirksMode(), usesDashbardCompatibilityMode);
-#if USE(IOSURFACE_CANVAS_BACKING_STORE) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING))
+#if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
              // Need to make sure a RenderLayer and compositing layer get created for the Canvas
              setNeedsStyleRecalc(SyntheticStyleChange);
  #endif
@@ -356,10 +356,8 @@ void HTMLCanvasElement::reset()
          if (m_rendererIsCanvas) {
              if (oldSize != size()) {
                  toRenderHTMLCanvas(renderer)->canvasSizeChanged();
-#if USE(ACCELERATED_COMPOSITING)
                  if (renderBox() && renderBox()->hasAcceleratedCompositing())
                      renderBox()->contentChanged(CanvasChanged);
-#endif
              }
              if (hadImageBuffer)
                  renderer->repaint();
@@ -387,13 +385,12 @@ bool HTMLCanvasElement::paintsIntoCanvasBuffer() const
          return true;
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
      if (!m_context->isAccelerated())
          return true;
  
      if (renderBox() && renderBox()->hasAcceleratedCompositing())
          return false;
-#endif
+
      return true;
  }
  
@@ -616,7 +613,7 @@ void HTMLCanvasElement::createImageBuffer() const
      size_t numBytes = 4 * m_imageBuffer->internalSize().width() * m_imageBuffer->internalSize().height();
      scriptExecutionContext()->vm()->heap.reportExtraMemoryCost(numBytes);
  
-#if USE(IOSURFACE_CANVAS_BACKING_STORE) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING))
+#if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
      if (m_context && m_context->is2d())
          // Recalculate compositing requirements if acceleration state changed.
          const_cast<HTMLCanvasElement*>(this)->setNeedsStyleRecalc(SyntheticStyleChange);
diff --git a/Source/WebCore/html/HTMLMediaElement.cpp b/Source/WebCore/html/HTMLMediaElement.cpp

index 35f0047985049262fc9282c34786c96948112228..9f997b06c2ffbc90c59ad2fd5148f1cfd40ae4b3 100644 (file)
--- a/Source/WebCore/html/HTMLMediaElement.cpp
+++ b/Source/WebCore/html/HTMLMediaElement.cpp
@@ -64,6 +64,7 @@
  #include "PageActivityAssertionToken.h"
  #include "PageGroup.h"
  #include "ProgressTracker.h"
+#include "RenderLayerCompositor.h"
  #include "RenderVideo.h"
  #include "RenderView.h"
  #include "ScriptController.h"
@@ -79,10 +80,6 @@
  #include <wtf/Ref.h>
  #include <wtf/text/CString.h>
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "RenderLayerCompositor.h"
-#endif
-
  #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
  #include "RenderEmbeddedObject.h"
  #include "SubframeLoader.h"
@@ -4014,7 +4011,6 @@ void HTMLMediaElement::mediaPlayerSizeChanged(MediaPlayer*)
      endProcessingMediaPlayerCallback();
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  bool HTMLMediaElement::mediaPlayerRenderingCanBeAccelerated(MediaPlayer*)
  {
      if (renderer() && renderer()->isVideo())
@@ -4029,7 +4025,6 @@ void HTMLMediaElement::mediaPlayerRenderingModeChanged(MediaPlayer*)
      // Kick off a fake recalcStyle that will update the compositing tree.
      setNeedsStyleRecalc(SyntheticStyleChange);
  }
-#endif
  
  #if PLATFORM(WIN) && USE(AVFOUNDATION)
  GraphicsDeviceAdapter* HTMLMediaElement::mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const
@@ -4060,9 +4055,7 @@ void HTMLMediaElement::mediaPlayerFirstVideoFrameAvailable(MediaPlayer*)
      beginProcessingMediaPlayerCallback();
      if (displayMode() == PosterWaitingForVideo) {
          setDisplayMode(Video);
-#if USE(ACCELERATED_COMPOSITING)
          mediaPlayerRenderingModeChanged(m_player.get());
-#endif
      }
      endProcessingMediaPlayerCallback();
  }
@@ -4922,7 +4915,6 @@ PlatformMedia HTMLMediaElement::platformMedia() const
      return m_player ? m_player->platformMedia() : NoPlatformMedia;
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  PlatformLayer* HTMLMediaElement::platformLayer() const
  {
  #if PLATFORM(IOS)
@@ -4951,7 +4943,6 @@ void HTMLMediaElement::returnPlatformLayer(PlatformLayer* platformLayer)
          renderer()->updateFromElement();
  }
  #endif
-#endif
  
  bool HTMLMediaElement::hasClosedCaptions() const
  {
diff --git a/Source/WebCore/html/HTMLMediaElement.h b/Source/WebCore/html/HTMLMediaElement.h

index 07faa23cc03a7b5c870e17430f4314822be5c451..ebe0e6b7c8f4cd5ac4396eef8fdfdb6396cd1230 100644 (file)
--- a/Source/WebCore/html/HTMLMediaElement.h
+++ b/Source/WebCore/html/HTMLMediaElement.h
@@ -130,12 +130,10 @@ public:
      virtual bool supportsScanning() const override;
      
      PlatformMedia platformMedia() const;
-#if USE(ACCELERATED_COMPOSITING)
      PlatformLayer* platformLayer() const;
  #if PLATFORM(IOS)
      PlatformLayer* borrowPlatformLayer();
      void returnPlatformLayer(PlatformLayer*);
-#endif
  #endif
  
      enum DelayedActionType {
@@ -508,10 +506,8 @@ private:
      virtual void mediaPlayerResourceNotSupported(MediaPlayer*) override;
      virtual void mediaPlayerRepaint(MediaPlayer*) override;
      virtual void mediaPlayerSizeChanged(MediaPlayer*) override;
-#if USE(ACCELERATED_COMPOSITING)
      virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) override;
      virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) override;
-#endif
      virtual void mediaPlayerEngineUpdated(MediaPlayer*) override;
      
      virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) override;
diff --git a/Source/WebCore/html/canvas/CanvasRenderingContext.h b/Source/WebCore/html/canvas/CanvasRenderingContext.h

index b5b2781f7095bd427083e8165fd5f6ddda8f057e..a9ac5b1219761ab67ea6cb6902f8d660f29bbf62 100644 (file)
--- a/Source/WebCore/html/canvas/CanvasRenderingContext.h
+++ b/Source/WebCore/html/canvas/CanvasRenderingContext.h
@@ -56,10 +56,7 @@ public:
      virtual bool isAccelerated() const { return false; }
  
      virtual void paintRenderingResultsToCanvas() {}
-
-#if USE(ACCELERATED_COMPOSITING)
      virtual PlatformLayer* platformLayer() const { return 0; }
-#endif
  
  protected:
      CanvasRenderingContext(HTMLCanvasElement*);
diff --git a/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp b/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp

index 18a87f4af01decc74e383671a0ac75b4eff96911..47d87ed54d25ea65329a63ce7a493380a8754960 100755 (executable)
--- a/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp
+++ b/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp
@@ -48,6 +48,7 @@
  #include "HTMLVideoElement.h"
  #include "ImageData.h"
  #include "RenderElement.h"
+#include "RenderLayer.h"
  #include "SecurityOrigin.h"
  #include "StrokeStyleApplier.h"
  #include "StyleProperties.h"
@@ -55,10 +56,6 @@
  #include "TextMetrics.h"
  #include "TextRun.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "RenderLayer.h"
-#endif
-
  #include <wtf/CheckedArithmetic.h>
  #include <wtf/MathExtras.h>
  #include <wtf/text/StringBuilder.h>
@@ -1739,7 +1736,7 @@ void CanvasRenderingContext2D::didDraw(const FloatRect& r, unsigned options)
      if (!state().m_hasInvertibleTransform)
          return;
  
-#if ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING)
+#if ENABLE(ACCELERATED_2D_CANVAS)
      // If we are drawing to hardware and we have a composited layer, just call contentChanged().
      if (isAccelerated()) {
          RenderBox* renderBox = canvas()->renderBox();
@@ -2327,7 +2324,7 @@ const Font& CanvasRenderingContext2D::accessFont()
      return state().m_font;
  }
  
-#if ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING)
+#if ENABLE(ACCELERATED_2D_CANVAS)
  PlatformLayer* CanvasRenderingContext2D::platformLayer() const
  {
      return canvas()->buffer() ? canvas()->buffer()->platformLayer() : 0;
diff --git a/Source/WebCore/html/canvas/CanvasRenderingContext2D.h b/Source/WebCore/html/canvas/CanvasRenderingContext2D.h

index 27b7e33c816cc8718de8998b787c2470a85c6301..bb0736d070f6d2a7b559bbd66224a384d18485fb 100644 (file)
--- a/Source/WebCore/html/canvas/CanvasRenderingContext2D.h
+++ b/Source/WebCore/html/canvas/CanvasRenderingContext2D.h
@@ -37,13 +37,10 @@
  #include "GraphicsTypes.h"
  #include "ImageBuffer.h"
  #include "Path.h"
+#include "PlatformLayer.h"
  #include <wtf/Vector.h>
  #include <wtf/text/WTFString.h>
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "PlatformLayer.h"
-#endif
-
  namespace WebCore {
  
  class CanvasGradient;
@@ -330,7 +327,7 @@ private:
  
      virtual bool hasInvertibleTransform() const override { return state().m_hasInvertibleTransform; }
  
-#if ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING)
+#if ENABLE(ACCELERATED_2D_CANVAS)
      virtual PlatformLayer* platformLayer() const override;
  #endif
  
diff --git a/Source/WebCore/html/canvas/WebGLRenderingContext.cpp b/Source/WebCore/html/canvas/WebGLRenderingContext.cpp

index fa5537b0ebb4cde4dd2d3924ebd128abaee3d78b..3810399022bfa78611a7d6422ef292a3afd97b95 100644 (file)
--- a/Source/WebCore/html/canvas/WebGLRenderingContext.cpp
+++ b/Source/WebCore/html/canvas/WebGLRenderingContext.cpp
@@ -647,21 +647,17 @@ void WebGLRenderingContext::markContextChanged()
          m_drawingBuffer->markContentsChanged();
  
      m_layerCleared = false;
-#if USE(ACCELERATED_COMPOSITING)
      RenderBox* renderBox = canvas()->renderBox();
      if (renderBox && renderBox->hasAcceleratedCompositing()) {
          m_markedCanvasDirty = true;
          canvas()->clearCopiedImage();
          renderBox->contentChanged(CanvasChanged);
      } else {
-#endif
          if (!m_markedCanvasDirty) {
              m_markedCanvasDirty = true;
              canvas()->didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));
          }
-#if USE(ACCELERATED_COMPOSITING)
      }
-#endif
  }
  
  bool WebGLRenderingContext::clearIfComposited(GC3Dbitfield mask)
@@ -802,11 +798,9 @@ void WebGLRenderingContext::reshape(int width, int height)
      height = clamp(height, 1, maxHeight);
  
      if (m_needsUpdate) {
-#if USE(ACCELERATED_COMPOSITING)
          RenderBox* renderBox = canvas()->renderBox();
          if (renderBox && renderBox->hasAcceleratedCompositing())
              renderBox->contentChanged(CanvasChanged);
-#endif
          m_needsUpdate = false;
      }
  
@@ -4776,12 +4770,10 @@ void WebGLRenderingContext::forceRestoreContext()
          m_restoreTimer.startOneShot(0);
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  PlatformLayer* WebGLRenderingContext::platformLayer() const
  {
      return (!isContextLost()) ? m_context->platformLayer() : 0;
  }
-#endif
  
  void WebGLRenderingContext::removeSharedObject(WebGLSharedObject* object)
  {
diff --git a/Source/WebCore/html/canvas/WebGLRenderingContext.h b/Source/WebCore/html/canvas/WebGLRenderingContext.h

index 88999d80e9a2c3fc9671760274975b1c3e6131ad..6adac0efe922f414aff65d92d0252fcc0df86fda 100644 (file)
--- a/Source/WebCore/html/canvas/WebGLRenderingContext.h
+++ b/Source/WebCore/html/canvas/WebGLRenderingContext.h
@@ -309,9 +309,7 @@ public:
  
      GraphicsContext3D* graphicsContext3D() const { return m_context.get(); }
      WebGLContextGroup* contextGroup() const { return m_contextGroup.get(); }
-#if USE(ACCELERATED_COMPOSITING)
      virtual PlatformLayer* platformLayer() const override;
-#endif
  
      void reshape(int width, int height);
  
diff --git a/Source/WebCore/inspector/InspectorController.cpp b/Source/WebCore/inspector/InspectorController.cpp

index 197eff2a5861ef007885c6895dbfaa5ec8a5fc5c..8a411b46734825eb199f29cbf1b8af418925165b 100644 (file)
--- a/Source/WebCore/inspector/InspectorController.cpp
+++ b/Source/WebCore/inspector/InspectorController.cpp
@@ -165,9 +165,7 @@ InspectorController::InspectorController(Page& page, InspectorClient* inspectorC
  
      m_agents.append(std::make_unique<InspectorInputAgent>(m_instrumentingAgents.get(), &page));
  
-#if USE(ACCELERATED_COMPOSITING)
      m_agents.append(std::make_unique<InspectorLayerTreeAgent>(m_instrumentingAgents.get()));
-#endif
  
      ASSERT(m_injectedScriptManager->commandLineAPIHost());
      if (CommandLineAPIHost* commandLineAPIHost = m_injectedScriptManager->commandLineAPIHost()) {
diff --git a/Source/WebCore/inspector/InspectorInstrumentation.cpp b/Source/WebCore/inspector/InspectorInstrumentation.cpp

index df135722791a5b8fcaa55e7e65849ddc5a1b4325..1a9a8e6cf3f3d202dd4b17a21ade226574a9fdf7 100644 (file)
--- a/Source/WebCore/inspector/InspectorInstrumentation.cpp
+++ b/Source/WebCore/inspector/InspectorInstrumentation.cpp
@@ -769,10 +769,8 @@ void InspectorInstrumentation::didCommitLoadImpl(InstrumentingAgents* instrument
  #endif
          if (InspectorDOMAgent* domAgent = instrumentingAgents->inspectorDOMAgent())
              domAgent->setDocument(page->mainFrame().document());
-#if USE(ACCELERATED_COMPOSITING)
          if (InspectorLayerTreeAgent* layerTreeAgent = instrumentingAgents->inspectorLayerTreeAgent())
              layerTreeAgent->reset();
-#endif
      }
      if (InspectorDOMAgent* domAgent = instrumentingAgents->inspectorDOMAgent())
          domAgent->didCommitLoad(loader->frame()->document());
@@ -1184,7 +1182,6 @@ InstrumentingAgents* InspectorInstrumentation::instrumentingAgentsForNonDocument
      return nullptr;
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  void InspectorInstrumentation::layerTreeDidChangeImpl(InstrumentingAgents* instrumentingAgents)
  {
      if (InspectorLayerTreeAgent* layerTreeAgent = instrumentingAgents->inspectorLayerTreeAgent())
@@ -1202,7 +1199,6 @@ void InspectorInstrumentation::pseudoElementDestroyedImpl(InstrumentingAgents* i
      if (InspectorLayerTreeAgent* layerTreeAgent = instrumentingAgents->inspectorLayerTreeAgent())
          layerTreeAgent->pseudoElementDestroyed(pseudoElement);
  }
-#endif
  
  } // namespace WebCore
  
diff --git a/Source/WebCore/inspector/InspectorInstrumentation.h b/Source/WebCore/inspector/InspectorInstrumentation.h

index 13d622455d289180dbd2fada17a1836219ffbaf4..8fce09412ebcfa718f70d73498b181ba2f0e5506 100644 (file)
--- a/Source/WebCore/inspector/InspectorInstrumentation.h
+++ b/Source/WebCore/inspector/InspectorInstrumentation.h
@@ -273,11 +273,9 @@ public:
      static void registerInstrumentingAgents(InstrumentingAgents*);
      static void unregisterInstrumentingAgents(InstrumentingAgents*);
  
-#if USE(ACCELERATED_COMPOSITING)
      static void layerTreeDidChange(Page*);
      static void renderLayerDestroyed(Page*, const RenderLayer*);
      static void pseudoElementDestroyed(Page*, PseudoElement*);
-#endif
  
  private:
  #if ENABLE(INSPECTOR)
@@ -444,11 +442,9 @@ private:
      static void cancelPauseOnNativeEvent(InstrumentingAgents*);
      static InspectorTimelineAgent* retrieveTimelineAgent(const InspectorInstrumentationCookie&);
  
-#if USE(ACCELERATED_COMPOSITING)
      static void layerTreeDidChangeImpl(InstrumentingAgents*);
      static void renderLayerDestroyedImpl(InstrumentingAgents*, const RenderLayer*);
      static void pseudoElementDestroyedImpl(InstrumentingAgents*, PseudoElement*);
-#endif
  
      static int s_frontendCounter;
  #endif
@@ -1842,7 +1838,6 @@ inline void InspectorInstrumentation::didFireAnimationFrame(const InspectorInstr
  #endif
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  inline void InspectorInstrumentation::layerTreeDidChange(Page* page)
  {
  #if ENABLE(INSPECTOR)
@@ -1874,7 +1869,6 @@ inline void InspectorInstrumentation::pseudoElementDestroyed(Page* page, PseudoE
      UNUSED_PARAM(pseudoElement);
  #endif
  }
-#endif
  
  #if ENABLE(INSPECTOR)
  inline InstrumentingAgents* InspectorInstrumentation::instrumentingAgentsForContext(ScriptExecutionContext* context)
diff --git a/Source/WebCore/inspector/InspectorLayerTreeAgent.cpp b/Source/WebCore/inspector/InspectorLayerTreeAgent.cpp

index 086e3c80c4fa6f10b50768a8fe524aa712429bb2..4c1f00609686de97b5bc483cd0cb366432d5b630 100644 (file)
--- a/Source/WebCore/inspector/InspectorLayerTreeAgent.cpp
+++ b/Source/WebCore/inspector/InspectorLayerTreeAgent.cpp
@@ -30,7 +30,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
  #if ENABLE(INSPECTOR)
  
  #include "InspectorLayerTreeAgent.h"
@@ -359,4 +358,3 @@ void InspectorLayerTreeAgent::unbindPseudoElement(PseudoElement* pseudoElement)
  } // namespace WebCore
  
  #endif // ENABLE(INSPECTOR)
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/inspector/InstrumentingAgents.cpp b/Source/WebCore/inspector/InstrumentingAgents.cpp

index 15643931b7803ca986336c1b4250e6a8f1fcc8c8..98e6bdd0c96a8c5ca669bfbfa34d3252ef317cac 100644 (file)
--- a/Source/WebCore/inspector/InstrumentingAgents.cpp
+++ b/Source/WebCore/inspector/InstrumentingAgents.cpp
@@ -48,9 +48,7 @@ InstrumentingAgents::InstrumentingAgents(InspectorEnvironment& environment)
      , m_inspectorAgent(nullptr)
      , m_inspectorPageAgent(nullptr)
      , m_inspectorCSSAgent(nullptr)
-#if USE(ACCELERATED_COMPOSITING)
      , m_inspectorLayerTreeAgent(nullptr)
-#endif
      , m_inspectorConsoleAgent(nullptr)
      , m_inspectorDOMAgent(nullptr)
      , m_inspectorResourceAgent(nullptr)
@@ -76,9 +74,7 @@ void InstrumentingAgents::reset()
      m_inspectorAgent = nullptr;
      m_inspectorPageAgent = nullptr;
      m_inspectorCSSAgent = nullptr;
-#if USE(ACCELERATED_COMPOSITING)
      m_inspectorLayerTreeAgent = nullptr;
-#endif
      m_inspectorConsoleAgent = nullptr;
      m_inspectorDOMAgent = nullptr;
      m_inspectorResourceAgent = nullptr;
diff --git a/Source/WebCore/inspector/InstrumentingAgents.h b/Source/WebCore/inspector/InstrumentingAgents.h

index d9b5d41dc558a611dd6c0beaf49d5fc8556bc6f6..c99d269fb4faf584e0d4c4ad358498fe0a109f7a 100644 (file)
--- a/Source/WebCore/inspector/InstrumentingAgents.h
+++ b/Source/WebCore/inspector/InstrumentingAgents.h
@@ -137,10 +137,8 @@ public:
      InspectorCanvasAgent* inspectorCanvasAgent() const { return m_inspectorCanvasAgent; }
      void setInspectorCanvasAgent(InspectorCanvasAgent* agent) { m_inspectorCanvasAgent = agent; }
  
-#if USE(ACCELERATED_COMPOSITING)
      InspectorLayerTreeAgent* inspectorLayerTreeAgent() const { return m_inspectorLayerTreeAgent; }
      void setInspectorLayerTreeAgent(InspectorLayerTreeAgent* agent) { m_inspectorLayerTreeAgent = agent; }
-#endif
  
  private:
      InstrumentingAgents(Inspector::InspectorEnvironment&);
@@ -150,9 +148,7 @@ private:
      Inspector::InspectorAgent* m_inspectorAgent;
      InspectorPageAgent* m_inspectorPageAgent;
      InspectorCSSAgent* m_inspectorCSSAgent;
-#if USE(ACCELERATED_COMPOSITING)
      InspectorLayerTreeAgent* m_inspectorLayerTreeAgent;
-#endif
      InspectorConsoleAgent* m_inspectorConsoleAgent;
      InspectorDOMAgent* m_inspectorDOMAgent;
      InspectorResourceAgent* m_inspectorResourceAgent;
diff --git a/Source/WebCore/loader/EmptyClients.h b/Source/WebCore/loader/EmptyClients.h

index 199c9cc4a1b46970e2100272e0e9cfdac02d9810..8f14f5af355e16a44124001a9534270fa9110129 100644 (file)
--- a/Source/WebCore/loader/EmptyClients.h
+++ b/Source/WebCore/loader/EmptyClients.h
@@ -183,11 +183,9 @@ public:
  
      virtual void scrollRectIntoView(const IntRect&) const override { }
  
-#if USE(ACCELERATED_COMPOSITING)
      virtual void attachRootGraphicsLayer(Frame*, GraphicsLayer*) override { }
      virtual void setNeedsOneShotDrawingSynchronization() override { }
      virtual void scheduleCompositingLayerFlush() override { }
-#endif
  
  #if PLATFORM(WIN)
      virtual void setLastSetCursorToCurrentCursor() override { }
diff --git a/Source/WebCore/page/ChromeClient.h b/Source/WebCore/page/ChromeClient.h

index d7fe0f88b49d9c6fa2d4a9a4780d1d388acfc706..ae5b6d14ad617cd114d122e60579da3e0f641149 100644 (file)
--- a/Source/WebCore/page/ChromeClient.h
+++ b/Source/WebCore/page/ChromeClient.h
@@ -287,7 +287,6 @@ public:
      
      virtual bool shouldPaintEntireContents() const { return false; }
  
-#if USE(ACCELERATED_COMPOSITING)
      // Allows ports to customize the type of graphics layers created by this page.
      virtual GraphicsLayerFactory* graphicsLayerFactory() const { return 0; }
  
@@ -321,7 +320,6 @@ public:
      
      // Returns true if layer tree updates are disabled.
      virtual bool layerTreeStateIsFrozen() const { return false; }
-#endif
  
      virtual PassRefPtr<ScrollingCoordinator> createScrollingCoordinator(Page*) const { return nullptr; }
  
diff --git a/Source/WebCore/page/Frame.cpp b/Source/WebCore/page/Frame.cpp

index 4456c0d5a13b11b08054da70b1db69d7206a1d83..5a9598e1a7f9a85cbff68af684600a45e114cc0d 100644 (file)
--- a/Source/WebCore/page/Frame.cpp
+++ b/Source/WebCore/page/Frame.cpp
@@ -75,6 +75,7 @@
  #include "Page.h"
  #include "PageCache.h"
  #include "PageGroup.h"
+#include "RenderLayerCompositor.h"
  #include "RenderTableCell.h"
  #include "RenderText.h"
  #include "RenderTextControl.h"
@@ -109,10 +110,6 @@
  #include <wtf/StdLibExtras.h>
  #include <yarr/RegularExpression.h>
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "RenderLayerCompositor.h"
-#endif
-
  #if ENABLE(SVG)
  #include "SVGDocument.h"
  #include "SVGDocumentExtensions.h"
@@ -999,17 +996,12 @@ Color Frame::tiledBackingStoreBackgroundColor() const
  
  String Frame::layerTreeAsText(LayerTreeFlags flags) const
  {
-#if USE(ACCELERATED_COMPOSITING)
      document()->updateLayout();
  
      if (!contentRenderer())
          return String();
  
      return contentRenderer()->compositor().layerTreeAsText(flags);
-#else
-    UNUSED_PARAM(flags);
-    return String();
-#endif
  }
  
  String Frame::trackedRepaintRectsAsText() const
@@ -1123,7 +1115,6 @@ void Frame::resumeActiveDOMObjectsAndAnimations()
      }
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  void Frame::deviceOrPageScaleFactorChanged()
  {
      for (RefPtr<Frame> child = tree().firstChild(); child; child = child->tree().nextSibling())
@@ -1132,7 +1123,6 @@ void Frame::deviceOrPageScaleFactorChanged()
      if (RenderView* root = contentRenderer())
          root->compositor().deviceOrPageScaleFactorChanged();
  }
-#endif
  
  bool Frame::isURLAllowed(const URL& url) const
  {
diff --git a/Source/WebCore/page/Frame.h b/Source/WebCore/page/Frame.h

index eff8e141d5b599c3161b2f12cc80a898c5d828c1..3e892079d9736bc85cbd73efced9b49095610e8b 100644 (file)
--- a/Source/WebCore/page/Frame.h
+++ b/Source/WebCore/page/Frame.h
@@ -195,9 +195,7 @@ namespace WebCore {
          // Scale factor of this frame with respect to the container.
          float frameScaleFactor() const;
  
-#if USE(ACCELERATED_COMPOSITING)
          void deviceOrPageScaleFactorChanged();
-#endif
  
  #if PLATFORM(IOS)
          const ViewportArguments& viewportArguments() const;
diff --git a/Source/WebCore/page/FrameView.cpp b/Source/WebCore/page/FrameView.cpp

index 8a9def413d9d7893bc7e65e8f73daad865b140ad..47119e1ec68814d86b7b96318f0523fedfb5bdd6 100644 (file)
--- a/Source/WebCore/page/FrameView.cpp
+++ b/Source/WebCore/page/FrameView.cpp
@@ -62,6 +62,7 @@
  #include "RenderIFrame.h"
  #include "RenderLayer.h"
  #include "RenderLayerBacking.h"
+#include "RenderLayerCompositor.h"
  #include "RenderScrollbar.h"
  #include "RenderScrollbarPart.h"
  #include "RenderStyle.h"
@@ -75,16 +76,12 @@
  #include "StyleResolver.h"
  #include "TextResourceDecoder.h"
  #include "TextStream.h"
+#include "TiledBacking.h"
  
  #include <wtf/CurrentTime.h>
  #include <wtf/Ref.h>
  #include <wtf/TemporaryChange.h>
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "RenderLayerCompositor.h"
-#include "TiledBacking.h"
-#endif
-
  #if ENABLE(SVG)
  #include "RenderSVGRoot.h"
  #include "SVGDocument.h"
@@ -433,12 +430,10 @@ void FrameView::setFrameRect(const IntRect& newRect)
  
      updateScrollableAreaSet();
  
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* renderView = this->renderView()) {
          if (renderView->usesCompositing())
              renderView->compositor().frameViewDidChangeSize();
      }
-#endif
  
      if (!frameFlatteningEnabled())
          sendResizeEventIfNeeded();
@@ -713,7 +708,6 @@ void FrameView::calculateScrollbarModesForLayout(ScrollbarMode& hMode, Scrollbar
      }    
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  void FrameView::updateCompositingLayersAfterStyleChange()
  {
      RenderView* renderView = this->renderView();
@@ -923,7 +917,6 @@ void FrameView::scheduleLayerFlushAllowingThrottling()
          return;
      view->compositor().scheduleLayerFlush(true /* canThrottle */);
  }
-#endif // USE(ACCELERATED_COMPOSITING)
  
  void FrameView::setHeaderHeight(int headerHeight)
  {
@@ -947,16 +940,13 @@ void FrameView::setFooterHeight(int footerHeight)
  
  bool FrameView::hasCompositedContent() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* renderView = this->renderView())
          return renderView->compositor().inCompositingMode();
-#endif
      return false;
  }
  
  bool FrameView::hasCompositedContentIncludingDescendants() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      for (Frame* frame = m_frame.get(); frame; frame = frame->tree().traverseNext(m_frame.get())) {
          RenderView* renderView = frame->contentRenderer();
          if (RenderLayerCompositor* compositor = renderView ? &renderView->compositor() : 0) {
@@ -967,51 +957,43 @@ bool FrameView::hasCompositedContentIncludingDescendants() const
                  break;
          }
      }
-#endif
      return false;
  }
  
  bool FrameView::hasCompositingAncestor() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      for (Frame* frame = this->frame().tree().parent(); frame; frame = frame->tree().parent()) {
          if (FrameView* view = frame->view()) {
              if (view->hasCompositedContent())
                  return true;
          }
      }
-#endif
      return false;
  }
  
  // Sometimes (for plug-ins) we need to eagerly go into compositing mode.
  void FrameView::enterCompositingMode()
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* renderView = this->renderView()) {
          renderView->compositor().enableCompositingMode();
          if (!needsLayout())
              renderView->compositor().scheduleCompositingLayerUpdate();
      }
-#endif
  }
  
  bool FrameView::isEnclosedInCompositingLayer() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      auto frameOwnerRenderer = frame().ownerRenderer();
      if (frameOwnerRenderer && frameOwnerRenderer->containerForRepaint())
          return true;
  
      if (FrameView* parentView = parentFrameView())
          return parentView->isEnclosedInCompositingLayer();
-#endif
      return false;
  }
  
  bool FrameView::flushCompositingStateIncludingSubframes()
  {
-#if USE(ACCELERATED_COMPOSITING)
      bool allFramesFlushed = flushCompositingStateForThisFrame(&frame());
      
      for (Frame* child = frame().tree().firstChild(); child; child = child->tree().traverseNext(&frame())) {
@@ -1019,19 +1001,12 @@ bool FrameView::flushCompositingStateIncludingSubframes()
          allFramesFlushed &= flushed;
      }
      return allFramesFlushed;
-#else // USE(ACCELERATED_COMPOSITING)
-    return true;
-#endif
  }
  
  bool FrameView::isSoftwareRenderable() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      RenderView* renderView = this->renderView();
      return !renderView || !renderView->compositor().has3DContent();
-#else
-    return true;
-#endif
  }
  
  void FrameView::didMoveOnscreen()
@@ -1328,9 +1303,7 @@ void FrameView::layout(bool allowSubtree)
  
      layer->updateLayerPositionsAfterLayout(renderView()->layer(), updateLayerPositionFlags(layer, subtree, m_needsFullRepaint));
  
-#if USE(ACCELERATED_COMPOSITING)
      updateCompositingLayersAfterLayout();
-#endif
      
      m_layoutCount++;
  
@@ -1494,14 +1467,13 @@ void FrameView::updateCanBlitOnScrollRecursively()
  
  bool FrameView::contentsInCompositedLayer() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      RenderView* renderView = this->renderView();
      if (renderView && renderView->isComposited()) {
          GraphicsLayer* layer = renderView->layer()->backing()->graphicsLayer();
          if (layer && layer->drawsContent())
              return true;
      }
-#endif
+
      return false;
  }
  
@@ -1675,22 +1647,18 @@ bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta, const IntRect
      for (auto& renderer : *m_viewportConstrainedObjects) {
          if (!renderer->style().hasViewportConstrainedPosition())
              continue;
-#if USE(ACCELERATED_COMPOSITING)
          if (renderer->isComposited())
              continue;
-#endif
  
          // Fixed items should always have layers.
          ASSERT(renderer->hasLayer());
          RenderLayer* layer = toRenderBoxModelObject(renderer)->layer();
  
-#if USE(ACCELERATED_COMPOSITING)
          if (layer->viewportConstrainedNotCompositedReason() == RenderLayer::NotCompositedForBoundsOutOfView
              || layer->viewportConstrainedNotCompositedReason() == RenderLayer::NotCompositedForNoVisibleContent) {
              // Don't invalidate for invisible fixed layers.
              continue;
          }
-#endif
  
  #if ENABLE(CSS_FILTERS)
          if (layer->hasAncestorWithFilterOutsets()) {
@@ -1718,14 +1686,12 @@ bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta, const IntRect
          IntRect scrolledRect = updateRect;
          scrolledRect.move(scrollDelta);
          updateRect.unite(scrolledRect);
-#if USE(ACCELERATED_COMPOSITING)
          if (isCompositedContentLayer) {
              updateRect = rootViewToContents(updateRect);
              ASSERT(renderView());
              renderView()->layer()->setBackingNeedsRepaintInRect(updateRect);
              continue;
          }
-#endif
          if (clipsRepaints())
              updateRect.intersect(rectToScroll);
          hostWindow()->invalidateContentsAndRootView(updateRect, false);
@@ -1736,7 +1702,6 @@ bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta, const IntRect
  
  void FrameView::scrollContentsSlowPath(const IntRect& updateRect)
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (contentsInCompositedLayer()) {
          // FIXME: respect paintsEntireContents()?
          IntRect updateRect = visibleContentRect(LegacyIOSDocumentVisibleRect);
@@ -1760,7 +1725,6 @@ void FrameView::scrollContentsSlowPath(const IntRect& updateRect)
              return;
          }
      }
-#endif
  
      ScrollView::scrollContentsSlowPath(updateRect);
  }
@@ -1784,8 +1748,7 @@ void FrameView::setIsOverlapped(bool isOverlapped)
  
      m_isOverlapped = isOverlapped;
      updateCanBlitOnScrollRecursively();
-    
-#if USE(ACCELERATED_COMPOSITING)
+
      if (hasCompositedContentIncludingDescendants()) {
          // Overlap can affect compositing tests, so if it changes, we need to trigger
          // a layer update in the parent document.
@@ -1809,7 +1772,6 @@ void FrameView::setIsOverlapped(bool isOverlapped)
              }
          }
      }
-#endif
  }
  
  bool FrameView::isOverlappedIncludingAncestors() const
@@ -1934,11 +1896,9 @@ void FrameView::setScrollPosition(const IntPoint& scrollPoint)
  
  void FrameView::delegatesScrollingDidChange()
  {
-#if USE(ACCELERATED_COMPOSITING)
      // When we switch to delgatesScrolling mode, we should destroy the scrolling/clipping layers in RenderLayerCompositor.
      if (hasCompositedContent())
          clearBackingStores();
-#endif
  }
  
  #if USE(TILED_BACKING_STORE)
@@ -1991,12 +1951,10 @@ void FrameView::scrollPositionChanged()
      frame().eventHandler().sendScrollEvent();
      frame().eventHandler().dispatchFakeMouseMoveEventSoon();
  
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* renderView = this->renderView()) {
          if (renderView->usesCompositing())
              renderView->compositor().frameViewDidScroll();
      }
-#endif
  }
  
  void FrameView::updateLayerPositionsAfterScrolling()
@@ -2045,7 +2003,6 @@ bool FrameView::shouldUpdateCompositingLayersAfterScrolling() const
  
  void FrameView::updateCompositingLayersAfterScrolling()
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (!shouldUpdateCompositingLayersAfterScrolling())
          return;
  
@@ -2053,7 +2010,6 @@ void FrameView::updateCompositingLayersAfterScrolling()
          if (RenderView* renderView = this->renderView())
              renderView->compositor().updateCompositingLayers(CompositingUpdateOnScroll);
      }
-#endif
  }
  
  bool FrameView::isRubberBandInProgress() const
@@ -2191,41 +2147,33 @@ void FrameView::visibleContentsResized()
      if (!useFixedLayout() && needsLayout())
          layout();
  
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* renderView = this->renderView()) {
          if (renderView->usesCompositing())
              renderView->compositor().frameViewDidChangeSize();
      }
-#endif
  }
  
  void FrameView::addedOrRemovedScrollbar()
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* renderView = this->renderView()) {
          if (renderView->usesCompositing())
              renderView->compositor().frameViewDidAddOrRemoveScrollbars();
      }
-#endif
  }
  
  void FrameView::disableLayerFlushThrottlingTemporarilyForInteraction()
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* view = renderView())
          view->compositor().disableLayerFlushThrottlingTemporarilyForInteraction();
-#endif
  }
  
  void FrameView::updateLayerFlushThrottlingInAllFrames()
  {
-#if USE(ACCELERATED_COMPOSITING)
      bool isMainLoadProgressing = frame().page()->progress().isMainLoadProgressing();
      for (Frame* frame = m_frame.get(); frame; frame = frame->tree().traverseNext(m_frame.get())) {
          if (RenderView* renderView = frame->contentRenderer())
              renderView->compositor().setLayerFlushThrottlingEnabled(isMainLoadProgressing);
      }
-#endif
  }
  
  void FrameView::adjustTiledBackingCoverage()
@@ -2233,11 +2181,9 @@ void FrameView::adjustTiledBackingCoverage()
      if (!m_speculativeTilingEnabled)
          enableSpeculativeTilingIfNeeded();
  
-#if USE(ACCELERATED_COMPOSITING)
      RenderView* renderView = this->renderView();
      if (renderView && renderView->layer()->backing())
          renderView->layer()->backing()->adjustTiledBackingCoverage();
-#endif
  #if PLATFORM(IOS)
      if (TileCache* tileCache = this->tileCache())
          tileCache->setSpeculativeTileCreationEnabled(m_speculativeTilingEnabled);
@@ -2487,7 +2433,6 @@ void FrameView::updateBackgroundRecursively(const Color& backgroundColor, bool t
  
  bool FrameView::hasExtendedBackground() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (!frame().settings().backgroundShouldExtendBeyondPage())
          return false;
  
@@ -2496,29 +2441,17 @@ bool FrameView::hasExtendedBackground() const
          return false;
  
      return tiledBacking->hasMargins();
-#else
-    return false;
-#endif
  }
  
  IntRect FrameView::extendedBackgroundRect() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      TiledBacking* tiledBacking = this->tiledBacking();
      if (!tiledBacking)
          return IntRect();
  
      return tiledBacking->bounds();
-#else
-    RenderView* renderView = this->renderView();
-    if (!renderView)
-        return IntRect();
-
-    return renderView->unscaledDocumentRect();
-#endif
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  void FrameView::setBackgroundExtendsBeyondPage(bool extendBackground)
  {
      RenderView* renderView = this->renderView();
@@ -2531,7 +2464,6 @@ void FrameView::setBackgroundExtendsBeyondPage(bool extendBackground)
  
      backing->setTiledBackingHasMargins(extendBackground);
  }
-#endif
  
  bool FrameView::shouldUpdateWhileOffscreen() const
  {
@@ -2716,12 +2648,10 @@ void FrameView::performPostLayoutTasks()
              scrollingCoordinator->frameViewLayoutUpdated(this);
      }
  
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* renderView = this->renderView()) {
          if (renderView->usesCompositing())
              renderView->compositor().frameViewDidLayout();
      }
-#endif
  
      scrollToAnchor();
  
@@ -3459,10 +3389,8 @@ void FrameView::paintContents(GraphicsContext* p, const IntRect& rect)
  
      FontCachePurgePreventer fontCachePurgePreventer;
  
-#if USE(ACCELERATED_COMPOSITING)
      if (!p->paintingDisabled() && !document->printing())
          flushCompositingStateForThisFrame(&frame());
-#endif
  
      PaintBehavior oldPaintBehavior = m_paintBehavior;
      
@@ -3927,12 +3855,10 @@ void FrameView::setTracksRepaints(bool trackRepaints)
              frame().document()->updateLayout();
      }
  
-#if USE(ACCELERATED_COMPOSITING)
      for (Frame* frame = &m_frame->tree().top(); frame; frame = frame->tree().traverseNext()) {
          if (RenderView* renderView = frame->contentRenderer())
              renderView->compositor().setTracksRepaints(trackRepaints);
      }
-#endif
  
      resetTrackedRepaints();
      m_isTrackingRepaints = trackRepaints;
@@ -3941,10 +3867,8 @@ void FrameView::setTracksRepaints(bool trackRepaints)
  void FrameView::resetTrackedRepaints()
  {
      m_trackedRepaintRects.clear();
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* renderView = this->renderView())
          renderView->compositor().resetTrackedRepaintRects();
-#endif
  }
  
  String FrameView::trackedRepaintRectsAsText() const
@@ -4099,12 +4023,8 @@ bool FrameView::updateFixedPositionLayoutRect()
  
  void FrameView::setScrollingPerformanceLoggingEnabled(bool flag)
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (TiledBacking* tiledBacking = this->tiledBacking())
          tiledBacking->setScrollingPerformanceLoggingEnabled(flag);
-#else
-    UNUSED_PARAM(flag);
-#endif
  }
  
  void FrameView::didAddScrollbar(Scrollbar* scrollbar, ScrollbarOrientation orientation)
@@ -4240,13 +4160,11 @@ void FrameView::setExposedRect(FloatRect exposedRect)
  
      m_exposedRect = exposedRect;
  
-#if USE(ACCELERATED_COMPOSITING)
      // FIXME: We should support clipping to the exposed rect for subframes as well.
      if (m_frame->isMainFrame()) {
          if (TiledBacking* tiledBacking = this->tiledBacking())
              tiledBacking->setExposedRect(exposedRect);
      }
-#endif
  }
  
  } // namespace WebCore
diff --git a/Source/WebCore/page/FrameView.h b/Source/WebCore/page/FrameView.h

index b1326844f28f7dc84de7b0af2ee8315a36aa75c0..ed20bd263281e96d6edbd2c9b0588d2ec1301c0f 100644 (file)
--- a/Source/WebCore/page/FrameView.h
+++ b/Source/WebCore/page/FrameView.h
@@ -135,7 +135,6 @@ public:
      void serviceScriptedAnimations(double monotonicAnimationStartTime);
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
      void updateCompositingLayersAfterStyleChange();
      void updateCompositingLayersAfterLayout();
      bool flushCompositingStateForThisFrame(Frame* rootFrameForFlush);
@@ -155,7 +154,6 @@ public:
      // In the future when any ScrollableArea can have a node in th ScrollingTree, this should
      // become a virtual function on ScrollableArea.
      uint64_t scrollLayerID() const;
-#endif
  
      bool hasCompositedContent() const;
      bool hasCompositedContentIncludingDescendants() const;
@@ -197,9 +195,7 @@ public:
      bool hasExtendedBackground() const;
      IntRect extendedBackgroundRect() const;
      
-#if USE(ACCELERATED_COMPOSITING)
      void setBackgroundExtendsBeyondPage(bool);
-#endif
  
      bool shouldUpdateWhileOffscreen() const;
      void setShouldUpdateWhileOffscreen(bool);
@@ -516,7 +512,6 @@ private:
      virtual ScrollableArea* enclosingScrollableArea() const override;
      virtual IntRect scrollableAreaBoundingBox() const override;
      virtual bool scrollAnimatorEnabled() const override;
-#if USE(ACCELERATED_COMPOSITING)
      virtual bool usesCompositedScrolling() const override;
      virtual GraphicsLayer* layerForScrolling() const override;
      virtual GraphicsLayer* layerForHorizontalScrollbar() const override;
@@ -524,7 +519,6 @@ private:
      virtual GraphicsLayer* layerForScrollCorner() const override;
  #if ENABLE(RUBBER_BANDING)
      virtual GraphicsLayer* layerForOverhangAreas() const override;
-#endif
  #endif
  
      // Override scrollbar notifications to update the AXObject cache.
diff --git a/Source/WebCore/page/Page.cpp b/Source/WebCore/page/Page.cpp

index d4638e9d0ce35736df372c3482171e76a9b8cf25..a69f55536dde9354ba0a4f7d100d8d0a4dc1cb15 100644 (file)
--- a/Source/WebCore/page/Page.cpp
+++ b/Source/WebCore/page/Page.cpp
@@ -723,9 +723,7 @@ void Page::setPageScaleFactor(float scale, const IntPoint& origin)
          mainFrame().view()->invalidateRect(IntRect(LayoutRect::infiniteRect()));
      }
  
-#if USE(ACCELERATED_COMPOSITING)
      mainFrame().deviceOrPageScaleFactorChanged();
-#endif
  
      if (view && view->fixedElementsLayoutRelativeToFrame())
          view->setViewportConstrainedObjectsNeedLayout();
@@ -746,10 +744,8 @@ void Page::setDeviceScaleFactor(float scaleFactor)
      m_deviceScaleFactor = scaleFactor;
      setNeedsRecalcStyleInAllFrames();
  
-#if USE(ACCELERATED_COMPOSITING)
      mainFrame().deviceOrPageScaleFactorChanged();
      pageCache()->markPagesForDeviceScaleChanged(this);
-#endif
  
      for (Frame* frame = &mainFrame(); frame; frame = frame->tree().traverseNext())
          frame->editor().deviceScaleFactorChanged();
diff --git a/Source/WebCore/page/Settings.cpp b/Source/WebCore/page/Settings.cpp

index 67a7cbcc33cd3f761b37056141fff74819ead6f3..aad81496208b23ac8a8ec4f912f4f1bd1e0919e1 100644 (file)
--- a/Source/WebCore/page/Settings.cpp
+++ b/Source/WebCore/page/Settings.cpp
@@ -604,9 +604,7 @@ void Settings::setBackgroundShouldExtendBeyondPage(bool shouldExtend)
  
      m_backgroundShouldExtendBeyondPage = shouldExtend;
  
-#if USE(ACCELERATED_COMPOSITING)
      m_page->mainFrame().view()->setBackgroundExtendsBeyondPage(shouldExtend);
-#endif
  }
  
  #if USE(AVFOUNDATION)
diff --git a/Source/WebCore/page/animation/AnimationBase.cpp b/Source/WebCore/page/animation/AnimationBase.cpp

index dd3315ebb069614d8c011a4b59e5e557a9510511..f5044b852d1469bb26c4fc0d1a6dbeaa34760ca5 100644 (file)
--- a/Source/WebCore/page/animation/AnimationBase.cpp
+++ b/Source/WebCore/page/animation/AnimationBase.cpp
@@ -659,10 +659,8 @@ void AnimationBase::freezeAtTime(double t)
      else
          m_pauseTime = m_startTime + t - m_animation->delay();
  
-#if USE(ACCELERATED_COMPOSITING)
      if (m_object && m_object->isComposited())
          toRenderBoxModelObject(m_object)->suspendAnimations(m_pauseTime);
-#endif
  }
  
  double AnimationBase::beginAnimationUpdateTime() const
diff --git a/Source/WebCore/page/animation/AnimationController.cpp b/Source/WebCore/page/animation/AnimationController.cpp

index 5b8c90b8ab1702223fd9a380e85d2cf41fff2809..b7c94ed66e572ac9304201ba74ef0442fa7884b1 100644 (file)
--- a/Source/WebCore/page/animation/AnimationController.cpp
+++ b/Source/WebCore/page/animation/AnimationController.cpp
@@ -634,12 +634,7 @@ void AnimationController::endAnimationUpdate()
  
  bool AnimationController::supportsAcceleratedAnimationOfProperty(CSSPropertyID property)
  {
-#if USE(ACCELERATED_COMPOSITING)
      return CSSPropertyAnimation::animationOfPropertyIsAccelerated(property);
-#else
-    UNUSED_PARAM(property);
-    return false;
-#endif
  }
  
  } // namespace WebCore
diff --git a/Source/WebCore/page/animation/CSSPropertyAnimation.cpp b/Source/WebCore/page/animation/CSSPropertyAnimation.cpp

index 291129e932c12e6868e9b4a564d4f0e5d50ed705..cfb320fb9d753203d189ef8ea6e3c1c6b5c8665c 100644 (file)
--- a/Source/WebCore/page/animation/CSSPropertyAnimation.cpp
+++ b/Source/WebCore/page/animation/CSSPropertyAnimation.cpp
@@ -389,9 +389,7 @@ public:
  
      CSSPropertyID property() const { return m_prop; }
  
-#if USE(ACCELERATED_COMPOSITING)
      virtual bool animationIsAccelerated() const { return false; }
-#endif
  
  private:
      CSSPropertyID m_prop;
@@ -533,7 +531,6 @@ protected:
  };
  
  
-#if USE(ACCELERATED_COMPOSITING)
  class PropertyWrapperAcceleratedOpacity : public PropertyWrapper<float> {
  public:
      PropertyWrapperAcceleratedOpacity()
@@ -583,7 +580,6 @@ public:
      }
  };
  #endif
-#endif // USE(ACCELERATED_COMPOSITING)
  
  static inline size_t shadowListLength(const ShadowData* shadow)
  {
@@ -1232,18 +1228,10 @@ CSSPropertyAnimationWrapperMap::CSSPropertyAnimationWrapperMap()
  
          new LengthPropertyWrapper<LengthBox>(CSSPropertyClip, &RenderStyle::clip, &RenderStyle::setClip),
  
-#if USE(ACCELERATED_COMPOSITING)
          new PropertyWrapperAcceleratedOpacity(),
          new PropertyWrapperAcceleratedTransform(),
  #if ENABLE(CSS_FILTERS)
          new PropertyWrapperAcceleratedFilter(),
-#endif
-#else
-        new PropertyWrapper<float>(CSSPropertyOpacity, &RenderStyle::opacity, &RenderStyle::setOpacity),
-        new PropertyWrapper<const TransformOperations&>(CSSPropertyWebkitTransform, &RenderStyle::transform, &RenderStyle::setTransform),
-#if ENABLE(CSS_FILTERS)
-        new PropertyWrapper<const FilterOperations&>(CSSPropertyWebkitFilter, &RenderStyle::filter, &RenderStyle::setFilter),
-#endif
  #endif
  
          new PropertyWrapperClipPath(CSSPropertyWebkitClipPath, &RenderStyle::clipPath, &RenderStyle::setClipPath),
@@ -1393,23 +1381,17 @@ bool CSSPropertyAnimation::blendProperties(const AnimationBase* anim, CSSPropert
      AnimationPropertyWrapperBase* wrapper = CSSPropertyAnimationWrapperMap::instance().wrapperForProperty(prop);
      if (wrapper) {
          wrapper->blend(anim, dst, a, b, progress);
-#if USE(ACCELERATED_COMPOSITING)
          return !wrapper->animationIsAccelerated() || !anim->isAccelerated();
-#else
-        return true;
-#endif
      }
  
      return false;
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  bool CSSPropertyAnimation::animationOfPropertyIsAccelerated(CSSPropertyID prop)
  {
      AnimationPropertyWrapperBase* wrapper = CSSPropertyAnimationWrapperMap::instance().wrapperForProperty(prop);
      return wrapper ? wrapper->animationIsAccelerated() : false;
  }
-#endif
  
  // Note: this is inefficient. It's only called from pauseTransitionAtTime().
  HashSet<CSSPropertyID> CSSPropertyAnimation::animatableShorthandsAffectingProperty(CSSPropertyID property)
diff --git a/Source/WebCore/page/animation/CSSPropertyAnimation.h b/Source/WebCore/page/animation/CSSPropertyAnimation.h

index c41c7dd90c3927ca4e28aab5c33f550337c8c441..b21466f0f8fee365c87d22925e858dc7a7ac01a6 100644 (file)
--- a/Source/WebCore/page/animation/CSSPropertyAnimation.h
+++ b/Source/WebCore/page/animation/CSSPropertyAnimation.h
@@ -40,9 +40,7 @@ class RenderStyle;
  
  class CSSPropertyAnimation {
  public:
-#if USE(ACCELERATED_COMPOSITING)
      static bool animationOfPropertyIsAccelerated(CSSPropertyID);
-#endif
      static bool propertiesEqual(CSSPropertyID, const RenderStyle* a, const RenderStyle* b);
      static CSSPropertyID getPropertyAtIndex(int, bool& isShorthand);
      static int getNumProperties();
diff --git a/Source/WebCore/page/animation/CompositeAnimation.cpp b/Source/WebCore/page/animation/CompositeAnimation.cpp

index e18779ea714b5d34721ec022973502d6be0639e2..1c95d90197e3780de0e978de4c0d78c5af75438e 100644 (file)
--- a/Source/WebCore/page/animation/CompositeAnimation.cpp
+++ b/Source/WebCore/page/animation/CompositeAnimation.cpp
@@ -148,7 +148,6 @@ void CompositeAnimation::updateTransitions(RenderElement* renderer, RenderStyle*
                      // list. In this case, the latter one overrides the earlier one, so we
                      // behave as though this is a running animation being replaced.
                      if (!implAnim->isTargetPropertyEqual(prop, targetStyle)) {
-#if USE(ACCELERATED_COMPOSITING)
                          // For accelerated animations we need to return a new RenderStyle with the _current_ value
                          // of the property, so that restarted transitions use the correct starting point.
                          if (CSSPropertyAnimation::animationOfPropertyIsAccelerated(prop) && implAnim->isAccelerated()) {
@@ -157,7 +156,6 @@ void CompositeAnimation::updateTransitions(RenderElement* renderer, RenderStyle*
  
                              implAnim->blendPropertyValueInStyle(prop, modifiedCurrentStyle.get());
                          }
-#endif
                          LOG(Animations, "Removing existing ImplicitAnimation %p for property %s", implAnim, getPropertyName(prop));
                          animationController()->animationWillBeRemoved(implAnim);
                          m_transitions.remove(prop);
diff --git a/Source/WebCore/page/animation/ImplicitAnimation.cpp b/Source/WebCore/page/animation/ImplicitAnimation.cpp

index af1d7881906c7604889752949413686ced202aed..fee6c0750065b812262aeb735e35d224bf25588d 100644 (file)
--- a/Source/WebCore/page/animation/ImplicitAnimation.cpp
+++ b/Source/WebCore/page/animation/ImplicitAnimation.cpp
@@ -77,7 +77,6 @@ void ImplicitAnimation::animate(CompositeAnimation*, RenderElement*, const Rende
      if (!animatedStyle)
          animatedStyle = RenderStyle::clone(targetStyle);
  
-#if USE(ACCELERATED_COMPOSITING)
      bool needsAnim = CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
      // FIXME: we also need to detect cases where we have to software animate for other reasons,
      // such as a child using inheriting the transform. https://bugs.webkit.org/show_bug.cgi?id=23902
@@ -87,7 +86,6 @@ void ImplicitAnimation::animate(CompositeAnimation*, RenderElement*, const Rende
          // that is animating are correctly detected during the animation (e.g. when a transition
          // gets interrupted).
          animatedStyle->setIsRunningAcceleratedAnimation();
-#endif
  
      // Fire the start timeout if needed
      fireAnimationEventsIfNeeded();
@@ -103,12 +101,8 @@ void ImplicitAnimation::getAnimatedStyle(RefPtr<RenderStyle>& animatedStyle)
  
  bool ImplicitAnimation::startAnimation(double timeOffset)
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (m_object && m_object->isComposited())
          return toRenderBoxModelObject(m_object)->startTransition(timeOffset, m_animatingProperty, m_fromStyle.get(), m_toStyle.get());
-#else
-    UNUSED_PARAM(timeOffset);
-#endif
      return false;
  }
  
@@ -117,12 +111,8 @@ void ImplicitAnimation::pauseAnimation(double timeOffset)
      if (!m_object)
          return;
  
-#if USE(ACCELERATED_COMPOSITING)
      if (m_object->isComposited())
          toRenderBoxModelObject(m_object)->transitionPaused(timeOffset, m_animatingProperty);
-#else
-    UNUSED_PARAM(timeOffset);
-#endif
      // Restore the original (unanimated) style
      if (!paused())
          setNeedsStyleRecalc(m_object->element());
@@ -130,10 +120,8 @@ void ImplicitAnimation::pauseAnimation(double timeOffset)
  
  void ImplicitAnimation::endAnimation()
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (m_object && m_object->isComposited())
          toRenderBoxModelObject(m_object)->transitionFinished(m_animatingProperty);
-#endif
  }
  
  void ImplicitAnimation::onAnimationEnd(double elapsedTime)
@@ -285,7 +273,6 @@ void ImplicitAnimation::checkForMatchingFilterFunctionLists()
  double ImplicitAnimation::timeToNextService()
  {
      double t = AnimationBase::timeToNextService();
-#if USE(ACCELERATED_COMPOSITING)
      if (t != 0 || preActive())
          return t;
          
@@ -295,7 +282,6 @@ double ImplicitAnimation::timeToNextService()
          bool isLooping;
          getTimeToNextEvent(t, isLooping);
      }
-#endif
      return t;
  }
  
diff --git a/Source/WebCore/page/animation/KeyframeAnimation.cpp b/Source/WebCore/page/animation/KeyframeAnimation.cpp

index 8f661c6c318cc8c31296cbcdc194de806c8648d8..bf10c27697df9a4d159d35b616221663db7693c4 100644 (file)
--- a/Source/WebCore/page/animation/KeyframeAnimation.cpp
+++ b/Source/WebCore/page/animation/KeyframeAnimation.cpp
@@ -183,14 +183,12 @@ void KeyframeAnimation::animate(CompositeAnimation* compositeAnimation, RenderEl
          double progress = 0.0;
          fetchIntervalEndpointsForProperty(*it, fromStyle, toStyle, progress);
  
-#if USE(ACCELERATED_COMPOSITING)
          bool needsAnim = CSSPropertyAnimation::blendProperties(this, *it, animatedStyle.get(), fromStyle, toStyle, progress);
          if (!needsAnim)
              // If we are running an accelerated animation, set a flag in the style
              // to indicate it. This can be used to make sure we get an updated
              // style for hit testing, etc.
              animatedStyle->setIsRunningAcceleratedAnimation();
-#endif
      }
  }
  
@@ -226,13 +224,9 @@ bool KeyframeAnimation::hasAnimationForProperty(CSSPropertyID property) const
  
  bool KeyframeAnimation::startAnimation(double timeOffset)
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (m_object && m_object->isComposited()) {
          return toRenderBoxModelObject(m_object)->startAnimation(timeOffset, m_animation.get(), m_keyframes);
      }
-#else
-    UNUSED_PARAM(timeOffset);
-#endif
      return false;
  }
  
@@ -241,12 +235,9 @@ void KeyframeAnimation::pauseAnimation(double timeOffset)
      if (!m_object)
          return;
  
-#if USE(ACCELERATED_COMPOSITING)
      if (m_object->isComposited())
          toRenderBoxModelObject(m_object)->animationPaused(timeOffset, m_keyframes.animationName());
-#else
-    UNUSED_PARAM(timeOffset);
-#endif
+
      // Restore the original (unanimated) style
      if (!paused())
          setNeedsStyleRecalc(m_object->element());
@@ -257,10 +248,9 @@ void KeyframeAnimation::endAnimation()
      if (!m_object)
          return;
  
-#if USE(ACCELERATED_COMPOSITING)
      if (m_object->isComposited())
          toRenderBoxModelObject(m_object)->animationFinished(m_keyframes.animationName());
-#endif
+
      // Restore the original (unanimated) style
      if (!paused())
          setNeedsStyleRecalc(m_object->element());
@@ -432,7 +422,6 @@ void KeyframeAnimation::checkForMatchingFilterFunctionLists()
  double KeyframeAnimation::timeToNextService()
  {
      double t = AnimationBase::timeToNextService();
-#if USE(ACCELERATED_COMPOSITING)
      if (t != 0 || preActive())
          return t;
          
@@ -452,7 +441,7 @@ double KeyframeAnimation::timeToNextService()
          bool isLooping;
          getTimeToNextEvent(t, isLooping);
      }
-#endif
+
      return t;
  }
  
diff --git a/Source/WebCore/page/ios/FrameIOS.mm b/Source/WebCore/page/ios/FrameIOS.mm

index 14968b6c8353f326c02e6395ba3d25df2278613c..b4e3c3c2a7ebf16120217fce1fec20a4115ac6d6 100644 (file)
--- a/Source/WebCore/page/ios/FrameIOS.mm
+++ b/Source/WebCore/page/ios/FrameIOS.mm
@@ -876,7 +876,6 @@ static bool anyFrameHasTiledLayers(Frame* rootFrame)
  
  void Frame::viewportOffsetChanged(ViewportOffsetChangeType changeType)
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (changeType == IncrementalScrollOffset) {
          if (anyFrameHasTiledLayers(this)) {
              if (RenderView* root = contentRenderer())
@@ -888,15 +887,13 @@ void Frame::viewportOffsetChanged(ViewportOffsetChangeType changeType)
          if (RenderView* root = contentRenderer())
              root->compositor().updateCompositingLayers(CompositingUpdateOnScroll);
      }
-#endif
  }
  
  bool Frame::containsTiledBackingLayers() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* root = contentRenderer())
          return root->compositor().hasNonMainLayersWithTiledBacking();
-#endif
+
      return false;
  }
  
diff --git a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp

index 77c50b842cba519fd0f0148a99ca124f2e0ad596..273861c13542b94353dc157b3989480d893176e8 100644 (file)
--- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
+++ b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
@@ -197,7 +197,6 @@ void AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScroll(ScrollingNo
  
      frameView->setInProgrammaticScroll(oldProgrammaticScroll);
  
-#if USE(ACCELERATED_COMPOSITING)
      if (scrollingNodeID == frameView->scrollLayerID()) {
          if (GraphicsLayer* scrollLayer = scrollLayerForFrameView(frameView)) {
              GraphicsLayer* counterScrollingLayer = counterScrollingLayerForFrameView(frameView);
@@ -228,9 +227,6 @@ void AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScroll(ScrollingNo
          }
      }
      // FIXME: handle non-main scrolling nodes.
-#else
-    UNUSED_PARAM(scrollingLayerPositionAction);
-#endif
  }
  
  void AsyncScrollingCoordinator::scrollableAreaScrollbarLayerDidChange(ScrollableArea* scrollableArea, ScrollbarOrientation orientation)
diff --git a/Source/WebCore/page/scrolling/ScrollingCoordinator.cpp b/Source/WebCore/page/scrolling/ScrollingCoordinator.cpp

index 93dfb0cec4b9e18ec98b31ac9be1bc0fa337ef5d..8e3256eb33bfdc93bc0d63229834d3f55b2aab0c 100644 (file)
--- a/Source/WebCore/page/scrolling/ScrollingCoordinator.cpp
+++ b/Source/WebCore/page/scrolling/ScrollingCoordinator.cpp
@@ -36,15 +36,12 @@
  #include "PlatformWheelEvent.h"
  #include "PluginViewBase.h"
  #include "Region.h"
+#include "RenderLayerCompositor.h"
  #include "RenderView.h"
  #include "ScrollAnimator.h"
  #include <wtf/MainThread.h>
  #include <wtf/text/StringBuilder.h>
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "RenderLayerCompositor.h"
-#endif
-
  #if USE(COORDINATED_GRAPHICS)
  #include "ScrollingCoordinatorCoordinatedGraphics.h"
  #endif
@@ -89,14 +86,10 @@ bool ScrollingCoordinator::coordinatesScrollingForFrameView(FrameView* frameView
          return false;
  
      // We currently only support composited mode.
-#if USE(ACCELERATED_COMPOSITING)
      RenderView* renderView = m_page->mainFrame().contentRenderer();
      if (!renderView)
          return false;
      return renderView->usesCompositing();
-#else
-    return false;
-#endif
  }
  
  Region ScrollingCoordinator::computeNonFastScrollableRegion(const Frame* frame, const IntPoint& frameLocation) const
@@ -112,11 +105,9 @@ Region ScrollingCoordinator::computeNonFastScrollableRegion(const Frame* frame,
      if (const FrameView::ScrollableAreaSet* scrollableAreas = frameView->scrollableAreas()) {
          for (FrameView::ScrollableAreaSet::const_iterator it = scrollableAreas->begin(), end = scrollableAreas->end(); it != end; ++it) {
              ScrollableArea* scrollableArea = *it;
-#if USE(ACCELERATED_COMPOSITING)
              // Composited scrollable areas can be scrolled off the main thread.
              if (scrollableArea->usesCompositedScrolling())
                  continue;
-#endif
              IntRect box = scrollableArea->scrollableAreaBoundingBox();
              box.moveBy(offset);
              nonFastScrollableRegion.unite(box);
@@ -179,7 +170,6 @@ void ScrollingCoordinator::frameViewFixedObjectsDidChange(FrameView* frameView)
      updateSynchronousScrollingReasons();
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  GraphicsLayer* ScrollingCoordinator::scrollLayerForScrollableArea(ScrollableArea* scrollableArea)
  {
      return scrollableArea->layerForScrolling();
@@ -194,23 +184,17 @@ GraphicsLayer* ScrollingCoordinator::verticalScrollbarLayerForScrollableArea(Scr
  {
      return scrollableArea->layerForVerticalScrollbar();
  }
-#endif
  
  GraphicsLayer* ScrollingCoordinator::scrollLayerForFrameView(FrameView* frameView)
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* renderView = frameView->frame().contentRenderer())
          return renderView->compositor().scrollLayer();
      return 0;
-#else
-    UNUSED_PARAM(frameView);
-    return 0;
-#endif
  }
  
  GraphicsLayer* ScrollingCoordinator::headerLayerForFrameView(FrameView* frameView)
  {
-#if USE(ACCELERATED_COMPOSITING) && ENABLE(RUBBER_BANDING)
+#if ENABLE(RUBBER_BANDING)
      if (RenderView* renderView = frameView->frame().contentRenderer())
          renderView->compositor().headerLayer();
      return 0;
@@ -222,7 +206,7 @@ GraphicsLayer* ScrollingCoordinator::headerLayerForFrameView(FrameView* frameVie
  
  GraphicsLayer* ScrollingCoordinator::footerLayerForFrameView(FrameView* frameView)
  {
-#if USE(ACCELERATED_COMPOSITING) && ENABLE(RUBBER_BANDING)
+#if ENABLE(RUBBER_BANDING)
      if (RenderView* renderView = frameView->frame().contentRenderer())
          return renderView->compositor().footerLayer();
      return 0;
@@ -234,14 +218,9 @@ GraphicsLayer* ScrollingCoordinator::footerLayerForFrameView(FrameView* frameVie
  
  GraphicsLayer* ScrollingCoordinator::counterScrollingLayerForFrameView(FrameView* frameView)
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (RenderView* renderView = frameView->frame().contentRenderer())
          return renderView->compositor().fixedRootBackgroundLayer();
      return 0;
-#else
-    UNUSED_PARAM(frameView);
-    return 0;
-#endif
  }
  
  void ScrollingCoordinator::frameViewRootLayerDidChange(FrameView* frameView)
@@ -279,7 +258,6 @@ bool ScrollingCoordinator::hasVisibleSlowRepaintViewportConstrainedObjects(Frame
      if (!viewportConstrainedObjects)
          return false;
  
-#if USE(ACCELERATED_COMPOSITING)
      for (FrameView::ViewportConstrainedObjectSet::const_iterator it = viewportConstrainedObjects->begin(), end = viewportConstrainedObjects->end(); it != end; ++it) {
          RenderObject* viewportConstrainedObject = *it;
          if (!viewportConstrainedObject->isBoxModelObject() || !viewportConstrainedObject->hasLayer())
@@ -290,9 +268,6 @@ bool ScrollingCoordinator::hasVisibleSlowRepaintViewportConstrainedObjects(Frame
              return true;
      }
      return false;
-#else
-    return viewportConstrainedObjects->size();
-#endif
  }
  
  SynchronousScrollingReasons ScrollingCoordinator::synchronousScrollingReasons() const
diff --git a/Source/WebCore/page/scrolling/ScrollingCoordinator.h b/Source/WebCore/page/scrolling/ScrollingCoordinator.h

index 0e05d69fdd8c8b8d6ee0723221a97f1c5f726b03..9247ba39af7e83b2d6fb1c9fb02d6bc21269dc74 100644 (file)
--- a/Source/WebCore/page/scrolling/ScrollingCoordinator.h
+++ b/Source/WebCore/page/scrolling/ScrollingCoordinator.h
@@ -182,11 +182,9 @@ public:
  protected:
      explicit ScrollingCoordinator(Page*);
  
-#if USE(ACCELERATED_COMPOSITING)
      static GraphicsLayer* scrollLayerForScrollableArea(ScrollableArea*);
      static GraphicsLayer* horizontalScrollbarLayerForScrollableArea(ScrollableArea*);
      static GraphicsLayer* verticalScrollbarLayerForScrollableArea(ScrollableArea*);
-#endif
  
      unsigned computeCurrentWheelEventHandlerCount();
      GraphicsLayer* scrollLayerForFrameView(FrameView*);
diff --git a/Source/WebCore/platform/ScrollView.cpp b/Source/WebCore/platform/ScrollView.cpp

index 2e81d22c9ff43771b46e8b1618b9a2f556174661..5974f84135fcd2c57189a2ac4627798e2ff48a42 100644 (file)
--- a/Source/WebCore/platform/ScrollView.cpp
+++ b/Source/WebCore/platform/ScrollView.cpp
@@ -976,7 +976,6 @@ void ScrollView::clipRectChanged()
          (*current)->clipRectChanged();
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  static void positionScrollbarLayer(GraphicsLayer* graphicsLayer, Scrollbar* scrollbar)
  {
      if (!graphicsLayer || !scrollbar)
@@ -1009,16 +1008,12 @@ static void positionScrollCornerLayer(GraphicsLayer* graphicsLayer, const IntRec
          graphicsLayer->setNeedsDisplay();
      graphicsLayer->setSize(cornerRect.size());
  }
-#endif
-
  
  void ScrollView::positionScrollbarLayers()
  {
-#if USE(ACCELERATED_COMPOSITING)
      positionScrollbarLayer(layerForHorizontalScrollbar(), horizontalScrollbar());
      positionScrollbarLayer(layerForVerticalScrollbar(), verticalScrollbar());
      positionScrollCornerLayer(layerForScrollCorner(), scrollCornerRect());
-#endif
  }
  
  void ScrollView::repaintContentRectangle(const IntRect& rect, bool now)
@@ -1099,23 +1094,14 @@ void ScrollView::invalidateScrollCornerRect(const IntRect& rect)
  
  void ScrollView::paintScrollbars(GraphicsContext* context, const IntRect& rect)
  {
-    if (m_horizontalScrollbar
-#if USE(ACCELERATED_COMPOSITING)
-        && !layerForHorizontalScrollbar()
-#endif
-                                      )
+    if (m_horizontalScrollbar && !layerForHorizontalScrollbar())
          paintScrollbar(context, m_horizontalScrollbar.get(), rect);
-    if (m_verticalScrollbar
-#if USE(ACCELERATED_COMPOSITING)
-        && !layerForVerticalScrollbar()
-#endif
-                                    )
+    if (m_verticalScrollbar && !layerForVerticalScrollbar())
          paintScrollbar(context, m_verticalScrollbar.get(), rect);
  
-#if USE(ACCELERATED_COMPOSITING)
      if (layerForScrollCorner())
          return;
-#endif
+
      paintScrollCorner(context, scrollCornerRect());
  }
  
@@ -1162,7 +1148,7 @@ void ScrollView::paint(GraphicsContext* context, const IntRect& rect)
          paintContents(context, documentDirtyRect);
      }
  
-#if USE(ACCELERATED_COMPOSITING) && ENABLE(RUBBER_BANDING)
+#if ENABLE(RUBBER_BANDING)
      if (!layerForOverhangAreas())
          calculateAndPaintOverhangAreas(context, rect);
  #else
diff --git a/Source/WebCore/platform/ScrollableArea.cpp b/Source/WebCore/platform/ScrollableArea.cpp

index 88d02938f651f3cda803995716a203225c24e173..85f58529b65b2a0c1f0d44d7645f5ccf3dbcfaa4 100644 (file)
--- a/Source/WebCore/platform/ScrollableArea.cpp
+++ b/Source/WebCore/platform/ScrollableArea.cpp
@@ -322,7 +322,6 @@ void ScrollableArea::setScrollbarOverlayStyle(ScrollbarOverlayStyle overlayStyle
  
  void ScrollableArea::invalidateScrollbar(Scrollbar* scrollbar, const IntRect& rect)
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (scrollbar == horizontalScrollbar()) {
          if (GraphicsLayer* graphicsLayer = layerForHorizontalScrollbar()) {
              graphicsLayer->setNeedsDisplay();
@@ -336,22 +335,20 @@ void ScrollableArea::invalidateScrollbar(Scrollbar* scrollbar, const IntRect& re
              return;
          }
      }
-#endif
+
      invalidateScrollbarRect(scrollbar, rect);
  }
  
  void ScrollableArea::invalidateScrollCorner(const IntRect& rect)
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (GraphicsLayer* graphicsLayer = layerForScrollCorner()) {
          graphicsLayer->setNeedsDisplay();
          return;
      }
-#endif
+
      invalidateScrollCornerRect(rect);
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  void ScrollableArea::verticalScrollbarLayerDidChange()
  {
      scrollAnimator()->verticalScrollbarLayerDidChange();
@@ -361,33 +358,20 @@ void ScrollableArea::horizontalScrollbarLayerDidChange()
  {
      scrollAnimator()->horizontalScrollbarLayerDidChange();
  }
-#endif
  
  bool ScrollableArea::hasLayerForHorizontalScrollbar() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      return layerForHorizontalScrollbar();
-#else
-    return false;
-#endif
  }
  
  bool ScrollableArea::hasLayerForVerticalScrollbar() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      return layerForVerticalScrollbar();
-#else
-    return false;
-#endif
  }
  
  bool ScrollableArea::hasLayerForScrollCorner() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      return layerForScrollCorner();
-#else
-    return false;
-#endif
  }
  
  void ScrollableArea::serviceScrollAnimations()
diff --git a/Source/WebCore/platform/ScrollableArea.h b/Source/WebCore/platform/ScrollableArea.h

index 8d6f40ca2feec4cc15264cb984bdaa05d6fc63fd..7b40770f1295bddf9a4b541748d67d1db20c37b5 100644 (file)
--- a/Source/WebCore/platform/ScrollableArea.h
+++ b/Source/WebCore/platform/ScrollableArea.h
@@ -36,10 +36,8 @@ class GraphicsContext;
  class PlatformTouchEvent;
  class PlatformWheelEvent;
  class ScrollAnimator;
-#if USE(ACCELERATED_COMPOSITING)
  class GraphicsLayer;
  class TiledBacking;
-#endif
  
  class ScrollableArea {
  public:
@@ -221,7 +219,6 @@ public:
      bool isPinnedVerticallyInDirection(int verticalScrollDelta) const;
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
      virtual TiledBacking* tiledBacking() const { return 0; }
      virtual bool usesCompositedScrolling() const { return false; }
  
@@ -230,7 +227,6 @@ public:
  
      void verticalScrollbarLayerDidChange();
      void horizontalScrollbarLayerDidChange();
-#endif
  
  protected:
      ScrollableArea();
@@ -242,14 +238,13 @@ protected:
      virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) = 0;
      virtual void invalidateScrollCornerRect(const IntRect&) = 0;
  
-#if USE(ACCELERATED_COMPOSITING)
      friend class ScrollingCoordinator;
      virtual GraphicsLayer* layerForScrolling() const { return 0; }
      virtual GraphicsLayer* layerForScrollCorner() const { return 0; }
  #if ENABLE(RUBBER_BANDING)
      virtual GraphicsLayer* layerForOverhangAreas() const { return 0; }
  #endif
-#endif
+
      bool hasLayerForHorizontalScrollbar() const;
      bool hasLayerForVerticalScrollbar() const;
      bool hasLayerForScrollCorner() const;
diff --git a/Source/WebCore/platform/ScrollbarTheme.h b/Source/WebCore/platform/ScrollbarTheme.h

index d68e062883803b4efa596f3584db8bfe83fbafc9..5898bd8a8ee368c6bdde67caf4eabc2f5807a770 100644 (file)
--- a/Source/WebCore/platform/ScrollbarTheme.h
+++ b/Source/WebCore/platform/ScrollbarTheme.h
@@ -36,7 +36,7 @@ class PlatformMouseEvent;
  class ScrollbarThemeClient;
  class ScrollView;
  
-#if USE(ACCELERATED_COMPOSITING) && ENABLE(RUBBER_BANDING)
+#if ENABLE(RUBBER_BANDING)
  class GraphicsLayer;
  #endif
  
@@ -90,7 +90,7 @@ public:
      virtual void paintTickmarks(GraphicsContext*, ScrollbarThemeClient*, const IntRect&) { }
      virtual void paintOverhangAreas(ScrollView*, GraphicsContext*, const IntRect&, const IntRect&, const IntRect&) { }
  
-#if USE(ACCELERATED_COMPOSITING) && ENABLE(RUBBER_BANDING)
+#if ENABLE(RUBBER_BANDING)
      virtual void setUpOverhangAreasLayerContents(GraphicsLayer*, const Color&) { }
      virtual void setUpContentShadowLayer(GraphicsLayer*) { }
  #endif
diff --git a/Source/WebCore/platform/efl/EflScreenUtilities.cpp b/Source/WebCore/platform/efl/EflScreenUtilities.cpp

index 133a1acfd4ed089f730d1907bb22a8bc4e6344d3..5dc091abfefe5638efa5d91bf8a211fed022892b 100644 (file)
--- a/Source/WebCore/platform/efl/EflScreenUtilities.cpp
+++ b/Source/WebCore/platform/efl/EflScreenUtilities.cpp
@@ -114,12 +114,10 @@ void applyFallbackCursor(Ecore_Evas* ecoreEvas, const char* cursorString)
      }
  
      Ecore_X_Window window;
-#if USE(ACCELERATED_COMPOSITING)
      window = ecore_evas_gl_x11_window_get(ecoreEvas);
      // Fallback to software mode if necessary.
      if (!window)
-#endif
-    window = ecore_evas_software_x11_window_get(ecoreEvas);
+        window = ecore_evas_software_x11_window_get(ecoreEvas);
  
      Ecore_X_Cursor cursor = ecore_x_cursor_shape_get(shape);
      ecore_x_window_cursor_set(window, cursor);
diff --git a/Source/WebCore/platform/graphics/GraphicsContext3D.h b/Source/WebCore/platform/graphics/GraphicsContext3D.h

index 705c3272bb7d5ccb2b90ccadde55fc4abe4ae140..c3f3e79bfcd2629e644967835501700150029a08 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsContext3D.h
+++ b/Source/WebCore/platform/graphics/GraphicsContext3D.h
@@ -491,9 +491,7 @@ public:
  #else
      PlatformGraphicsContext3D platformGraphicsContext3D();
      Platform3DObject platformTexture() const;
-#if USE(ACCELERATED_COMPOSITING) 
      PlatformLayer* platformLayer() const;
-#endif
  #endif
  
      bool makeContextCurrent();
diff --git a/Source/WebCore/platform/graphics/GraphicsContext3DPrivate.cpp b/Source/WebCore/platform/graphics/GraphicsContext3DPrivate.cpp

index 049fdd2d12f1de25a12468299c9d924fee4a457f..956166dacbe316f1bb77ad838eebc72984753a15 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsContext3DPrivate.cpp
+++ b/Source/WebCore/platform/graphics/GraphicsContext3DPrivate.cpp
@@ -37,7 +37,7 @@
  #include "OpenGLShims.h"
  #endif
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER) && USE(TEXTURE_MAPPER_GL)
+#if USE(TEXTURE_MAPPER) && USE(TEXTURE_MAPPER_GL)
  #include <texmap/TextureMapperGL.h>
  #endif
  
@@ -68,7 +68,7 @@ GraphicsContext3DPrivate::GraphicsContext3DPrivate(GraphicsContext3D* context, G
  
  GraphicsContext3DPrivate::~GraphicsContext3DPrivate()
  {
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
      if (client())
          client()->platformLayerWillBeDestroyed();
  #endif
@@ -84,7 +84,7 @@ PlatformGraphicsContext3D GraphicsContext3DPrivate::platformContext()
      return m_glContext ? m_glContext->platformContext() : GLContext::getCurrent()->platformContext();
  }
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity)
  {
      if (!m_glContext)
@@ -150,9 +150,9 @@ void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper* textureMapper
      TextureMapperGL::Flags flags = TextureMapperGL::ShouldFlipTexture | (m_context->m_attrs.alpha ? TextureMapperGL::ShouldBlend : 0);
      IntSize textureSize(m_context->m_currentWidth, m_context->m_currentHeight);
      texmapGL->drawTexture(m_context->m_texture, flags, textureSize, targetRect, matrix, opacity);
-#endif // USE(ACCELERATED_COMPOSITING_GL)
+#endif // USE(TEXTURE_MAPPER_GL)
  }
-#endif // USE(ACCELERATED_COMPOSITING)
+#endif // USE(TEXTURE_MAPPER)
  
  } // namespace WebCore
  
diff --git a/Source/WebCore/platform/graphics/GraphicsContext3DPrivate.h b/Source/WebCore/platform/graphics/GraphicsContext3DPrivate.h

index 42eb6c2e7051c902750b2880dec4fa3743b210fd..b6fd44827642e1f92f9777f599dded6d43e8b2a8 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsContext3DPrivate.h
+++ b/Source/WebCore/platform/graphics/GraphicsContext3DPrivate.h
@@ -24,14 +24,14 @@
  #include "GraphicsContext3D.h"
  #include <wtf/PassOwnPtr.h>
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  #include "TextureMapperPlatformLayer.h"
  #endif
  
  namespace WebCore {
  
  class GraphicsContext3DPrivate
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
      : public TextureMapperPlatformLayer
  #endif
  {
@@ -43,7 +43,7 @@ public:
  
      GraphicsContext3D::RenderStyle renderStyle() { return m_renderStyle; }
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
      virtual void paintToTextureMapper(TextureMapper*, const FloatRect& target, const TransformationMatrix&, float opacity);
  #endif
  
diff --git a/Source/WebCore/platform/graphics/GraphicsLayer.cpp b/Source/WebCore/platform/graphics/GraphicsLayer.cpp

index 3d410b701ccf012b9693037f3222b5522174da2d..9344a3873e8e05811a423559ca8c134b7d13847f 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsLayer.cpp
+++ b/Source/WebCore/platform/graphics/GraphicsLayer.cpp
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "GraphicsLayer.h"
  
  #include "FloatPoint.h"
@@ -793,5 +791,3 @@ void showGraphicsLayerTree(const WebCore::GraphicsLayer* layer)
      fprintf(stderr, "%s\n", output.utf8().data());
  }
  #endif
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/GraphicsLayer.h b/Source/WebCore/platform/graphics/GraphicsLayer.h

index 3d57e804aeee1af6b967231c8a1dcb38314e992b..ff0c159d8be71ac3a4ada37a5dae1c4bf8875968 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsLayer.h
+++ b/Source/WebCore/platform/graphics/GraphicsLayer.h
@@ -26,8 +26,6 @@
  #ifndef GraphicsLayer_h
  #define GraphicsLayer_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "Animation.h"
  #include "Color.h"
  #include "FloatPoint.h"
@@ -625,6 +623,4 @@ protected:
  void showGraphicsLayerTree(const WebCore::GraphicsLayer* layer);
  #endif
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // GraphicsLayer_h
diff --git a/Source/WebCore/platform/graphics/GraphicsLayerAnimation.cpp b/Source/WebCore/platform/graphics/GraphicsLayerAnimation.cpp

index add686f66152ec15b4b3552bdb82ca52443f86c0..645066e9ebc7a752ee2bd1cb7e4501754ff01eb8 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsLayerAnimation.cpp
+++ b/Source/WebCore/platform/graphics/GraphicsLayerAnimation.cpp
@@ -19,7 +19,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
  #include "GraphicsLayerAnimation.h"
  
  #include "LayoutSize.h"
@@ -401,5 +400,3 @@ GraphicsLayerAnimations GraphicsLayerAnimations::getActiveAnimations() const
      return active;
  }
  }
-#endif
-
diff --git a/Source/WebCore/platform/graphics/GraphicsLayerAnimation.h b/Source/WebCore/platform/graphics/GraphicsLayerAnimation.h

index 2d2f6857354423ff81ef16149f166b83c1561364..8f37fe4137e28d61f8e3879b67cc4dadf532e8c2 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsLayerAnimation.h
+++ b/Source/WebCore/platform/graphics/GraphicsLayerAnimation.h
@@ -20,8 +20,6 @@
  #ifndef GraphicsLayerAnimation_h
  #define GraphicsLayerAnimation_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "GraphicsLayer.h"
  #include "TransformationMatrix.h"
  #include <wtf/HashMap.h>
@@ -105,6 +103,5 @@ private:
  };
  
  }
-#endif
  
  #endif // GraphicsLayerAnimation_h
diff --git a/Source/WebCore/platform/graphics/GraphicsLayerClient.h b/Source/WebCore/platform/graphics/GraphicsLayerClient.h

index 90f9e823b4a97ed7d90406e5fdeff4f013c0399c..3d513cd1e23848d6a24c8ef44cb5dacf3fda86c7 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsLayerClient.h
+++ b/Source/WebCore/platform/graphics/GraphicsLayerClient.h
@@ -26,8 +26,6 @@
  #ifndef GraphicsLayerClient_h
  #define GraphicsLayerClient_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  namespace WebCore {
  
  class FloatPoint;
@@ -107,6 +105,4 @@ public:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // GraphicsLayerClient_h
diff --git a/Source/WebCore/platform/graphics/GraphicsLayerFactory.h b/Source/WebCore/platform/graphics/GraphicsLayerFactory.h

index 6413e93cb42a1f1aec52f5fa9025950f998f9836..708c8c699a91e56efbc18b7e1bb5a5122f629e1a 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsLayerFactory.h
+++ b/Source/WebCore/platform/graphics/GraphicsLayerFactory.h
@@ -26,8 +26,6 @@
  #ifndef GraphicsLayerFactory_h
  #define GraphicsLayerFactory_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include <wtf/Forward.h>
  
  namespace WebCore {
@@ -44,6 +42,4 @@ public:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // GraphicsLayerFactory_h
diff --git a/Source/WebCore/platform/graphics/GraphicsLayerUpdater.cpp b/Source/WebCore/platform/graphics/GraphicsLayerUpdater.cpp

index b3c943644615215aaaeabc72b0b36d37d28a3427..056992d1e6f8e2ae46f200d99b537e23cab9a820 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsLayerUpdater.cpp
+++ b/Source/WebCore/platform/graphics/GraphicsLayerUpdater.cpp
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "GraphicsLayerUpdater.h"
  
  #include "GraphicsLayer.h"
@@ -81,5 +79,3 @@ void GraphicsLayerUpdater::displayRefreshFired(double timestamp)
  }
  
  } // namespace WebCore
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/GraphicsLayerUpdater.h b/Source/WebCore/platform/graphics/GraphicsLayerUpdater.h

index 108099ae6a95ea23434e34bf484066f5e29b31f5..f4246df597ab6dc1ac16e2931a9f02e4fbea80ac 100644 (file)
--- a/Source/WebCore/platform/graphics/GraphicsLayerUpdater.h
+++ b/Source/WebCore/platform/graphics/GraphicsLayerUpdater.h
@@ -26,8 +26,6 @@
  #ifndef GraphicsLayerUpdater_h
  #define GraphicsLayerUpdater_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "DisplayRefreshMonitor.h"
  #include "PlatformScreen.h"
  
@@ -62,6 +60,4 @@ private:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // GraphicsLayerUpdater_h
diff --git a/Source/WebCore/platform/graphics/ImageBuffer.cpp b/Source/WebCore/platform/graphics/ImageBuffer.cpp

index 833534c6c6b8d9ca5232be6b7acae23bfef5b9a4..e6facda80dc305bf8bcf3625f3bbba8375b9eeef 100644 (file)
--- a/Source/WebCore/platform/graphics/ImageBuffer.cpp
+++ b/Source/WebCore/platform/graphics/ImageBuffer.cpp
@@ -98,7 +98,7 @@ void ImageBuffer::convertToLuminanceMask()
      genericConvertToLuminanceMask();
  }
  
-#if USE(ACCELERATED_COMPOSITING) && !USE(CAIRO)
+#if !USE(CAIRO)
  PlatformLayer* ImageBuffer::platformLayer() const
  {
      return 0;
diff --git a/Source/WebCore/platform/graphics/ImageBuffer.h b/Source/WebCore/platform/graphics/ImageBuffer.h

index b62e5069f469c3f58e66c275eb17691b1272cd41..5a4df216979e8a8537184945217c7a673de97165 100644 (file)
--- a/Source/WebCore/platform/graphics/ImageBuffer.h
+++ b/Source/WebCore/platform/graphics/ImageBuffer.h
@@ -32,13 +32,11 @@
  #include "ColorSpace.h"
  #include "FloatRect.h"
  #include "GraphicsContext.h"
-#if USE(ACCELERATED_COMPOSITING)
-#include "PlatformLayer.h"
-#endif
  #include "GraphicsTypes.h"
  #include "GraphicsTypes3D.h"
  #include "IntSize.h"
  #include "ImageBufferData.h"
+#include "PlatformLayer.h"
  #include <runtime/Uint8ClampedArray.h>
  #include <wtf/Forward.h>
  #include <wtf/OwnPtr.h>
@@ -119,9 +117,7 @@ namespace WebCore {
  #else
          AffineTransform baseTransform() const { return AffineTransform(1, 0, 0, -1, 0, m_data.m_backingStoreSize.height()); }
  #endif
-#if USE(ACCELERATED_COMPOSITING)
          PlatformLayer* platformLayer() const;
-#endif
  
          // FIXME: current implementations of this method have the restriction that they only work
          // with textures that are RGB or RGBA format, and UNSIGNED_BYTE type.
diff --git a/Source/WebCore/platform/graphics/MediaPlayer.cpp b/Source/WebCore/platform/graphics/MediaPlayer.cpp

index eac25540b3dacb2921d0c7ad8e08411484459735..e3f77247e4bce2d8441457193252e5876034ffb0 100644 (file)
--- a/Source/WebCore/platform/graphics/MediaPlayer.cpp
+++ b/Source/WebCore/platform/graphics/MediaPlayer.cpp
@@ -95,9 +95,7 @@ public:
      virtual void pause() { }    
  
      virtual PlatformMedia platformMedia() const { return NoPlatformMedia; }
-#if USE(ACCELERATED_COMPOSITING)
      virtual PlatformLayer* platformLayer() const { return 0; }
-#endif
  
      virtual IntSize naturalSize() const { return IntSize(0, 0); }
  
@@ -612,12 +610,10 @@ PlatformMedia MediaPlayer::platformMedia() const
      return m_private->platformMedia();
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  PlatformLayer* MediaPlayer::platformLayer() const
  {
      return m_private->platformLayer();
  }
-#endif
  
  MediaPlayer::NetworkState MediaPlayer::networkState()
  {
@@ -890,7 +886,6 @@ bool MediaPlayer::canEnterFullscreen() const
  }
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
  void MediaPlayer::acceleratedRenderingStateChanged()
  {
      m_private->acceleratedRenderingStateChanged();
@@ -900,7 +895,6 @@ bool MediaPlayer::supportsAcceleratedRendering() const
  {
      return m_private->supportsAcceleratedRendering();
  }
-#endif // USE(ACCELERATED_COMPOSITING)
  
  bool MediaPlayer::shouldMaintainAspectRatio() const
  {
diff --git a/Source/WebCore/platform/graphics/MediaPlayer.h b/Source/WebCore/platform/graphics/MediaPlayer.h

index c6480e4b0fd088250f56fdbb5847e7638e550624..471891cdf7af6b28c2bfbbfefee497a68f9d8179 100644 (file)
--- a/Source/WebCore/platform/graphics/MediaPlayer.h
+++ b/Source/WebCore/platform/graphics/MediaPlayer.h
@@ -38,6 +38,7 @@
  #include "URL.h"
  #include "LayoutRect.h"
  #include "NativeImagePtr.h"
+#include "PlatformLayer.h"
  #include "Timer.h"
  #include "VideoTrackPrivate.h"
  #include <runtime/Uint8Array.h>
@@ -49,10 +50,6 @@
  #include <wtf/PassOwnPtr.h>
  #include <wtf/text/StringHash.h>
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "PlatformLayer.h"
-#endif
-
  #if USE(PLATFORM_TEXT_TRACK_MENU)
  #include "PlatformTextTrackMenu.h"
  #endif
@@ -199,14 +196,12 @@ public:
      // A characteristic of the media file, eg. video, audio, closed captions, etc, has changed.
      virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) { }
      
-#if USE(ACCELERATED_COMPOSITING)
      // whether the rendering system can accelerate the display of this MediaPlayer.
      virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) { return false; }
  
      // called when the media player's rendering mode changed, which indicates a change in the
      // availability of the platformLayer().
      virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) { }
-#endif
  
  #if PLATFORM(WIN) && USE(AVFOUNDATION)
      virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const { return 0; }
@@ -294,9 +289,7 @@ public:
      bool supportsScanning() const;
      bool requiresImmediateCompositing() const;
      PlatformMedia platformMedia() const;
-#if USE(ACCELERATED_COMPOSITING)
      PlatformLayer* platformLayer() const;
-#endif
  
      IntSize naturalSize();
      bool hasVideo() const;
@@ -457,12 +450,10 @@ public:
      bool canEnterFullscreen() const;
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
      // whether accelerated rendering is supported by the media engine for the current media.
      bool supportsAcceleratedRendering() const;
      // called when the rendering system flips the into or out of accelerated rendering mode.
      void acceleratedRenderingStateChanged();
-#endif
  
      bool shouldMaintainAspectRatio() const;
      void setShouldMaintainAspectRatio(bool);
diff --git a/Source/WebCore/platform/graphics/MediaPlayerPrivate.h b/Source/WebCore/platform/graphics/MediaPlayerPrivate.h

index fbafd70cd9ef34a07804a25a79293b878239b350..553788c385251a5ba2872019996a16a08f651645 100644 (file)
--- a/Source/WebCore/platform/graphics/MediaPlayerPrivate.h
+++ b/Source/WebCore/platform/graphics/MediaPlayerPrivate.h
@@ -52,9 +52,7 @@ public:
      
      virtual void prepareToPlay() { }
      virtual PlatformMedia platformMedia() const { return NoPlatformMedia; }
-#if USE(ACCELERATED_COMPOSITING)
      virtual PlatformLayer* platformLayer() const { return 0; }
-#endif
  
      virtual void play() = 0;
      virtual void pause() = 0;    
@@ -160,12 +158,10 @@ public:
      virtual bool canEnterFullscreen() const { return false; }
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
      // whether accelerated rendering is supported by the media engine for the current media.
      virtual bool supportsAcceleratedRendering() const { return false; }
      // called when the rendering system flips the into or out of accelerated rendering mode.
      virtual void acceleratedRenderingStateChanged() { }
-#endif
  
      virtual bool shouldMaintainAspectRatio() const { return true; }
      virtual void setShouldMaintainAspectRatio(bool) { }
diff --git a/Source/WebCore/platform/graphics/PlatformLayer.h b/Source/WebCore/platform/graphics/PlatformLayer.h

index a18f9b9c3f49747f1dd7e2c6a968a5567882a4ea..2c7d26b2b407ba5790d34f399d22d17be2661707 100644 (file)
--- a/Source/WebCore/platform/graphics/PlatformLayer.h
+++ b/Source/WebCore/platform/graphics/PlatformLayer.h
@@ -26,8 +26,6 @@
  #ifndef PlatformLayer_h
  #define PlatformLayer_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #if PLATFORM(MAC)
  OBJC_CLASS CALayer;
  typedef CALayer PlatformLayer;
@@ -56,6 +54,4 @@ typedef TextureMapperPlatformLayer PlatformLayer;
  typedef void* PlatformLayer;
  #endif
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // PlatformLayer_h
diff --git a/Source/WebCore/platform/graphics/TextTrackRepresentation.cpp b/Source/WebCore/platform/graphics/TextTrackRepresentation.cpp

index d178e586f78f201690eec33f22a263493ba1ade9..fcf58b8c296cab49a2dd879b446500f357447ca4 100644 (file)
--- a/Source/WebCore/platform/graphics/TextTrackRepresentation.cpp
+++ b/Source/WebCore/platform/graphics/TextTrackRepresentation.cpp
@@ -35,9 +35,7 @@ class NullTextTrackRepresentation : public TextTrackRepresentation {
  public:
      virtual ~NullTextTrackRepresentation() { }
      virtual void update() { }
-#if USE(ACCELERATED_COMPOSITING)
      virtual PlatformLayer* platformLayer() { return 0; }
-#endif
      virtual void setContentScale(float) { }
      virtual IntRect bounds() const { return IntRect(); }
  };
diff --git a/Source/WebCore/platform/graphics/TextTrackRepresentation.h b/Source/WebCore/platform/graphics/TextTrackRepresentation.h

index 5f844483da6bd20d9e75b48f2533407694c22882..9e1c83bd8a9867fba99d855cc20fb09d28441629 100644 (file)
--- a/Source/WebCore/platform/graphics/TextTrackRepresentation.h
+++ b/Source/WebCore/platform/graphics/TextTrackRepresentation.h
@@ -53,9 +53,7 @@ public:
      virtual ~TextTrackRepresentation() { }
  
      virtual void update() = 0;
-#if USE(ACCELERATED_COMPOSITING)
      virtual PlatformLayer* platformLayer() = 0;
-#endif
      virtual void setContentScale(float) = 0;
      virtual IntRect bounds() const = 0;
  };
diff --git a/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp b/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp

index d0720c5d1d4bd60fcf90140c2ebccc63c15d093f..58a24681ae22570c49a86f50d01d28f6ece9f21c 100644 (file)
--- a/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp
+++ b/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp
@@ -91,10 +91,8 @@ MediaPlayerPrivateAVFoundation::~MediaPlayerPrivateAVFoundation()
  
  MediaPlayerPrivateAVFoundation::MediaRenderingMode MediaPlayerPrivateAVFoundation::currentRenderingMode() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (platformLayer())
          return MediaRenderingToLayer;
-#endif
  
      if (hasContextRenderer())
          return MediaRenderingToContext;
@@ -107,10 +105,8 @@ MediaPlayerPrivateAVFoundation::MediaRenderingMode MediaPlayerPrivateAVFoundatio
      if (!m_player->visible() || !m_player->frameView() || assetStatus() == MediaPlayerAVAssetStatusUnknown)
          return MediaRenderingNone;
  
-#if USE(ACCELERATED_COMPOSITING)
      if (supportsAcceleratedRendering() && m_player->mediaPlayerClient()->mediaPlayerRenderingCanBeAccelerated(m_player))
          return MediaRenderingToLayer;
-#endif
  
      return MediaRenderingToContext;
  }
@@ -140,21 +136,17 @@ void MediaPlayerPrivateAVFoundation::setUpVideoRendering()
      case MediaRenderingToContext:
          createContextVideoRenderer();
          break;
-        
-#if USE(ACCELERATED_COMPOSITING)
+
      case MediaRenderingToLayer:
          createVideoLayer();
          break;
-#endif
      }
  
-#if USE(ACCELERATED_COMPOSITING)
      // If using a movie layer, inform the client so the compositing tree is updated.
      if (currentMode == MediaRenderingToLayer || preferredMode == MediaRenderingToLayer) {
          LOG(Media, "MediaPlayerPrivateAVFoundation::setUpVideoRendering(%p) - calling mediaPlayerRenderingModeChanged()", this);
          m_player->mediaPlayerClient()->mediaPlayerRenderingModeChanged(m_player);
      }
-#endif
  }
  
  void MediaPlayerPrivateAVFoundation::tearDownVideoRendering()
@@ -163,10 +155,8 @@ void MediaPlayerPrivateAVFoundation::tearDownVideoRendering()
  
      destroyContextVideoRenderer();
  
-#if USE(ACCELERATED_COMPOSITING)
      if (platformLayer())
          destroyVideoLayer();
-#endif
  }
  
  bool MediaPlayerPrivateAVFoundation::hasSetUpVideoRendering() const
diff --git a/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h b/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h

index 192ec39fb26eb0f9ea62d356cb54609f26a6e791..0cfa51f70392e66ba3d31dae4c873f6c2288b1ed 100644 (file)
--- a/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h
+++ b/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h
@@ -180,11 +180,9 @@ protected:
      virtual void paint(GraphicsContext*, const IntRect&) = 0;
      virtual void paintCurrentFrameInContext(GraphicsContext*, const IntRect&) = 0;
      virtual void setPreload(MediaPlayer::Preload) override;
-#if USE(ACCELERATED_COMPOSITING)
      virtual PlatformLayer* platformLayer() const { return 0; }
      virtual bool supportsAcceleratedRendering() const = 0;
      virtual void acceleratedRenderingStateChanged() override;
-#endif
      virtual bool shouldMaintainAspectRatio() const override { return m_shouldMaintainAspectRatio; }
      virtual void setShouldMaintainAspectRatio(bool) override;
  
diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h

index 1f20621532f99cad677824a0b4f7717c7d0557dc..f5a8b1131401666277a74048b1a89731dce7b353 100644 (file)
--- a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h
+++ b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h
@@ -80,9 +80,7 @@ private:
  
      virtual void prepareToPlay() override;
      virtual PlatformMedia platformMedia() const override;
-#if USE(ACCELERATED_COMPOSITING)
      virtual PlatformLayer* platformLayer() const override;
-#endif
  
      virtual void play() override;
      void playInternal();
@@ -128,11 +126,9 @@ private:
  
      virtual bool hasAvailableVideoFrame() const override;
  
-#if USE(ACCELERATED_COMPOSITING)
      virtual bool supportsAcceleratedRendering() const override;
      // called when the rendering system flips the into or out of accelerated rendering mode.
      virtual void acceleratedRenderingStateChanged() override;
-#endif
  
      virtual MediaPlayer::MovieLoadType movieLoadType() const override;
  
diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm

index 520879920b259370ad248aff0eaa0df4c8fb272a..6c465687f69e72043003b503684bd8b9adacc915 100644 (file)
--- a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm
+++ b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm
@@ -258,12 +258,10 @@ PlatformMedia MediaPlayerPrivateMediaSourceAVFObjC::platformMedia() const
      return pm;
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  PlatformLayer* MediaPlayerPrivateMediaSourceAVFObjC::platformLayer() const
  {
      return m_sampleBufferDisplayLayer.get();
  }
-#endif
  
  void MediaPlayerPrivateMediaSourceAVFObjC::play()
  {
@@ -437,7 +435,6 @@ bool MediaPlayerPrivateMediaSourceAVFObjC::hasAvailableVideoFrame() const
      return m_hasAvailableVideoFrame;
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  bool MediaPlayerPrivateMediaSourceAVFObjC::supportsAcceleratedRendering() const
  {
      return true;
@@ -450,7 +447,6 @@ void MediaPlayerPrivateMediaSourceAVFObjC::acceleratedRenderingStateChanged()
      else
          destroyLayer();
  }
-#endif
  
  MediaPlayer::MovieLoadType MediaPlayerPrivateMediaSourceAVFObjC::movieLoadType() const
  {
diff --git a/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp b/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

index ab44c7c653cbc0c4982b9cfeacd7240214aca1f8..082d9ec28c1bef23f8bf1e2646a3312f9c8afcb3 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp
+++ b/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "GraphicsLayerCA.h"
  
  #include "Animation.h"
@@ -3508,5 +3506,3 @@ double GraphicsLayerCA::backingStoreMemoryEstimate() const
  }
  
  } // namespace WebCore
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h b/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

index e3e7928774e5afc5b109887a44b03f9009e2aa28..0ef5d9912544cb60c6b0cd26a9b7f79954941c3f 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h
+++ b/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h
@@ -26,8 +26,6 @@
  #ifndef GraphicsLayerCA_h
  #define GraphicsLayerCA_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "GraphicsLayer.h"
  #include "Image.h"
  #include "PlatformCAAnimation.h"
@@ -551,7 +549,4 @@ GRAPHICSLAYER_TYPE_CASTS(GraphicsLayerCA, isGraphicsLayerCA());
  
  } // namespace WebCore
  
-
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // GraphicsLayerCA_h
diff --git a/Source/WebCore/platform/graphics/ca/LayerFlushScheduler.cpp b/Source/WebCore/platform/graphics/ca/LayerFlushScheduler.cpp

index fc8de7384e583b4a9b315d8081f567e39bc369e3..99ce6938b3e4a6dd7c8818c4b9a56d3eec107ad6 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/LayerFlushScheduler.cpp
+++ b/Source/WebCore/platform/graphics/ca/LayerFlushScheduler.cpp
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "LayerFlushScheduler.h"
  
  namespace WebCore {
@@ -50,5 +48,3 @@ void LayerFlushScheduler::resume()
  }
  
  } // namespace WebCore
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/LayerFlushScheduler.h b/Source/WebCore/platform/graphics/ca/LayerFlushScheduler.h

index fe0b52d88c1e0636c0b5919a77ec6460f473245f..60188f3670450a7cdd045a5ac22f15ce39fbd395 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/LayerFlushScheduler.h
+++ b/Source/WebCore/platform/graphics/ca/LayerFlushScheduler.h
@@ -26,8 +26,6 @@
  #ifndef LayerFlushScheduler_h
  #define LayerFlushScheduler_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "LayerFlushSchedulerClient.h"
  #include <wtf/Noncopyable.h>
  #include <wtf/RetainPtr.h>
@@ -63,6 +61,4 @@ protected:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // LayerFlushScheduler_h
diff --git a/Source/WebCore/platform/graphics/ca/LayerFlushSchedulerClient.h b/Source/WebCore/platform/graphics/ca/LayerFlushSchedulerClient.h

index f79cb3827a775ebd3fdd8ad3211395b2b15fd689..eb0b96c1ba28a982e9e8e68cc58e810e8e1613ea 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/LayerFlushSchedulerClient.h
+++ b/Source/WebCore/platform/graphics/ca/LayerFlushSchedulerClient.h
@@ -26,8 +26,6 @@
  #ifndef LayerFlushSchedulerClient_h
  #define LayerFlushSchedulerClient_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  namespace WebCore {
  
  class LayerFlushSchedulerClient {
@@ -41,6 +39,4 @@ public:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // LayerFlushSchedulerClient_h
diff --git a/Source/WebCore/platform/graphics/ca/PlatformCAAnimation.h b/Source/WebCore/platform/graphics/ca/PlatformCAAnimation.h

index ce3236f48f5427b5efab4c22a7f45e693bfb0df6..acbaea20170f693c83d8764064fcda4080d7fde2 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/PlatformCAAnimation.h
+++ b/Source/WebCore/platform/graphics/ca/PlatformCAAnimation.h
@@ -26,8 +26,6 @@
  #ifndef PlatformCAAnimation_h
  #define PlatformCAAnimation_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "Color.h"
  #include "FilterOperation.h"
  #include "FloatPoint3D.h"
@@ -165,6 +163,4 @@ private:
  
  }
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // PlatformCAAnimation_h
diff --git a/Source/WebCore/platform/graphics/ca/PlatformCAFilters.h b/Source/WebCore/platform/graphics/ca/PlatformCAFilters.h

index 9c3507b23944951555762939cdb1b2ff40a74627..797d3b6027af8693d178e1b8f101c0a06a759783 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/PlatformCAFilters.h
+++ b/Source/WebCore/platform/graphics/ca/PlatformCAFilters.h
@@ -26,7 +26,6 @@
  #ifndef PlatformCAFilters_h
  #define PlatformCAFilters_h
  
-#if USE(ACCELERATED_COMPOSITING)
  #if ENABLE(CSS_FILTERS)
  
  #include "FilterOperations.h"
@@ -65,6 +64,5 @@ public:
  }
  
  #endif // ENABLE(CSS_FILTERS)
-#endif // USE(ACCELERATED_COMPOSITING)
  
  #endif // PlatformCAFilters_h
diff --git a/Source/WebCore/platform/graphics/ca/PlatformCALayer.h b/Source/WebCore/platform/graphics/ca/PlatformCALayer.h

index 37a495f08cde8bad28f4477a9a6c19ede2a13d58..e4744b084d0ba08630d83771af74bdf0747799bf 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/PlatformCALayer.h
+++ b/Source/WebCore/platform/graphics/ca/PlatformCALayer.h
@@ -26,8 +26,6 @@
  #ifndef PlatformCALayer_h
  #define PlatformCALayer_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "GraphicsContext.h"
  #include "GraphicsLayer.h"
  #include "PlatformCAAnimation.h"
@@ -238,6 +236,4 @@ protected:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // PlatformCALayer_h
diff --git a/Source/WebCore/platform/graphics/ca/PlatformCALayerClient.h b/Source/WebCore/platform/graphics/ca/PlatformCALayerClient.h

index a223f16dc88c236f34c9a5a70837d80a536a68d2..36b8b0f64c3542099486fafc6ca5ec6f1dba4fcf 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/PlatformCALayerClient.h
+++ b/Source/WebCore/platform/graphics/ca/PlatformCALayerClient.h
@@ -26,8 +26,6 @@
  #ifndef PlatformCALayerClient_h
  #define PlatformCALayerClient_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "GraphicsContext.h"
  #include "GraphicsLayer.h"
  #include "PlatformCAAnimation.h"
@@ -71,6 +69,4 @@ protected:
  
  }
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // PlatformCALayerClient_h
diff --git a/Source/WebCore/platform/graphics/ca/mac/LayerFlushSchedulerMac.cpp b/Source/WebCore/platform/graphics/ca/mac/LayerFlushSchedulerMac.cpp

index bfc3e5af6c306fbd5eca6810c3b0471198eac707..ade9e8ce5f88fa6103b90dea1f0cc932a438ce6e 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/mac/LayerFlushSchedulerMac.cpp
+++ b/Source/WebCore/platform/graphics/ca/mac/LayerFlushSchedulerMac.cpp
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "LayerFlushScheduler.h"
  
  #include <wtf/AutodrainedPool.h>
@@ -111,5 +109,3 @@ void LayerFlushScheduler::invalidate()
  }
      
  } // namespace WebCore
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/mac/PlatformCAAnimationMac.mm b/Source/WebCore/platform/graphics/ca/mac/PlatformCAAnimationMac.mm

index e6e59f3abdf8a95f9c17385a8c6254da7ae8caf5..d1f8be56e2a2d07fec3637be7755798ef902c3a8 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/mac/PlatformCAAnimationMac.mm
+++ b/Source/WebCore/platform/graphics/ca/mac/PlatformCAAnimationMac.mm
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #import "PlatformCAAnimation.h"
  
  #import "FloatConversion.h"
@@ -583,5 +581,3 @@ void PlatformCAAnimation::copyTimingFunctionsFrom(const PlatformCAAnimation* val
      CAKeyframeAnimation* other = static_cast<CAKeyframeAnimation*>(value->m_animation.get());
      [static_cast<CAKeyframeAnimation*>(m_animation.get()) setTimingFunctions:[other timingFunctions]];
  }
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/mac/PlatformCAFiltersMac.mm b/Source/WebCore/platform/graphics/ca/mac/PlatformCAFiltersMac.mm

index 6ff64856bca7e649cfcfbc784f0863fe17e2dffa..96edac1d0979b2bcf3f89579192cd7a06102c14a 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/mac/PlatformCAFiltersMac.mm
+++ b/Source/WebCore/platform/graphics/ca/mac/PlatformCAFiltersMac.mm
@@ -25,7 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
  #if ENABLE(CSS_FILTERS)
  
  #import "PlatformCAFilters.h"
@@ -711,4 +710,3 @@ const char* PlatformCAFilters::animatedFilterPropertyName(FilterOperation::Opera
  }
  
  #endif // ENABLE(CSS_FILTERS)
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.h b/Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.h

index 6fc4d38f5ad97e88e623e224b2879dadb3abea28..b99dceee323944bbdfd8a204ace9386253228582 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.h
+++ b/Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.h
@@ -26,8 +26,6 @@
  #ifndef PlatformCALayerMac_h
  #define PlatformCALayerMac_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "PlatformCALayer.h"
  
  OBJC_CLASS NSObject;
@@ -165,6 +163,4 @@ PLATFORM_CALAYER_TYPE_CASTS(PlatformCALayerMac, isPlatformCALayerMac())
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // PlatformCALayerMac_h
diff --git a/Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.mm b/Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.mm

index 567dc2a378fd452c42cffdf731b6a982899fafb5..9addd726635feee6a026ecee6da5701768948673 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.mm
+++ b/Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.mm
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #import "PlatformCALayerMac.h"
  
  #import "AnimationUtilities.h"
@@ -831,5 +829,3 @@ void PlatformCALayerMac::enumerateRectsBeingDrawn(CGContextRef context, void (^b
  {
      wkCALayerEnumerateRectsBeingDrawnWithBlock(m_layer.get(), context, block);
  }
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/win/AbstractCACFLayerTreeHost.h b/Source/WebCore/platform/graphics/ca/win/AbstractCACFLayerTreeHost.h

index 13c674640dbf7026953aa1a01c1fa228434fb663..01f23c3e9c361d7af313e9f95c8304e04c03d57e 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/AbstractCACFLayerTreeHost.h
+++ b/Source/WebCore/platform/graphics/ca/win/AbstractCACFLayerTreeHost.h
@@ -26,8 +26,6 @@
  #ifndef AbstractCACFLayerTreeHost_h
  #define AbstractCACFLayerTreeHost_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include <wtf/Forward.h>
  
  namespace WebCore {
@@ -47,6 +45,4 @@ protected:
  
  }
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // AbstractCACFLayerTreeHost_h
diff --git a/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHost.cpp b/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHost.cpp

index 5d0c34686cded982c95c837d29cd0d60f58f751c..5e5411a49d6620f22bfb1f32486953b769aa88c9 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHost.cpp
+++ b/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHost.cpp
@@ -26,8 +26,6 @@
  #include "config.h"
  #include "CACFLayerTreeHost.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "CACFLayerTreeHostClient.h"
  #include "DefWndProcWindowClass.h"
  #include "LayerChangesFlusher.h"
@@ -328,5 +326,3 @@ CGRect CACFLayerTreeHost::bounds() const
  }
  
  }
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHost.h b/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHost.h

index 9cea1c01de67bdd404aa5ba5aed8542d4bbfda19..24f320879843257cabde8492e1f3a2496e059fae 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHost.h
+++ b/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHost.h
@@ -26,8 +26,6 @@
  #ifndef CACFLayerTreeHost_h
  #define CACFLayerTreeHost_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "AbstractCACFLayerTreeHost.h"
  #include "COMPtr.h"
  #include "Timer.h"
@@ -120,6 +118,4 @@ private:
  
  }
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // CACFLayerTreeHost_h
diff --git a/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHostClient.h b/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHostClient.h

index 845f934dc070e8a24f1c0b69dc271688975b2a4b..f9eec0da98a4a535688aac639d39888a6a88d1b2 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHostClient.h
+++ b/Source/WebCore/platform/graphics/ca/win/CACFLayerTreeHostClient.h
@@ -26,8 +26,6 @@
  #ifndef CACFLayerTreeHostClient_h
  #define CACFLayerTreeHostClient_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  namespace WebCore {
  
  class CACFLayerTreeHostClient {
@@ -38,6 +36,4 @@ public:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // CACFLayerTreeHostClient_h
diff --git a/Source/WebCore/platform/graphics/ca/win/LayerChangesFlusher.cpp b/Source/WebCore/platform/graphics/ca/win/LayerChangesFlusher.cpp

index 1b19ea4b7c79f145eef4f8486326215ac5342152..fd44aa063a29c040fa9c00952f19d8ab51adb5e7 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/LayerChangesFlusher.cpp
+++ b/Source/WebCore/platform/graphics/ca/win/LayerChangesFlusher.cpp
@@ -26,8 +26,6 @@
  #include "config.h"
  #include "LayerChangesFlusher.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "AbstractCACFLayerTreeHost.h"
  #include "StructuredExceptionHandlerSuppressor.h"
  #include <wtf/StdLibExtras.h>
@@ -131,5 +129,3 @@ void LayerChangesFlusher::removeHook()
  }
  
  } // namespace WebCore
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/win/LayerChangesFlusher.h b/Source/WebCore/platform/graphics/ca/win/LayerChangesFlusher.h

index 1e7ab314719af6a21d074bde2bb59569dac2e928..37c314020cc786c7bfc0e990c59dced51f6da935 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/LayerChangesFlusher.h
+++ b/Source/WebCore/platform/graphics/ca/win/LayerChangesFlusher.h
@@ -26,8 +26,6 @@
  #ifndef LayerChangesFlusher_h
  #define LayerChangesFlusher_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include <windows.h>
  #include <wtf/HashSet.h>
  #include <wtf/Noncopyable.h>
@@ -60,6 +58,4 @@ private:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // LayerChangesFlusher_h
diff --git a/Source/WebCore/platform/graphics/ca/win/LegacyCACFLayerTreeHost.cpp b/Source/WebCore/platform/graphics/ca/win/LegacyCACFLayerTreeHost.cpp

index 228e16e577f19fb8247886d081b14655d549116d..8f345bd31fcdad6f363cfe61d69f15f759476e6b 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/LegacyCACFLayerTreeHost.cpp
+++ b/Source/WebCore/platform/graphics/ca/win/LegacyCACFLayerTreeHost.cpp
@@ -26,8 +26,6 @@
  #include "config.h"
  #include "LegacyCACFLayerTreeHost.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "PlatformCALayer.h"
  #include <QuartzCore/CABase.h>
  #include <WebKitSystemInterface/WebKitSystemInterface.h>
@@ -398,5 +396,3 @@ bool LegacyCACFLayerTreeHost::resetDevice(ResetReason reason)
  }
  
  } // namespace WebCore
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/win/LegacyCACFLayerTreeHost.h b/Source/WebCore/platform/graphics/ca/win/LegacyCACFLayerTreeHost.h

index 5a678c68f17e16c68cff9d3ce5637a491a833f59..331da78388d7babd06b35e6258665777dcc2560e 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/LegacyCACFLayerTreeHost.h
+++ b/Source/WebCore/platform/graphics/ca/win/LegacyCACFLayerTreeHost.h
@@ -26,8 +26,6 @@
  #ifndef LegacyCACFLayerTreeHost_h
  #define LegacyCACFLayerTreeHost_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "CACFLayerTreeHost.h"
  
  namespace WebCore {
@@ -81,6 +79,4 @@ private:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // LegacyCACFLayerTreeHost_h
diff --git a/Source/WebCore/platform/graphics/ca/win/PlatformCAAnimationWin.cpp b/Source/WebCore/platform/graphics/ca/win/PlatformCAAnimationWin.cpp

index c584b96f7693df79d320a151cd68391764c07278..d2454014d79f574fb553acea78d73c67e33cc87c 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/PlatformCAAnimationWin.cpp
+++ b/Source/WebCore/platform/graphics/ca/win/PlatformCAAnimationWin.cpp
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "PlatformCAAnimation.h"
  
  #include "FloatConversion.h"
@@ -559,5 +557,3 @@ void PlatformCAAnimation::copyTimingFunctionsFrom(const PlatformCAAnimation* val
  {
      CACFAnimationSetTimingFunctions(m_animation.get(), CACFAnimationGetTimingFunctions(value->platformAnimation()));
  }
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/win/PlatformCAFiltersWin.cpp b/Source/WebCore/platform/graphics/ca/win/PlatformCAFiltersWin.cpp

index 30c40a7e39b406763535f6068f0a49ce11796f28..3a0d05cfa5643f4c5d30ea0dbfd52015b9b24b4a 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/PlatformCAFiltersWin.cpp
+++ b/Source/WebCore/platform/graphics/ca/win/PlatformCAFiltersWin.cpp
@@ -25,7 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
  #if ENABLE(CSS_FILTERS)
  
  #include "PlatformCAFilters.h"
@@ -50,4 +49,3 @@ const char* PlatformCAFilters::animatedFilterPropertyName(FilterOperation::Opera
  }
  
  #endif // ENABLE(CSS_FILTERS)
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.cpp b/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.cpp

index 18be867c357a38442d7bb8dd57d3e5e7cfe607f3..e80c2443124c20b6c54a3ea04e7ca7e0479bcd30 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.cpp
+++ b/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.cpp
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "PlatformCALayerWin.h"
  
  #include "AbstractCACFLayerTreeHost.h"
@@ -675,5 +673,3 @@ PassRefPtr<PlatformCALayer> PlatformCALayerWin::createCompatibleLayer(PlatformCA
  {
      return PlatformCALayerWin::create(layerType, client);
  }
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.h b/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.h

index 262aa2cd96f135634cf1d8926c1223c42e1e6b77..01b056e27e6bd6a0d35c482980dcbd04b9e9db48 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.h
+++ b/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.h
@@ -26,8 +26,6 @@
  #ifndef PlatformCALayerWin_h
  #define PlatformCALayerWin_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "PlatformCALayer.h"
  
  namespace WebCore {
@@ -154,6 +152,4 @@ private:
  
  }
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // PlatformCALayerWin_h
diff --git a/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWinInternal.cpp b/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWinInternal.cpp

index f0121aa9b113a30383b784b9470df52666c872b3..f6835d698832ba02ed7f1bb749b2b22b4f905c12 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWinInternal.cpp
+++ b/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWinInternal.cpp
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "PlatformCALayerWinInternal.h"
  
  #include "Font.h"
@@ -488,5 +486,3 @@ void PlatformCALayerWinInternal::drawTile(CACFLayerRef tile, CGContextRef contex
  
      CGContextRestoreGState(context);
  }
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWinInternal.h b/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWinInternal.h

index 39ef3b3576f2fcfa06e7f937b35270432ac8d686..9edbba46b764c4fe8812f728615f5c030c0b722f 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWinInternal.h
+++ b/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWinInternal.h
@@ -26,8 +26,6 @@
  #ifndef PlatformCALayerWinInternal_h
  #define PlatformCALayerWinInternal_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include <CoreGraphics/CGGeometry.h>
  #include <wtf/RetainPtr.h>
  #include <wtf/Vector.h>
@@ -84,6 +82,4 @@ private:
  
  }
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // PlatformCALayerWinInternal_h
diff --git a/Source/WebCore/platform/graphics/ca/win/WKCACFViewLayerTreeHost.cpp b/Source/WebCore/platform/graphics/ca/win/WKCACFViewLayerTreeHost.cpp

index 2f64ab160cf88c0f0f436bd6de24e5516430d1fb..4a25c6dd7d35f4932222c07fea98f505931eab4f 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/WKCACFViewLayerTreeHost.cpp
+++ b/Source/WebCore/platform/graphics/ca/win/WKCACFViewLayerTreeHost.cpp
@@ -26,8 +26,6 @@
  #include "config.h"
  #include "WKCACFViewLayerTreeHost.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "PlatformCALayer.h"
  #include "SoftLinking.h"
  #include <wtf/CurrentTime.h>
@@ -187,5 +185,3 @@ GraphicsDeviceAdapter* WKCACFViewLayerTreeHost::graphicsDeviceAdapter() const
  #endif
  
  } // namespace WebCore
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/ca/win/WKCACFViewLayerTreeHost.h b/Source/WebCore/platform/graphics/ca/win/WKCACFViewLayerTreeHost.h

index c6f4a902c0796f12c8dfc37407b23c9db9f77860..0dd18ca3392d101451e055a706bc183d26bfa472 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/win/WKCACFViewLayerTreeHost.h
+++ b/Source/WebCore/platform/graphics/ca/win/WKCACFViewLayerTreeHost.h
@@ -26,8 +26,6 @@
  #ifndef WKCACFViewLayerTreeHost_h
  #define WKCACFViewLayerTreeHost_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "CACFLayerTreeHost.h"
  
  typedef struct _WKCACFView* WKCACFViewRef;
@@ -65,6 +63,4 @@ private:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // WKCACFViewLayerTreeHost_h
diff --git a/Source/WebCore/platform/graphics/cairo/DrawingBufferCairo.cpp b/Source/WebCore/platform/graphics/cairo/DrawingBufferCairo.cpp

index 738e4938153893d0e2f5a15e72d643f11f52dba8..d710400128ea878ca4496604a00d46d3e556070f 100644 (file)
--- a/Source/WebCore/platform/graphics/cairo/DrawingBufferCairo.cpp
+++ b/Source/WebCore/platform/graphics/cairo/DrawingBufferCairo.cpp
@@ -33,8 +33,6 @@
  
  namespace WebCore {
  
-#if USE(ACCELERATED_COMPOSITING)
-
  unsigned DrawingBuffer::frontColorBuffer() const
  {
      return colorBuffer();
@@ -43,7 +41,6 @@ unsigned DrawingBuffer::frontColorBuffer() const
  void DrawingBuffer::paintCompositedResultsToCanvas(ImageBuffer*)
  {
  }
-#endif
  
  }
  
diff --git a/Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp b/Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp

index 8641fd4839fa29acc5d152a667a8c156d24dc157..80b91e46a0a5d44dfb51f0c1bc8fcb8f39fb629b 100644 (file)
--- a/Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp
+++ b/Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp
@@ -306,12 +306,10 @@ bool GraphicsContext3D::isGLES2Compliant() const
  #endif
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  PlatformLayer* GraphicsContext3D::platformLayer() const
  {
      return m_private.get();
  }
-#endif
  
  } // namespace WebCore
  
diff --git a/Source/WebCore/platform/graphics/cairo/ImageBufferCairo.cpp b/Source/WebCore/platform/graphics/cairo/ImageBufferCairo.cpp

index 00482ad6d469103b04f21053f8812b9a66cfa7ab..86d8269cfcfd08986889a3a0badfea9267942364 100644 (file)
--- a/Source/WebCore/platform/graphics/cairo/ImageBufferCairo.cpp
+++ b/Source/WebCore/platform/graphics/cairo/ImageBufferCairo.cpp
@@ -406,7 +406,6 @@ void ImageBufferData::paintToTextureMapper(TextureMapper* textureMapper, const F
  }
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
  PlatformLayer* ImageBuffer::platformLayer() const
  {
  #if ENABLE(ACCELERATED_2D_CANVAS)
@@ -415,6 +414,5 @@ PlatformLayer* ImageBuffer::platformLayer() const
  #endif
      return 0;
  }
-#endif
  
  } // namespace WebCore
diff --git a/Source/WebCore/platform/graphics/efl/GraphicsContext3DEfl.cpp b/Source/WebCore/platform/graphics/efl/GraphicsContext3DEfl.cpp

index 12ca72664c3290fea274c963181b1ff1233f288f..94618254aee28dfda49415b57296b264af9b0105 100644 (file)
--- a/Source/WebCore/platform/graphics/efl/GraphicsContext3DEfl.cpp
+++ b/Source/WebCore/platform/graphics/efl/GraphicsContext3DEfl.cpp
@@ -21,8 +21,6 @@
  #include "config.h"
  #include "GraphicsContext3D.h"
  
-#if USE(3D_GRAPHICS) || USE(ACCELERATED_COMPOSITING)
-
  #include "GLDefs.h"
  #include "GraphicsContext3DPrivate.h"
  #include "Image.h"
@@ -175,7 +173,6 @@ Platform3DObject GraphicsContext3D::platformTexture() const
      return m_texture;
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  PlatformLayer* GraphicsContext3D::platformLayer() const
  {
  #if USE(TEXTURE_MAPPER_GL)
@@ -185,7 +182,6 @@ PlatformLayer* GraphicsContext3D::platformLayer() const
      return 0;
  #endif
  }
-#endif
  
  bool GraphicsContext3D::makeContextCurrent()
  {
@@ -310,5 +306,3 @@ bool GraphicsContext3D::ImageExtractor::extractImage(bool premultiplyAlpha, bool
  }
  
  } // namespace WebCore
-
-#endif // USE(3D_GRAPHICS)
diff --git a/Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.cpp b/Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.cpp

index c1b7b6ca06e8690f943fe95d986ea89d55242f5c..343dab6a9a30f1c85aeefa854c6af63b37507683 100644 (file)
--- a/Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.cpp
+++ b/Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.cpp
@@ -21,8 +21,6 @@
  #include "config.h"
  #include "GraphicsContext3DPrivate.h"
  
-#if USE(3D_GRAPHICS) || USE(ACCELERATED_COMPOSITING)
-
  #include "HostWindow.h"
  #include "NotImplemented.h"
  
@@ -275,5 +273,3 @@ GraphicsSurface::Flags GraphicsContext3DPrivate::graphicsSurfaceFlags() const
  #endif
  
  } // namespace WebCore
-
-#endif // USE(3D_GRAPHICS) || USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.h b/Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.h

index cc41dc30d36fb917455e9346f4540f77b68772f5..1332a48b8fcc328f74af52619304e74a0bdcc4f0 100644 (file)
--- a/Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.h
+++ b/Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.h
@@ -21,8 +21,6 @@
  #ifndef GraphicsContext3DPrivate_h
  #define GraphicsContext3DPrivate_h
  
-#if USE(3D_GRAPHICS) || USE(ACCELERATED_COMPOSITING)
-
  #include "GraphicsContext3D.h"
  
  #if USE(TEXTURE_MAPPER_GL)
@@ -96,5 +94,3 @@ private:
  } // namespace WebCore
  
  #endif
-
-#endif
diff --git a/Source/WebCore/platform/graphics/gpu/DrawingBuffer.h b/Source/WebCore/platform/graphics/gpu/DrawingBuffer.h

index e234e420cdf49697444370f438b352df13900063..0b75f7686999e1f00a1011c3c61660db58b8b1d7 100644 (file)
--- a/Source/WebCore/platform/graphics/gpu/DrawingBuffer.h
+++ b/Source/WebCore/platform/graphics/gpu/DrawingBuffer.h
@@ -117,11 +117,9 @@ public:
  
      void markContentsChanged() { m_contentsChanged = true; }
  
-#if USE(ACCELERATED_COMPOSITING)
      PlatformLayer* platformLayer();
      unsigned frontColorBuffer() const;
      void paintCompositedResultsToCanvas(ImageBuffer*);
-#endif
  
      GraphicsContext3D* graphicsContext3D() const { return m_context.get(); }
  
diff --git a/Source/WebCore/platform/graphics/gpu/LoopBlinnMathUtils.cpp b/Source/WebCore/platform/graphics/gpu/LoopBlinnMathUtils.cpp

index 32a54fb90dbb7524e99ba30984bec1b217cd7b4c..87d72dff498d8955e948f32fb746ffa8ee2db355 100644 (file)
--- a/Source/WebCore/platform/graphics/gpu/LoopBlinnMathUtils.cpp
+++ b/Source/WebCore/platform/graphics/gpu/LoopBlinnMathUtils.cpp
@@ -25,8 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING) || ENABLE(ACCELERATED_2D_CANVAS)
-
  #include "LoopBlinnMathUtils.h"
  
  #include "FloatPoint.h"
@@ -666,5 +664,3 @@ bool isConvex(const FloatPoint* vertices, int nVertices)
  
  } // namespace LoopBlinnMathUtils
  } // namespace WebCore
-
-#endif
diff --git a/Source/WebCore/platform/graphics/gpu/TilingData.cpp b/Source/WebCore/platform/graphics/gpu/TilingData.cpp

index 23df37da0a8e263955512471ebfe0ab06824e31a..6a3d04c4d9e1a23b0d66537439d2d12dd3ae1e91 100644 (file)
--- a/Source/WebCore/platform/graphics/gpu/TilingData.cpp
+++ b/Source/WebCore/platform/graphics/gpu/TilingData.cpp
@@ -30,8 +30,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING) || ENABLE(ACCELERATED_2D_CANVAS)
-
  #include "TilingData.h"
  
  #include "FloatRect.h"
@@ -203,5 +201,3 @@ void TilingData::recomputeNumTiles()
  }
  
  }
-
-#endif
diff --git a/Source/WebCore/platform/graphics/gpu/mac/DrawingBufferMac.mm b/Source/WebCore/platform/graphics/gpu/mac/DrawingBufferMac.mm

index 51c2657f1d1976c9d328758b38ae8d7bffa0ea29..42c0e0e52a0c655e1266963df7ba13126132ec55 100644 (file)
--- a/Source/WebCore/platform/graphics/gpu/mac/DrawingBufferMac.mm
+++ b/Source/WebCore/platform/graphics/gpu/mac/DrawingBufferMac.mm
@@ -94,7 +94,6 @@ DrawingBuffer::~DrawingBuffer()
      clear();
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  PlatformLayer* DrawingBuffer::platformLayer()
  {
      return m_platformLayer.get();
@@ -104,7 +103,6 @@ unsigned DrawingBuffer::frontColorBuffer() const
  {
      return colorBuffer();
  }
-#endif
  
  }
  
diff --git a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp

index 3763a006fb2ec74b183ff119d6fe47cd34882c11..2bcc636980559ebe3ba769fbcbc33d867f090163 100644 (file)
--- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
+++ b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
@@ -43,7 +43,7 @@
  
  #include <gst/audio/streamvolume.h>
  
-#if GST_CHECK_VERSION(1, 1, 0) && USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER_GL)
+#if GST_CHECK_VERSION(1, 1, 0) && USE(TEXTURE_MAPPER_GL)
  #include "TextureMapperGL.h"
  #endif
  
@@ -304,7 +304,7 @@ void MediaPlayerPrivateGStreamerBase::muteChanged()
  }
  
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
+#if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
  PassRefPtr<BitmapTexture> MediaPlayerPrivateGStreamerBase::updateTexture(TextureMapper* textureMapper)
  {
      GMutexLocker lock(m_bufferMutex);
@@ -357,7 +357,7 @@ void MediaPlayerPrivateGStreamerBase::triggerRepaint(GstBuffer* buffer)
          gst_buffer_replace(&m_buffer, buffer);
      }
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
+#if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
      if (supportsAcceleratedRendering() && m_player->mediaPlayerClient()->mediaPlayerRenderingCanBeAccelerated(m_player) && client()) {
          client()->setPlatformLayerNeedsDisplay();
          return;
@@ -374,7 +374,7 @@ void MediaPlayerPrivateGStreamerBase::setSize(const IntSize& size)
  
  void MediaPlayerPrivateGStreamerBase::paint(GraphicsContext* context, const IntRect& rect)
  {
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
+#if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
      if (client())
          return;
  #endif
@@ -401,7 +401,7 @@ void MediaPlayerPrivateGStreamerBase::paint(GraphicsContext* context, const IntR
          rect, gstImage->rect(), CompositeCopy, ImageOrientationDescription(), false);
  }
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
+#if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
  void MediaPlayerPrivateGStreamerBase::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity)
  {
      if (textureMapper->accelerationMode() != TextureMapper::OpenGLMode)
diff --git a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h

index 0f650944a5eba49dc232a9b5762f35e046ae284d..cb7bb0b2eb9ec56c43cdbc3024aaa5d7dd0438c7 100644 (file)
--- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h
+++ b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h
@@ -31,7 +31,7 @@
  
  #include <wtf/Forward.h>
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
+#if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
  #include "TextureMapperPlatformLayer.h"
  #endif
  
@@ -48,7 +48,7 @@ class IntSize;
  class IntRect;
  
  class MediaPlayerPrivateGStreamerBase : public MediaPlayerPrivateInterface
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
+#if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
      , public TextureMapperPlatformLayer
  #endif
  {
@@ -95,7 +95,7 @@ public:
      unsigned audioDecodedByteCount() const;
      unsigned videoDecodedByteCount() const;
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
+#if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
      virtual PlatformLayer* platformLayer() const { return const_cast<MediaPlayerPrivateGStreamerBase*>(this); }
      virtual bool supportsAcceleratedRendering() const { return true; }
      virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float);
@@ -125,7 +125,7 @@ protected:
      unsigned long m_volumeSignalHandler;
      unsigned long m_muteSignalHandler;
      mutable IntSize m_videoSize;
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
+#if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
      PassRefPtr<BitmapTexture> updateTexture(TextureMapper*);
  #endif
  };
diff --git a/Source/WebCore/platform/graphics/ios/MediaPlayerPrivateIOS.h b/Source/WebCore/platform/graphics/ios/MediaPlayerPrivateIOS.h

index 8116f83ddf1b93d736ff916e4843f0b545482001..16274b25be514eb9546597b6657f7a30cd517e1a 100644 (file)
--- a/Source/WebCore/platform/graphics/ios/MediaPlayerPrivateIOS.h
+++ b/Source/WebCore/platform/graphics/ios/MediaPlayerPrivateIOS.h
@@ -142,9 +142,7 @@ private:
      virtual void setHasPlaybackTargetAvailabilityListeners(bool) override;
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
      virtual bool supportsAcceleratedRendering() const override;
-#endif
  
      virtual void setMediaPlayerProxy(WebMediaPlayerProxy*) override;
      void processPendingRequests();
diff --git a/Source/WebCore/platform/graphics/ios/MediaPlayerPrivateIOS.mm b/Source/WebCore/platform/graphics/ios/MediaPlayerPrivateIOS.mm

index 9eea7279daecf01cd0911e11e5047c49018dd60c..52bb0190178544152403afc5152d8ebb90380a76 100644 (file)
--- a/Source/WebCore/platform/graphics/ios/MediaPlayerPrivateIOS.mm
+++ b/Source/WebCore/platform/graphics/ios/MediaPlayerPrivateIOS.mm
@@ -663,12 +663,10 @@ void MediaPlayerPrivateIOS::setHasPlaybackTargetAvailabilityListeners(bool hasLi
  }
  #endif
  
-#if USE(ACCELERATED_COMPOSITING)
  bool MediaPlayerPrivateIOS::supportsAcceleratedRendering() const
  {
      return true;
  }
-#endif
  
  void MediaPlayerPrivateIOS::enterFullscreen()
  {
diff --git a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h b/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h

index 9ea438c39ddda87206d31c81f2ec78fcf73f7036..25e679206d65a8be13fcd3ab22d584b61d287ccb 100644 (file)
--- a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h
+++ b/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h
@@ -65,9 +65,7 @@ public:
      void sizeChanged();
      void timeChanged();
      void didEnd();
-#if USE(ACCELERATED_COMPOSITING)
      void layerHostChanged(PlatformLayer* rootLayer);
-#endif
  
  private:
      MediaPlayerPrivateQTKit(MediaPlayer*);
@@ -83,9 +81,7 @@ private:
      static bool isAvailable();
  
      PlatformMedia platformMedia() const;
-#if USE(ACCELERATED_COMPOSITING)
      PlatformLayer* platformLayer() const;
-#endif
  
      IntSize naturalSize() const;
      bool hasVideo() const;
@@ -138,11 +134,8 @@ private:
      void paintCurrentFrameInContext(GraphicsContext*, const IntRect&);
      virtual void prepareForRendering();
  
-
-#if USE(ACCELERATED_COMPOSITING)
      bool supportsAcceleratedRendering() const;
      void acceleratedRenderingStateChanged();
-#endif
  
      bool hasSingleSecurityOrigin() const;
      MediaPlayer::MovieLoadType movieLoadType() const;
diff --git a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm b/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm

index d922ced35785e5537da940b358171a31b35120b3..789b9ef97a276369e528144a24c5c6adc5e64c42 100644 (file)
--- a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm
+++ b/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm
@@ -38,6 +38,7 @@
  #import "URL.h"
  #import "Logging.h"
  #import "MIMETypeRegistry.h"
+#import "PlatformLayer.h"
  #import "SecurityOrigin.h"
  #import "SoftLinking.h"
  #import "TimeRanges.h"
@@ -45,10 +46,6 @@
  #import <QTKit/QTKit.h>
  #import <objc/runtime.h>
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "PlatformLayer.h"
-#endif
-
  #if DRAW_FRAME_RATE
  #import "Font.h"
  #import "Document.h"
@@ -508,7 +505,6 @@ void MediaPlayerPrivateQTKit::destroyQTVideoRenderer()
  void MediaPlayerPrivateQTKit::createQTMovieLayer()
  {
      LOG(Media, "MediaPlayerPrivateQTKit::createQTMovieLayer(%p)", this);
-#if USE(ACCELERATED_COMPOSITING)
      if (!m_qtMovie)
          return;
  
@@ -525,20 +521,17 @@ void MediaPlayerPrivateQTKit::createQTMovieLayer()
  #endif
          // The layer will get hooked up via RenderLayerBacking::updateGraphicsLayerConfiguration().
      }
-#endif
  }
  
  void MediaPlayerPrivateQTKit::destroyQTMovieLayer()
  {
      LOG(Media, "MediaPlayerPrivateQTKit::destroyQTMovieLayer(%p)", this);
-#if USE(ACCELERATED_COMPOSITING)
      if (!m_qtVideoLayer)
          return;
  
      // disassociate our movie from our instance of QTMovieLayer
      [m_qtVideoLayer.get() setMovie:nil];    
      m_qtVideoLayer = nil;
-#endif
  }
  
  MediaPlayerPrivateQTKit::MediaRenderingMode MediaPlayerPrivateQTKit::currentRenderingMode() const
@@ -560,10 +553,8 @@ MediaPlayerPrivateQTKit::MediaRenderingMode MediaPlayerPrivateQTKit::preferredRe
      if (!m_player->frameView() || !m_qtMovie)
          return MediaRenderingNone;
  
-#if USE(ACCELERATED_COMPOSITING)
      if (supportsAcceleratedRendering() && m_player->mediaPlayerClient()->mediaPlayerRenderingCanBeAccelerated(m_player))
          return MediaRenderingMovieLayer;
-#endif
  
      if (!QTVideoRendererClass())
          return MediaRenderingMovieView;
@@ -691,12 +682,10 @@ PlatformMedia MediaPlayerPrivateQTKit::platformMedia() const
      return pm;
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  PlatformLayer* MediaPlayerPrivateQTKit::platformLayer() const
  {
      return m_qtVideoLayer.get();
  }
-#endif
  
  void MediaPlayerPrivateQTKit::play()
  {
@@ -897,12 +886,10 @@ void MediaPlayerPrivateQTKit::setClosedCaptionsVisible(bool closedCaptionsVisibl
      if (metaDataAvailable()) {
          wkQTMovieSetShowClosedCaptions(m_qtMovie.get(), closedCaptionsVisible);
  
-#if USE(ACCELERATED_COMPOSITING)
          if (closedCaptionsVisible && m_qtVideoLayer) {
              // Captions will be rendered upside down unless we flag the movie as flipped (again). See <rdar://7408440>.
              [m_qtVideoLayer.get() setGeometryFlipped:YES];
          }
-#endif
      }
  }
  
@@ -1225,12 +1212,10 @@ void MediaPlayerPrivateQTKit::didEnd()
      m_player->timeChanged();
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  void MediaPlayerPrivateQTKit::layerHostChanged(PlatformLayer* rootLayer)
  {
      UNUSED_PARAM(rootLayer);
  }
-#endif
  
  void MediaPlayerPrivateQTKit::setSize(const IntSize&) 
  { 
@@ -1617,7 +1602,6 @@ void MediaPlayerPrivateQTKit::sawUnsupportedTracks()
      m_player->mediaPlayerClient()->mediaPlayerSawUnsupportedTracks(m_player);
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  bool MediaPlayerPrivateQTKit::supportsAcceleratedRendering() const
  {
      return isReadyForVideoSetup() && getQTMovieLayerClass() != Nil;
@@ -1628,7 +1612,6 @@ void MediaPlayerPrivateQTKit::acceleratedRenderingStateChanged()
      // Set up or change the rendering path if necessary.
      setUpVideoRendering();
  }
-#endif
  
  bool MediaPlayerPrivateQTKit::hasSingleSecurityOrigin() const
  {
@@ -1780,12 +1763,8 @@ void MediaPlayerPrivateQTKit::setPrivateBrowsingMode(bool privateBrowsing)
  
  - (void)layerHostChanged:(NSNotification *)notification
  {
-#if USE(ACCELERATED_COMPOSITING)
      CALayer* rootLayer = static_cast<CALayer*>([notification object]);
      m_callback->layerHostChanged(rootLayer);
-#else
-    UNUSED_PARAM(notification);
-#endif
  }
  
  - (void)setDelayCallbacks:(BOOL)shouldDelay
diff --git a/Source/WebCore/platform/graphics/mac/WebGLLayer.h b/Source/WebCore/platform/graphics/mac/WebGLLayer.h

index eade52034cdd810a602fe81fda2842b23186a09e..00c81f6aae09a653f27345d6b31af6333ec22823 100644 (file)
--- a/Source/WebCore/platform/graphics/mac/WebGLLayer.h
+++ b/Source/WebCore/platform/graphics/mac/WebGLLayer.h
@@ -26,8 +26,6 @@
  #ifndef WebGLLayer_h
  #define WebGLLayer_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #import <QuartzCore/QuartzCore.h>
  
  namespace WebCore {
@@ -51,6 +49,4 @@ namespace WebCore {
  
  @end
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // WebGLLayer_h
diff --git a/Source/WebCore/platform/graphics/mac/WebGLLayer.mm b/Source/WebCore/platform/graphics/mac/WebGLLayer.mm

index 648299e7596c34562e154450e77ea24a782b21ec..71f81fca6c3a37d2ea4093d2560ec0936ef64646 100644 (file)
--- a/Source/WebCore/platform/graphics/mac/WebGLLayer.mm
+++ b/Source/WebCore/platform/graphics/mac/WebGLLayer.mm
@@ -25,7 +25,6 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING)
  #if ENABLE(WEBGL)
  
  #import "WebGLLayer.h"
@@ -177,4 +176,3 @@ static void freeData(void *, const void *data, size_t /* size */)
  @end
  
  #endif // ENABLE(WEBGL)
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/mac/WebLayer.h b/Source/WebCore/platform/graphics/mac/WebLayer.h

index 52dcb2388e120bbbd97969df8ba709674719627e..1222a6337ecd594ba20071d1ec9d2fedf04bc8e7 100644 (file)
--- a/Source/WebCore/platform/graphics/mac/WebLayer.h
+++ b/Source/WebCore/platform/graphics/mac/WebLayer.h
@@ -26,8 +26,6 @@
  #ifndef WebLayer_h
  #define WebLayer_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #import <QuartzCore/QuartzCore.h>
  #import <WebCore/FloatRect.h>
  #import <wtf/Vector.h>
@@ -54,6 +52,4 @@ void drawLayerContents(CGContextRef, PlatformCALayer*, RepaintRectList& dirtyRec
  void drawRepaintIndicator(CGContextRef, PlatformCALayer*, int repaintCount, CGColorRef customBackgroundColor);
  }
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // WebLayer_h
diff --git a/Source/WebCore/platform/graphics/mac/WebLayer.mm b/Source/WebCore/platform/graphics/mac/WebLayer.mm

index d99df2eb03acf45f81bab327ca3b7c2c13e0d641..9f2179d6092fe5a48ff60df21342693e29b2fd6b 100644 (file)
--- a/Source/WebCore/platform/graphics/mac/WebLayer.mm
+++ b/Source/WebCore/platform/graphics/mac/WebLayer.mm
@@ -24,9 +24,6 @@
   */
  
  #include "config.h"
-
-#if USE(ACCELERATED_COMPOSITING)
-
  #import "WebLayer.h"
  
  #import "GraphicsContext.h"
@@ -330,5 +327,3 @@ void drawRepaintIndicator(CGContextRef context, PlatformCALayer* platformCALayer
  @end  // implementation WebLayer(ExtendedDescription)
  
  #endif // NDEBUG
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/mac/WebTiledLayer.h b/Source/WebCore/platform/graphics/mac/WebTiledLayer.h

index 6f559e3d3201f2a34c2276e1107432d57a9d0fb8..46d58a9dab40c0671b500c66718b8dbe19a275ae 100644 (file)
--- a/Source/WebCore/platform/graphics/mac/WebTiledLayer.h
+++ b/Source/WebCore/platform/graphics/mac/WebTiledLayer.h
@@ -26,8 +26,6 @@
  #ifndef WebTiledLayer_h
  #define WebTiledLayer_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #import "WebLayer.h"
  
  @interface WebTiledLayer : CATiledLayer 
@@ -38,7 +36,5 @@
  
  @end
  
-#endif // USE(ACCELERATED_COMPOSITING)
-
  #endif // WebTiledLayer_h
  
diff --git a/Source/WebCore/platform/graphics/mac/WebTiledLayer.mm b/Source/WebCore/platform/graphics/mac/WebTiledLayer.mm

index c86afa6884becd2f36847f3bd20d78d094ca21ef..71386043e3586366e87c1643bc5f0b251fe146b8 100644 (file)
--- a/Source/WebCore/platform/graphics/mac/WebTiledLayer.mm
+++ b/Source/WebCore/platform/graphics/mac/WebTiledLayer.mm
@@ -24,9 +24,6 @@
   */
  
  #include "config.h"
-
-#if USE(ACCELERATED_COMPOSITING)
-
  #import "WebTiledLayer.h"
  
  #import "GraphicsContext.h"
@@ -141,5 +138,3 @@ using namespace WebCore;
  }
  
  @end // implementation WebTiledLayer
-
-#endif // USE(ACCELERATED_COMPOSITING)
diff --git a/Source/WebCore/platform/graphics/opengl/GLDefs.h b/Source/WebCore/platform/graphics/opengl/GLDefs.h

index 659d249749c731182d5d8a571a1a252f3931cd71..a091f135829ef8fc75eff405d8db762f3af42c77 100644 (file)
--- a/Source/WebCore/platform/graphics/opengl/GLDefs.h
+++ b/Source/WebCore/platform/graphics/opengl/GLDefs.h
@@ -26,8 +26,6 @@
  #ifndef GLDefs_h
  #define GLDefs_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #define GL_GLEXT_PROTOTYPES 1
  
  #if USE(OPENGL_ES_2)
@@ -82,5 +80,3 @@ typedef void* PlatformDrawable;
  }
  
  #endif
-
-#endif
diff --git a/Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp b/Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp

index 9ab3dea9538fcb5f6a39051a0c978fb85670945a..06f61c4e7a0892e948a271bb62cc611cf4921cde 100644 (file)
--- a/Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp
+++ b/Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp
@@ -26,8 +26,6 @@
  #include "config.h"
  #include "GLPlatformContext.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #if USE(GLX)
  #include "GLXContext.h"
  #elif USE(EGL)
@@ -285,5 +283,3 @@ void GLPlatformContext::destroy()
  }
  
  } // namespace WebCore
-
-#endif
diff --git a/Source/WebCore/platform/graphics/opengl/GLPlatformContext.h b/Source/WebCore/platform/graphics/opengl/GLPlatformContext.h

index 2e41db3da2c490d5696c4336d86bcc47f50c1b47..03147c88bebc6265acc1a1f4b1addee0c9f2ccd3 100644 (file)
--- a/Source/WebCore/platform/graphics/opengl/GLPlatformContext.h
+++ b/Source/WebCore/platform/graphics/opengl/GLPlatformContext.h
@@ -26,8 +26,6 @@
  #ifndef GLPlatformContext_h
  #define GLPlatformContext_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "GLDefs.h"
  #include "GLPlatformSurface.h"
  #include "GraphicsContext3D.h"
@@ -96,6 +94,4 @@ protected:
  
  } // namespace WebCore
  
-#endif
-
  #endif // GLNativeContext_H
diff --git a/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.cpp b/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.cpp

index 43b65308d0affaa0b8912d8898382add908e0386..dd27f76992b7538f7dc6fe213410023a9a25018d 100644 (file)
--- a/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.cpp
+++ b/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.cpp
@@ -26,8 +26,6 @@
  #include "config.h"
  #include "GLPlatformSurface.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #if USE(GLX)
  #include "GLXSurface.h"
  #endif
@@ -133,5 +131,3 @@ GLPlatformSurface::SurfaceAttributes GLPlatformSurface::attributes() const
  }
  
  }
-
-#endif
diff --git a/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.h b/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.h

index d276fa5e8e0b672f5aa30c9be2ae35e3288b7f11..af7f7bcb7389f3bbd4cd960bb39b26c0b56f872f 100644 (file)
--- a/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.h
+++ b/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.h
@@ -26,8 +26,6 @@
  #ifndef GLPlatformSurface_h
  #define GLPlatformSurface_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "GLDefs.h"
  #include "IntRect.h"
  #include <wtf/Noncopyable.h>
@@ -95,6 +93,3 @@ protected:
  }
  
  #endif
-
-#endif
-
diff --git a/Source/WebCore/platform/graphics/surfaces/GLTransportSurface.cpp b/Source/WebCore/platform/graphics/surfaces/GLTransportSurface.cpp

index 8199d6ba6b67d51307b3bec5769a4698fa572557..25d6ce9f1e5ebaa94b0db6266ae3f5078f128745 100644 (file)
--- a/Source/WebCore/platform/graphics/surfaces/GLTransportSurface.cpp
+++ b/Source/WebCore/platform/graphics/surfaces/GLTransportSurface.cpp
@@ -26,8 +26,6 @@
  #include "config.h"
  #include "GLTransportSurface.h"
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "FloatRect.h"
  
  #if USE(GLX)
@@ -259,5 +257,3 @@ void GLTransportSurfaceClient::createTexture()
  }
  
  }
-
-#endif
diff --git a/Source/WebCore/platform/graphics/surfaces/GLTransportSurface.h b/Source/WebCore/platform/graphics/surfaces/GLTransportSurface.h

index 2fdd1f8dfb159f276f7259997dbead8ee0a48d1a..b579c859af430dcd22b3b6e206f42b3ce1cf2316 100644 (file)
--- a/Source/WebCore/platform/graphics/surfaces/GLTransportSurface.h
+++ b/Source/WebCore/platform/graphics/surfaces/GLTransportSurface.h
@@ -26,8 +26,6 @@
  #ifndef GLTransportSurface_h
  #define GLTransportSurface_h
  
-#if USE(ACCELERATED_COMPOSITING)
-
  #include "GLPlatformSurface.h"
  #include <wtf/PassOwnPtr.h>
  
@@ -77,5 +75,3 @@ protected:
  }
  
  #endif
-
-#endif
diff --git a/Source/WebCore/platform/graphics/surfaces/glx/GLXConfigSelector.h b/Source/WebCore/platform/graphics/surfaces/glx/GLXConfigSelector.h

index 2fea7b004471f6bcf4dc307a23ffc17191797fb5..8a6109a2fc4e1053f2fead1c8ef19aceb06f381d 100644 (file)
--- a/Source/WebCore/platform/graphics/surfaces/glx/GLXConfigSelector.h
+++ b/Source/WebCore/platform/graphics/surfaces/glx/GLXConfigSelector.h
@@ -26,7 +26,7 @@
  #ifndef GLXConfigSelector_h
  #define GLXConfigSelector_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(GLX)
+#if USE(GLX)
  
  #include "X11Helper.h"
  #include <opengl/GLDefs.h>
diff --git a/Source/WebCore/platform/graphics/surfaces/glx/GLXContext.cpp b/Source/WebCore/platform/graphics/surfaces/glx/GLXContext.cpp

index 10d44f882ecab890f15769809a090d43f0387e7b..f42d3afa33c6b4873100b3078e03329d8f2bb656 100644 (file)
--- a/Source/WebCore/platform/graphics/surfaces/glx/GLXContext.cpp
+++ b/Source/WebCore/platform/graphics/surfaces/glx/GLXContext.cpp
@@ -26,7 +26,7 @@
  #include "config.h"
  #include "GLXContext.h"
  
-#if USE(ACCELERATED_COMPOSITING) && USE(GLX)
+#if USE(GLX)
  
  #include "X11Helper.h"
  
diff --git a/Source/WebCore/platform/graphics/surfaces/glx/GLXContext.h b/Source/WebCore/platform/graphics/surfaces/glx/GLXContext.h

index b08b53e83c0cd9d603991725b992fdb43e1cda93..95e969239d402b322757065fd0a3e98811c217ef 100644 (file)
--- a/Source/WebCore/platform/graphics/surfaces/glx/GLXContext.h
+++ b/Source/WebCore/platform/graphics/surfaces/glx/GLXContext.h
@@ -26,7 +26,7 @@
  #ifndef GLXContext_h
  #define GLXContext_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(GLX)
+#if USE(GLX)
  
  #include "GLPlatformContext.h"
  
diff --git a/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp b/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp

index 4db9c89875b8efd7d802269f507b62ff0b949624..16f56c17070bcff563799d58132d8f5eccb1546d 100644 (file)
--- a/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp
+++ b/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp
@@ -26,7 +26,7 @@
  #include "config.h"
  #include "GLXSurface.h"
  
-#if USE(ACCELERATED_COMPOSITING) && USE(GLX)
+#if USE(GLX)
  
  namespace WebCore {
  
diff --git a/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.h b/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.h

index bb76fc01ffb49f106a7075aad13e18178ec4daa7..0b19fe39688c8cc7106583adbf5cdb1efa242011 100644 (file)
--- a/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.h
+++ b/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.h
@@ -26,7 +26,7 @@
  #ifndef GLXSurface_h
  #define GLXSurface_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(GLX)
+#if USE(GLX)
  
  #include "GLTransportSurface.h"
  #include "GLXConfigSelector.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapper.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapper.cpp

index 4c8ee6a2b78d1cd3af0d95f8ee5058f172a0feb4..4cf446282a14dc2d03dcf1ca0095859122dfcefa 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapper.cpp
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapper.cpp
@@ -26,7 +26,7 @@
  #include "Timer.h"
  #include <wtf/CurrentTime.h>
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  
  namespace WebCore {
  
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapper.h b/Source/WebCore/platform/graphics/texmap/TextureMapper.h

index a0a171e0565c536c5fe9c759c9c29a23fa02c557..2c86d727c69f637edbd083fee0937c6806a6a1f7 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapper.h
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapper.h
@@ -20,7 +20,7 @@
  #ifndef TextureMapper_h
  #define TextureMapper_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  
  #if (PLATFORM(GTK) || PLATFORM(EFL)) && USE(OPENGL_ES_2)
  #define TEXMAP_OPENGL_ES_2
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperBackingStore.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperBackingStore.cpp

index e68bc0914145c66848b3de5ab24487d35842dd83..7a00e22ae5ac7e55f13d7c1b7ba846b0ced6fdb8 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperBackingStore.cpp
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperBackingStore.cpp
@@ -19,7 +19,7 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  #include "TextureMapperBackingStore.h"
  
  #include "GraphicsLayer.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperBackingStore.h b/Source/WebCore/platform/graphics/texmap/TextureMapperBackingStore.h

index 4bae45b4f180658235a64ca9465d032ee245e095..7927a49b43853dcc131e7b756782a40274fb3548 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperBackingStore.h
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperBackingStore.h
@@ -20,7 +20,7 @@
  #ifndef TextureMapperBackingStore_h
  #define TextureMapperBackingStore_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  
  #include "FloatRect.h"
  #include "Image.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperFPSCounter.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperFPSCounter.cpp

index d74477010a38b3b108fdc97896d69b0c7c975359..2d333af390e5382e1aec8e5364bb42ffe0e186e1 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperFPSCounter.cpp
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperFPSCounter.cpp
@@ -21,7 +21,7 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  
  #include "TextureMapperFPSCounter.h"
  
@@ -64,4 +64,4 @@ void TextureMapperFPSCounter::updateFPSAndDisplay(TextureMapper* textureMapper,
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
+#endif // USE(TEXTURE_MAPPER)
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperFPSCounter.h b/Source/WebCore/platform/graphics/texmap/TextureMapperFPSCounter.h

index 0062373835b76eccfde1b70a59c1c4ec691bf0fc..649989c76c41839a9dcfb0d9d969f7386454ee30 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperFPSCounter.h
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperFPSCounter.h
@@ -22,7 +22,7 @@
  #ifndef TextureMapperFPSCounter_h
  #define TextureMapperFPSCounter_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  #include "FloatPoint.h"
  #include "TransformationMatrix.h"
  #include <wtf/Noncopyable.h>
@@ -47,7 +47,7 @@ private:
  
  } // namespace WebCore
  
-#endif // USE(ACCELERATED_COMPOSITING)
+#endif // USE(TEXTURE_MAPPER)
  
  #endif // TextureMapperFPSCounter_h
  
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp

index 05b884bd5d42718f8eea41cebf414d1dc542ba45..f09bba5118f4b9c0a3e3459938f98ef3c7df5fbe 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp
@@ -50,7 +50,7 @@
  #define GL_UNPACK_SKIP_ROWS 0x0CF3
  #endif
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  
  namespace WebCore {
  struct TextureMapperGLData {
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperGL.h b/Source/WebCore/platform/graphics/texmap/TextureMapperGL.h

index 081403f003a2c4762bf591dfcb35599a7d88860c..f0fd1b1b4e12e5d9c013a6247ee3b54f4e2bd0c3 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperGL.h
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperGL.h
@@ -20,7 +20,7 @@
  #ifndef TextureMapperGL_h
  #define TextureMapperGL_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  
  #include "FilterOperation.h"
  #include "FloatQuad.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp

index 7e7babbcd0c91de4b2722638255e64559a79cb73..86592c6a7c7b77439530e31e7eea98b9fcaec961 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp
@@ -24,7 +24,7 @@
  #include "Region.h"
  #include <wtf/MathExtras.h>
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  
  namespace WebCore {
  
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.h b/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.h

index 87ff3f4a7ae206bec40d566d0661c15d4de9ffed..9046aa53708a40bd475a5f891bd92078516ed3b0 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.h
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.h
@@ -20,7 +20,7 @@
  #ifndef TextureMapperLayer_h
  #define TextureMapperLayer_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  
  #include "FilterOperations.h"
  #include "FloatRect.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp

index f4b9a7e983025cec9428c3bd007de431e9092304..72475029a8484252f7f98f8ed6dba4ad5d6651f9 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp
@@ -22,7 +22,7 @@
  #include "config.h"
  #include "TextureMapperShaderProgram.h"
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  #include "LengthFunctions.h"
  #include "Logging.h"
  #include "TextureMapperGL.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperSurfaceBackingStore.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperSurfaceBackingStore.cpp

index 8d38776e9b5f533a605e73ca76e33cabfd98b7c9..b33bbb6293005eff6af376c41418edac5508a10a 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperSurfaceBackingStore.cpp
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperSurfaceBackingStore.cpp
@@ -19,7 +19,7 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING) && USE(GRAPHICS_SURFACE)
+#if USE(GRAPHICS_SURFACE)
  #include "TextureMapperSurfaceBackingStore.h"
  
  #include "GraphicsSurface.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperSurfaceBackingStore.h b/Source/WebCore/platform/graphics/texmap/TextureMapperSurfaceBackingStore.h

index 793c61dc342ff0263527874c7120d35eb280c578..31d18192cd3ef0ab468681cbfe5adfe9683538bb 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperSurfaceBackingStore.h
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperSurfaceBackingStore.h
@@ -20,7 +20,7 @@
  #ifndef TextureMapperSurfaceBackingStore_h
  #define TextureMapperSurfaceBackingStore_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(GRAPHICS_SURFACE)
+#if USE(GRAPHICS_SURFACE)
  
  #include "GraphicsSurface.h"
  #include "TextureMapperBackingStore.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperTile.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperTile.cpp

index 2ea7fb6ed886564c95999eb5cdb8a54615ad5e9d..e6f3fe80ee6822bc0a4506f707f51978e4656aa2 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperTile.cpp
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperTile.cpp
@@ -18,7 +18,7 @@
   */
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  #include "TextureMapperTile.h"
  
  #include "Image.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperTile.h b/Source/WebCore/platform/graphics/texmap/TextureMapperTile.h

index ee6809f204434685f09be8e4a3e0ff14dee9a054..648e71f00a09aaf7bbfe39280ec0ea77eb1486df 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperTile.h
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperTile.h
@@ -20,7 +20,7 @@
  #ifndef TextureMapperTile_h
  #define TextureMapperTile_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  
  #include "FloatRect.h"
  #include "Image.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp

index ef564023d68ef876f2a33b4ea421a80afd990a35..b81b89f0c0476933747f2c8192bfb573aadb3d43 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp
@@ -19,7 +19,7 @@
  
  #include "config.h"
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  #include "TextureMapperTiledBackingStore.h"
  
  #include "ImageBuffer.h"
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.h b/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.h

index 38161c4753c0d7265bdd30eecd0eb7e9c5792028..2f792dcf94848d4b8abb0a29f10d83184e30f59d 100644 (file)
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.h
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.h
@@ -20,7 +20,7 @@
  #ifndef TextureMapperTiledBackingStore_h
  #define TextureMapperTiledBackingStore_h
  
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#if USE(TEXTURE_MAPPER)
  
  #include "FloatRect.h"
  #include "Image.h"
diff --git a/Source/WebCore/platform/graphics/win/GraphicsContext3DWin.cpp b/Source/WebCore/platform/graphics/win/GraphicsContext3DWin.cpp

index 05e150848f70a00e786860eb23f7bab091f3af68..2f35ef540c8703d2d17b8de4454dbae5a5f78b68 100644 (file)
--- a/Source/WebCore/platform/graphics/win/GraphicsContext3DWin.cpp
+++ b/Source/WebCore/platform/graphics/win/GraphicsContext3DWin.cpp
@@ -197,12 +197,10 @@ bool GraphicsContext3D::isGLES2Compliant() const
  #endif
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  PlatformLayer* GraphicsContext3D::platformLayer() const
  {
      return m_webGLLayer->platformLayer();
  }
-#endif
  
  } // namespace WebCore
  
diff --git a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.cpp b/Source/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.cpp

index 6077f2df36187c48f266889b00a71a81251ac3cc..0d098bdf3f23c899e4aeb27b4f2055fe2b666cc6 100644 (file)
--- a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.cpp
+++ b/Source/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.cpp
@@ -34,7 +34,7 @@
  #include <CoreGraphics/CGColor.h>
  #endif
  
-#if USE(ACCELERATED_COMPOSITING) && USE(CA)
+#if USE(CA)
  #include "CACFLayerTreeHost.h"
  #include "PlatformCALayer.h"
  #endif
@@ -84,7 +84,7 @@ void MediaPlayerPrivateFullscreenWindow::createWindow(HWND parentHwnd)
          parentHwnd, 0, instanceHandle(), this);
      ASSERT(IsWindow(m_hwnd));
  
-#if USE(ACCELERATED_COMPOSITING) && USE(CA)
+#if USE(CA)
      if (m_layerTreeHost)
          m_layerTreeHost->setWindow(m_hwnd);
  #endif
@@ -92,7 +92,7 @@ void MediaPlayerPrivateFullscreenWindow::createWindow(HWND parentHwnd)
      ::SetFocus(m_hwnd);
  }
  
-#if USE(ACCELERATED_COMPOSITING) && USE(CA)
+#if USE(CA)
  void MediaPlayerPrivateFullscreenWindow::setRootChildLayer(PassRefPtr<PlatformCALayer> rootChild)
  {
      if (m_rootChild == rootChild)
@@ -156,7 +156,7 @@ LRESULT MediaPlayerPrivateFullscreenWindow::wndProc(HWND hWnd, UINT message, WPA
          break;
      case WM_DESTROY:
          m_hwnd = 0;
-#if USE(ACCELERATED_COMPOSITING) && USE(CA)
+#if USE(CA)
          if (m_layerTreeHost)
              m_layerTreeHost->setWindow(0);
  #endif
@@ -166,7 +166,7 @@ LRESULT MediaPlayerPrivateFullscreenWindow::wndProc(HWND hWnd, UINT message, WPA
              LPWINDOWPOS wp = reinterpret_cast<LPWINDOWPOS>(lParam);
              if (wp->flags & SWP_NOSIZE)
                  break;
-#if USE(ACCELERATED_COMPOSITING) && USE(CA)
+#if USE(CA)
              if (m_layerTreeHost) {
                  m_layerTreeHost->resize();
                  PlatformCALayer* rootLayer = m_rootChild->rootLayer();
@@ -179,7 +179,7 @@ LRESULT MediaPlayerPrivateFullscreenWindow::wndProc(HWND hWnd, UINT message, WPA
          }
          break;
      case WM_PAINT:
-#if USE(ACCELERATED_COMPOSITING) && USE(CA)
+#if USE(CA)
          if (m_layerTreeHost) {
              m_layerTreeHost->paint();
              ::ValidateRect(m_hwnd, 0);
diff --git a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.h b/Source/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.h

index 9f2d63a83528a36dfca0176a146a982f776e4f4a..cdd0ca30410ba4a6c928dfb9e9ff6a9c55e8d19d 100644 (file)
--- a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.h
+++ b/Source/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.h
@@ -29,13 +29,13 @@
  #include <wtf/RefPtr.h>
  #include <wtf/WindowsExtras.h>
  
-#if USE(ACCELERATED_COMPOSITING) && USE(CA)
+#if USE(CA)
  #include "CACFLayerTreeHostClient.h"
  #endif
  
  namespace WebCore {
  
-#if USE(ACCELERATED_COMPOSITING) && USE(CA)
+#if USE(CA)
  class CACFLayerTreeHost;
  class PlatformCALayer;
  #endif
@@ -56,7 +56,7 @@ public:
      
      HWND hwnd() const { return m_hwnd; }
  
-#if USE(ACCELERATED_COMPOSITING) && USE(CA)
+#if USE(CA)
      PlatformCALayer* rootChildLayer() const { return m_rootChild.get(); }
      void setRootChildLayer(PassRefPtr<PlatformCALayer>);
  #endif
@@ -66,7 +66,7 @@ private:
      LRESULT wndProc(HWND, UINT message, WPARAM, LPARAM);
  
      MediaPlayerPrivateFullscreenClient* m_client;
-#if USE(ACCELERATED_COMPOSITING) && USE(CA)
+#if USE(CA)
      RefPtr<CACFLayerTreeHost> m_layerTreeHost;
      RefPtr<PlatformCALayer> m_rootChild;
  #endif
diff --git a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp b/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp

index d12cc0db20dc82c29a44b4a0352076714b72864c..3185e5b9b77524629f689386531eb8e92c7c34b9 100644 (file)
--- a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp
+++ b/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp
@@ -37,6 +37,7 @@
  #include "GraphicsContext.h"
  #include "MediaPlayerPrivateTaskTimer.h"
  #include "Page.h"
+#include "PlatformCALayerWin.h"
  #include "QTCFDictionary.h"
  #include "QTDecompressionSession.h"
  #include "QTMovie.h"
@@ -48,6 +49,7 @@
  #include "TimeRanges.h"
  #include "Timer.h"
  #include "URL.h"
+#include "WKCAImageQueue.h"
  #include <AssertMacros.h>
  #include <CoreGraphics/CGAffineTransform.h>
  #include <CoreGraphics/CGContext.h>
@@ -61,11 +63,6 @@
  #include <wtf/text/StringBuilder.h>
  #include <wtf/text/StringHash.h>
  
-#if USE(ACCELERATED_COMPOSITING)
-#include "PlatformCALayerWin.h"
-#include "WKCAImageQueue.h"
-#endif
-
  using namespace std;
  
  namespace WebCore {
@@ -88,7 +85,6 @@ private:
      MediaPlayerPrivateQuickTimeVisualContext* m_parent;
  };
  
-#if USE(ACCELERATED_COMPOSITING)
  class MediaPlayerPrivateQuickTimeVisualContext::LayerClient : public PlatformCALayerClient {
  public:
      LayerClient(MediaPlayerPrivateQuickTimeVisualContext* parent) : m_parent(parent) {}
@@ -137,7 +133,6 @@ void MediaPlayerPrivateQuickTimeVisualContext::LayerClient::platformCALayerLayou
      m_parent->m_qtVideoLayer->setBounds(videoBounds);
      m_parent->m_qtVideoLayer->setPosition(position);
  }
-#endif
  
  class MediaPlayerPrivateQuickTimeVisualContext::VisualContextClient : public QTMovieVisualContextClient {
  public:
@@ -175,10 +170,8 @@ MediaPlayerPrivateQuickTimeVisualContext::MediaPlayerPrivateQuickTimeVisualConte
      , m_visible(false)
      , m_newFrameAvailable(false)
      , m_movieClient(adoptPtr(new MediaPlayerPrivateQuickTimeVisualContext::MovieClient(this)))
-#if USE(ACCELERATED_COMPOSITING)
      , m_layerClient(adoptPtr(new MediaPlayerPrivateQuickTimeVisualContext::LayerClient(this)))
      , m_movieTransform(CGAffineTransformIdentity)
-#endif
      , m_visualContextClient(adoptPtr(new MediaPlayerPrivateQuickTimeVisualContext::VisualContextClient(this)))
      , m_delayingLoad(false)
      , m_privateBrowsing(false)
@@ -195,11 +188,10 @@ MediaPlayerPrivateQuickTimeVisualContext::~MediaPlayerPrivateQuickTimeVisualCont
  
  bool MediaPlayerPrivateQuickTimeVisualContext::supportsFullscreen() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      Document* document = m_player->mediaPlayerClient()->mediaPlayerOwningDocument(); 
      if (document)
          return document->settings()->acceleratedCompositingEnabled();
-#endif
+
      return false;
  }
  
@@ -210,13 +202,11 @@ PlatformMedia MediaPlayerPrivateQuickTimeVisualContext::platformMedia() const
      p.media.qtMovieVisualContext = m_visualContext.get();
      return p;
  }
-#if USE(ACCELERATED_COMPOSITING)
  
  PlatformLayer* MediaPlayerPrivateQuickTimeVisualContext::platformLayer() const
  {
      return m_transformLayer ? m_transformLayer->platformLayer() : 0;
  }
-#endif
  
  String MediaPlayerPrivateQuickTimeVisualContext::rfc2616DateStringFromTime(CFAbsoluteTime time)
  {
@@ -498,13 +488,9 @@ IntSize MediaPlayerPrivateQuickTimeVisualContext::naturalSize() const
      int width;
      int height;
      m_movie->getNaturalSize(width, height);
-#if USE(ACCELERATED_COMPOSITING)
      CGSize originalSize = {width, height};
      CGSize transformedSize = CGSizeApplyAffineTransform(originalSize, m_movieTransform);
      return IntSize(abs(transformedSize.width), abs(transformedSize.height));
-#else
-    return IntSize(width, height);
-#endif
  }
  
  bool MediaPlayerPrivateQuickTimeVisualContext::hasVideo() const
@@ -740,7 +726,6 @@ void MediaPlayerPrivateQuickTimeVisualContext::paint(GraphicsContext* p, const I
  
      QTPixelBuffer buffer = m_visualContext->imageForTime(0);
      if (buffer.pixelBufferRef()) {
-#if USE(ACCELERATED_COMPOSITING)
          if (m_qtVideoLayer) {
              // We are probably being asked to render the video into a canvas, but 
              // there's a good chance the QTPixelBuffer is not ARGB and thus can't be
@@ -755,7 +740,7 @@ void MediaPlayerPrivateQuickTimeVisualContext::paint(GraphicsContext* p, const I
                  buffer = m_decompressionSession->decompress(buffer);
              }
          }
-#endif
+
          CGImageRef image = CreateCGImageFromPixelBuffer(buffer);
          
          CGContextRef context = p->platformContext();
@@ -807,7 +792,6 @@ static CFDictionaryRef QTCFDictionaryCreateWithDataCallback(CFAllocatorRef alloc
  
  static CGImageRef CreateCGImageFromPixelBuffer(QTPixelBuffer buffer)
  {
-#if USE(ACCELERATED_COMPOSITING)
      CGDataProviderRef provider = 0;
      CGColorSpaceRef colorSpace = 0;
      CGImageRef image = 0;
@@ -856,9 +840,6 @@ Bail:
          CGColorSpaceRelease(colorSpace);
   
      return image;
-#else
-    return 0;
-#endif
  }
  
  
@@ -867,7 +848,6 @@ void MediaPlayerPrivateQuickTimeVisualContext::retrieveCurrentImage()
      if (!m_visualContext)
          return;
  
-#if USE(ACCELERATED_COMPOSITING)
      if (m_qtVideoLayer) {
  
          QTPixelBuffer buffer = m_visualContext->imageForTime(0);
@@ -911,7 +891,6 @@ void MediaPlayerPrivateQuickTimeVisualContext::retrieveCurrentImage()
              layer->setNeedsCommit();
          }
      } else
-#endif
          m_player->repaint();
  
      m_visualContext->task();
@@ -1081,10 +1060,8 @@ MediaPlayerPrivateQuickTimeVisualContext::MediaRenderingMode MediaPlayerPrivateQ
      if (!m_movie)
          return MediaRenderingNone;
  
-#if USE(ACCELERATED_COMPOSITING)
      if (m_qtVideoLayer)
          return MediaRenderingMovieLayer;
-#endif
  
      return m_visualContext ? MediaRenderingSoftwareRenderer : MediaRenderingNone;
  }
@@ -1094,10 +1071,8 @@ MediaPlayerPrivateQuickTimeVisualContext::MediaRenderingMode MediaPlayerPrivateQ
      if (!m_player->frameView() || !m_movie)
          return MediaRenderingNone;
  
-#if USE(ACCELERATED_COMPOSITING)
      if (supportsAcceleratedRendering() && m_player->mediaPlayerClient()->mediaPlayerRenderingCanBeAccelerated(m_player))
          return MediaRenderingMovieLayer;
-#endif
  
      return MediaRenderingSoftwareRenderer;
  }
@@ -1107,10 +1082,6 @@ void MediaPlayerPrivateQuickTimeVisualContext::setUpVideoRendering()
      MediaRenderingMode currentMode = currentRenderingMode();
      MediaRenderingMode preferredMode = preferredRenderingMode();
  
-#if !USE(ACCELERATED_COMPOSITING)
-    ASSERT(preferredMode != MediaRenderingMovieLayer);
-#endif
-
      if (currentMode == preferredMode && currentMode != MediaRenderingNone)
          return;
  
@@ -1120,10 +1091,8 @@ void MediaPlayerPrivateQuickTimeVisualContext::setUpVideoRendering()
      if (preferredMode == MediaRenderingMovieLayer)
          createLayerForMovie();
  
-#if USE(ACCELERATED_COMPOSITING)
      if (currentMode == MediaRenderingMovieLayer || preferredMode == MediaRenderingMovieLayer)
          m_player->mediaPlayerClient()->mediaPlayerRenderingModeChanged(m_player);
-#endif
  
      QTPixelBuffer::Type contextType = requiredDllsAvailable() && preferredMode == MediaRenderingMovieLayer ? QTPixelBuffer::ConfigureForCAImageQueue : QTPixelBuffer::ConfigureForCGImage;
      m_visualContext = QTMovieVisualContext::create(m_visualContextClient.get(), contextType);
@@ -1132,26 +1101,19 @@ void MediaPlayerPrivateQuickTimeVisualContext::setUpVideoRendering()
  
  void MediaPlayerPrivateQuickTimeVisualContext::tearDownVideoRendering()
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (m_qtVideoLayer)
          destroyLayerForMovie();
-#endif
  
      m_visualContext = 0;
  }
  
  bool MediaPlayerPrivateQuickTimeVisualContext::hasSetUpVideoRendering() const
  {
-#if USE(ACCELERATED_COMPOSITING)
      return m_qtVideoLayer || (currentRenderingMode() != MediaRenderingMovieLayer && m_visualContext);
-#else
-    return true;
-#endif
  }
  
  void MediaPlayerPrivateQuickTimeVisualContext::retrieveAndResetMovieTransform()
  {
-#if USE(ACCELERATED_COMPOSITING)
      // First things first, reset the total movie transform so that
      // we can bail out early:
      m_movieTransform = CGAffineTransformIdentity;
@@ -1180,12 +1142,10 @@ void MediaPlayerPrivateQuickTimeVisualContext::retrieveAndResetMovieTransform()
      // Multiply the two transforms together, taking care to 
      // do so in the correct order, track * movie = final:
      m_movieTransform = CGAffineTransformConcat(trackTransform, movieTransform);
-#endif
  }
  
  void MediaPlayerPrivateQuickTimeVisualContext::createLayerForMovie()
  {
-#if USE(ACCELERATED_COMPOSITING)
      ASSERT(supportsAcceleratedRendering());
  
      if (!m_movie || m_qtVideoLayer)
@@ -1220,7 +1180,6 @@ void MediaPlayerPrivateQuickTimeVisualContext::createLayerForMovie()
      m_transformLayer->appendSublayer(m_qtVideoLayer.get());
      m_transformLayer->setNeedsLayout();
      // The layer will get hooked up via RenderLayerBacking::updateGraphicsLayerConfiguration().
-#endif
  
      // Fill the newly created layer with image data, so we're not looking at 
      // an empty layer until the next time a new image is available, which could
@@ -1231,7 +1190,6 @@ void MediaPlayerPrivateQuickTimeVisualContext::createLayerForMovie()
  
  void MediaPlayerPrivateQuickTimeVisualContext::destroyLayerForMovie()
  {
-#if USE(ACCELERATED_COMPOSITING)
      if (m_qtVideoLayer) {
          m_qtVideoLayer->removeFromSuperlayer();
          m_qtVideoLayer = 0;
@@ -1242,10 +1200,8 @@ void MediaPlayerPrivateQuickTimeVisualContext::destroyLayerForMovie()
  
      if (m_imageQueue)
          m_imageQueue = nullptr;
-#endif
  }
  
-#if USE(ACCELERATED_COMPOSITING)
  bool MediaPlayerPrivateQuickTimeVisualContext::supportsAcceleratedRendering() const
  {
      return isReadyForRendering();
@@ -1263,9 +1219,6 @@ void MediaPlayerPrivateQuickTimeVisualContext::setPrivateBrowsingMode(bool priva
      if (m_movie)
          m_movie->setPrivateBrowsingMode(m_privateBrowsing);
  }
-    
-#endif
-
  
  }
  
diff --git a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h b/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h

index 2cae9171dc935c0c8a7ed3f27c2a1bb888176707..c92b496bc46f16a7abfdf8884b3d0bf63f49ffb7 100644 (file)
--- a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h
+++ b/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h
@@ -49,11 +49,8 @@ nam
author	abucur@adobe.com <abucur@adobe.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
	Thu, 30 Jan 2014 10:22:36 +0000 (10:22 +0000)
committer	abucur@adobe.com <abucur@adobe.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
	Thu, 30 Jan 2014 10:22:36 +0000 (10:22 +0000)