Diff
Modified: trunk/Source/WebKit2/ChangeLog (176933 => 176934)
--- trunk/Source/WebKit2/ChangeLog 2014-12-07 23:25:59 UTC (rev 176933)
+++ trunk/Source/WebKit2/ChangeLog 2014-12-08 03:50:34 UTC (rev 176934)
@@ -1,3 +1,39 @@
+2014-12-07 Gwang Yoon Hwang <[email protected]>
+
+ [CoordinatedGraphics] Change the namespace of CoordinatedBackingStore and CoordinatedGraphicsScene
+ https://bugs.webkit.org/show_bug.cgi?id=139372
+
+ Reviewed by Gyuyoung Kim.
+
+ CoordinatedBackingStore and CoordinatedGraphicsScene should be declared in the WebKit namespace
+ instead of WebCore namespace.
+
+ * UIProcess/API/CoordinatedGraphics/WKCoordinatedScene.cpp:
+ * UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp:
+ * UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h:
+ (WebKit::CoordinatedBackingStoreTile::CoordinatedBackingStoreTile):
+ (WebKit::CoordinatedBackingStore::rect):
+ (WebCore::CoordinatedBackingStoreTile::CoordinatedBackingStoreTile): Deleted.
+ (WebCore::CoordinatedBackingStore::rect): Deleted.
+ * UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp:
+ * UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h:
+ (WebKit::CoordinatedGraphicsScene::setViewBackgroundColor):
+ (WebKit::CoordinatedGraphicsScene::viewBackgroundColor):
+ (WebKit::CoordinatedGraphicsScene::layerByID):
+ (WebKit::CoordinatedGraphicsScene::rootLayer):
+ (WebCore::CoordinatedGraphicsScene::setViewBackgroundColor): Deleted.
+ (WebCore::CoordinatedGraphicsScene::viewBackgroundColor): Deleted.
+ (WebCore::CoordinatedGraphicsScene::layerByID): Deleted.
+ (WebCore::CoordinatedGraphicsScene::rootLayer): Deleted.
+ * UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.h:
+ (WebKit::CoordinatedLayerTreeHostProxy::coordinatedGraphicsScene):
+ * UIProcess/CoordinatedGraphics/WKCoordinatedSceneAPICast.h:
+ (WebKit::toImpl):
+ (WebKit::toAPI):
+ (toImpl): Deleted.
+ (toAPI): Deleted.
+ * UIProcess/CoordinatedGraphics/WebView.h:
+
2014-12-07 Dan Bernstein <[email protected]>
Introduce and deploy a function that allocates and returns an instance of a soft-linked class
Modified: trunk/Source/WebKit2/UIProcess/API/CoordinatedGraphics/WKCoordinatedScene.cpp (176933 => 176934)
--- trunk/Source/WebKit2/UIProcess/API/CoordinatedGraphics/WKCoordinatedScene.cpp 2014-12-07 23:25:59 UTC (rev 176933)
+++ trunk/Source/WebKit2/UIProcess/API/CoordinatedGraphics/WKCoordinatedScene.cpp 2014-12-08 03:50:34 UTC (rev 176934)
@@ -34,6 +34,8 @@
#include "WKCoordinatedSceneAPICast.h"
#include <WebCore/TextureMapperLayer.h>
+using namespace WebKit;
+
WK_EXPORT WKCoordinatedSceneLayer WKCoordinatedSceneFindScrollableContentsLayerAt(WKCoordinatedScene scene, WKPoint point)
{
return toAPI(toImpl(scene)->findScrollableContentsLayerAt(WebCore::FloatPoint(point.x, point.y)));
Modified: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp (176933 => 176934)
--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp 2014-12-07 23:25:59 UTC (rev 176933)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp 2014-12-08 03:50:34 UTC (rev 176934)
@@ -21,13 +21,15 @@
#include "CoordinatedBackingStore.h"
#if USE(COORDINATED_GRAPHICS)
-#include "GraphicsLayer.h"
-#include "TextureMapper.h"
-#include "TextureMapperGL.h"
#include <WebCore/CoordinatedSurface.h>
+#include <WebCore/GraphicsLayer.h>
+#include <WebCore/TextureMapper.h>
+#include <WebCore/TextureMapperGL.h>
-namespace WebCore {
+using namespace WebCore;
+namespace WebKit {
+
void CoordinatedBackingStoreTile::swapBuffers(TextureMapper* textureMapper)
{
if (!m_surface)
Modified: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h (176933 => 176934)
--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h 2014-12-07 23:25:59 UTC (rev 176933)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h 2014-12-08 03:50:34 UTC (rev 176934)
@@ -22,68 +22,71 @@
#if USE(COORDINATED_GRAPHICS)
-#include "TextureMapper.h"
-#include "TextureMapperBackingStore.h"
-#include "TextureMapperTile.h"
+#include <WebCore/TextureMapper.h>
+#include <WebCore/TextureMapperBackingStore.h>
+#include <WebCore/TextureMapperTile.h>
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
+
namespace WebCore {
-
class CoordinatedSurface;
+}
-class CoordinatedBackingStoreTile : public TextureMapperTile {
+namespace WebKit {
+
+class CoordinatedBackingStoreTile : public WebCore::TextureMapperTile {
public:
explicit CoordinatedBackingStoreTile(float scale = 1)
- : TextureMapperTile(FloatRect())
+ : WebCore::TextureMapperTile(WebCore::FloatRect())
, m_scale(scale)
{
}
inline float scale() const { return m_scale; }
- void swapBuffers(TextureMapper*);
- void setBackBuffer(const IntRect&, const IntRect&, PassRefPtr<CoordinatedSurface> buffer, const IntPoint&);
+ void swapBuffers(WebCore::TextureMapper*);
+ void setBackBuffer(const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<WebCore::CoordinatedSurface> buffer, const WebCore::IntPoint&);
private:
- RefPtr<CoordinatedSurface> m_surface;
- IntRect m_sourceRect;
- IntRect m_tileRect;
- IntPoint m_surfaceOffset;
+ RefPtr<WebCore::CoordinatedSurface> m_surface;
+ WebCore::IntRect m_sourceRect;
+ WebCore::IntRect m_tileRect;
+ WebCore::IntPoint m_surfaceOffset;
float m_scale;
};
-class CoordinatedBackingStore : public TextureMapperBackingStore {
+class CoordinatedBackingStore : public WebCore::TextureMapperBackingStore {
public:
void createTile(uint32_t tileID, float);
void removeTile(uint32_t tileID);
void removeAllTiles();
- void updateTile(uint32_t tileID, const IntRect&, const IntRect&, PassRefPtr<CoordinatedSurface>, const IntPoint&);
+ void updateTile(uint32_t tileID, const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<WebCore::CoordinatedSurface>, const WebCore::IntPoint&);
static PassRefPtr<CoordinatedBackingStore> create() { return adoptRef(new CoordinatedBackingStore); }
- void commitTileOperations(TextureMapper*);
- PassRefPtr<BitmapTexture> texture() const;
- void setSize(const FloatSize&);
- virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float);
- virtual void drawBorder(TextureMapper*, const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) override;
- virtual void drawRepaintCounter(TextureMapper*, int repaintCount, const Color&, const FloatRect&, const TransformationMatrix&) override;
+ void commitTileOperations(WebCore::TextureMapper*);
+ PassRefPtr<WebCore::BitmapTexture> texture() const;
+ void setSize(const WebCore::FloatSize&);
+ virtual void paintToTextureMapper(WebCore::TextureMapper*, const WebCore::FloatRect&, const WebCore::TransformationMatrix&, float);
+ virtual void drawBorder(WebCore::TextureMapper*, const WebCore::Color&, float borderWidth, const WebCore::FloatRect&, const WebCore::TransformationMatrix&) override;
+ virtual void drawRepaintCounter(WebCore::TextureMapper*, int repaintCount, const WebCore::Color&, const WebCore::FloatRect&, const WebCore::TransformationMatrix&) override;
private:
CoordinatedBackingStore()
: m_scale(1.)
{ }
- void paintTilesToTextureMapper(Vector<TextureMapperTile*>&, TextureMapper*, const TransformationMatrix&, float, const FloatRect&);
- TransformationMatrix adjustedTransformForRect(const FloatRect&);
- FloatRect rect() const { return FloatRect(FloatPoint::zero(), m_size); }
+ void paintTilesToTextureMapper(Vector<WebCore::TextureMapperTile*>&, WebCore::TextureMapper*, const WebCore::TransformationMatrix&, float, const WebCore::FloatRect&);
+ WebCore::TransformationMatrix adjustedTransformForRect(const WebCore::FloatRect&);
+ WebCore::FloatRect rect() const { return WebCore::FloatRect(WebCore::FloatPoint::zero(), m_size); }
typedef HashMap<uint32_t, CoordinatedBackingStoreTile> CoordinatedBackingStoreTileMap;
CoordinatedBackingStoreTileMap m_tiles;
HashSet<uint32_t> m_tilesToRemove;
// FIXME: m_pendingSize should be removed after the following bug is fixed: https://bugs.webkit.org/show_bug.cgi?id=108294
- FloatSize m_pendingSize;
- FloatSize m_size;
+ WebCore::FloatSize m_pendingSize;
+ WebCore::FloatSize m_size;
float m_scale;
};
-} // namespace WebCore
+} // namespace WebKit
#endif // USE(COORDINATED_GRAPHICS)
Modified: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp (176933 => 176934)
--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp 2014-12-07 23:25:59 UTC (rev 176933)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp 2014-12-08 03:50:34 UTC (rev 176934)
@@ -24,15 +24,17 @@
#include "CoordinatedGraphicsScene.h"
#include "CoordinatedBackingStore.h"
-#include "TextureMapper.h"
-#include "TextureMapperBackingStore.h"
-#include "TextureMapperGL.h"
-#include "TextureMapperLayer.h"
+#include <WebCore/TextureMapper.h>
+#include <WebCore/TextureMapperBackingStore.h>
+#include <WebCore/TextureMapperGL.h>
+#include <WebCore/TextureMapperLayer.h>
#include <wtf/Atomics.h>
#include <wtf/MainThread.h>
-namespace WebCore {
+using namespace WebCore;
+namespace WebKit {
+
void CoordinatedGraphicsScene::dispatchOnMainThread(std::function<void()> function)
{
if (isMainThread())
@@ -709,6 +711,6 @@
return rootLayer() ? rootLayer()->findScrollableContentsLayerAt(point) : 0;
}
-} // namespace WebCore
+} // namespace WebKit
#endif // USE(COORDINATED_GRAPHICS)
Modified: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h (176933 => 176934)
--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h 2014-12-07 23:25:59 UTC (rev 176933)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h 2014-12-08 03:50:34 UTC (rev 176934)
@@ -22,29 +22,29 @@
#define CoordinatedGraphicsScene_h
#if USE(COORDINATED_GRAPHICS)
-#include "GraphicsContext.h"
-#include "GraphicsLayer.h"
-#include "GraphicsLayerAnimation.h"
-#include "GraphicsSurface.h"
-#include "IntRect.h"
-#include "IntSize.h"
-#include "TextureMapper.h"
-#include "TextureMapperBackingStore.h"
-#include "TextureMapperFPSCounter.h"
-#include "TextureMapperLayer.h"
-#include "Timer.h"
#include <WebCore/CoordinatedGraphicsState.h>
#include <WebCore/CoordinatedSurface.h>
+#include <WebCore/GraphicsContext.h>
+#include <WebCore/GraphicsLayer.h>
+#include <WebCore/GraphicsLayerAnimation.h>
+#include <WebCore/IntRect.h>
+#include <WebCore/IntSize.h>
+#include <WebCore/TextureMapper.h>
+#include <WebCore/TextureMapperBackingStore.h>
+#include <WebCore/TextureMapperFPSCounter.h>
+#include <WebCore/TextureMapperLayer.h>
+#include <WebCore/Timer.h>
#include <functional>
#include <wtf/HashSet.h>
#include <wtf/ThreadingPrimitives.h>
#include <wtf/Vector.h>
#if USE(GRAPHICS_SURFACE)
-#include "TextureMapperSurfaceBackingStore.h"
+#include <WebCore/GraphicsSurface.h>
+#include <WebCore/TextureMapperSurfaceBackingStore.h>
#endif
-namespace WebCore {
+namespace WebKit {
class CoordinatedBackingStore;
@@ -54,21 +54,21 @@
virtual void purgeBackingStores() = 0;
virtual void renderNextFrame() = 0;
virtual void updateViewport() = 0;
- virtual void commitScrollOffset(uint32_t layerID, const IntSize& offset) = 0;
+ virtual void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset) = 0;
};
-class CoordinatedGraphicsScene : public ThreadSafeRefCounted<CoordinatedGraphicsScene>, public TextureMapperLayer::ScrollingClient {
+class CoordinatedGraphicsScene : public ThreadSafeRefCounted<CoordinatedGraphicsScene>, public WebCore::TextureMapperLayer::ScrollingClient {
public:
explicit CoordinatedGraphicsScene(CoordinatedGraphicsSceneClient*);
virtual ~CoordinatedGraphicsScene();
- void paintToCurrentGLContext(const TransformationMatrix&, float, const FloatRect&, const Color& backgroundColor, bool drawsBackground, const FloatPoint&, TextureMapper::PaintFlags = 0);
- void paintToGraphicsContext(PlatformGraphicsContext*, const Color& backgroundColor, bool drawsBackground);
+ void paintToCurrentGLContext(const WebCore::TransformationMatrix&, float, const WebCore::FloatRect&, const WebCore::Color& backgroundColor, bool drawsBackground, const WebCore::FloatPoint&, WebCore::TextureMapper::PaintFlags = 0);
+ void paintToGraphicsContext(PlatformGraphicsContext*, const WebCore::Color& backgroundColor, bool drawsBackground);
void detach();
void appendUpdate(std::function<void()>);
WebCore::TextureMapperLayer* findScrollableContentsLayerAt(const WebCore::FloatPoint&);
- virtual void commitScrollOffset(uint32_t layerID, const IntSize& offset);
+ virtual void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset);
// The painting thread must lock the main thread to use below two methods, because two methods access members that the main thread manages. See m_client.
// Currently, QQuickWebPage::updatePaintNode() locks the main thread before calling both methods.
@@ -77,113 +77,113 @@
bool isActive() const { return m_isActive; }
void setActive(bool);
- void commitSceneState(const CoordinatedGraphicsState&);
+ void commitSceneState(const WebCore::CoordinatedGraphicsState&);
- void setViewBackgroundColor(const Color& color) { m_viewBackgroundColor = color; }
- Color viewBackgroundColor() const { return m_viewBackgroundColor; }
+ void setViewBackgroundColor(const WebCore::Color& color) { m_viewBackgroundColor = color; }
+ WebCore::Color viewBackgroundColor() const { return m_viewBackgroundColor; }
private:
- void setRootLayerID(CoordinatedLayerID);
- void createLayers(const Vector<CoordinatedLayerID>&);
- void deleteLayers(const Vector<CoordinatedLayerID>&);
- void setLayerState(CoordinatedLayerID, const CoordinatedGraphicsLayerState&);
- void setLayerChildrenIfNeeded(TextureMapperLayer*, const CoordinatedGraphicsLayerState&);
- void updateTilesIfNeeded(TextureMapperLayer*, const CoordinatedGraphicsLayerState&);
- void createTilesIfNeeded(TextureMapperLayer*, const CoordinatedGraphicsLayerState&);
- void removeTilesIfNeeded(TextureMapperLayer*, const CoordinatedGraphicsLayerState&);
- void setLayerFiltersIfNeeded(TextureMapperLayer*, const CoordinatedGraphicsLayerState&);
- void setLayerAnimationsIfNeeded(TextureMapperLayer*, const CoordinatedGraphicsLayerState&);
+ void setRootLayerID(WebCore::CoordinatedLayerID);
+ void createLayers(const Vector<WebCore::CoordinatedLayerID>&);
+ void deleteLayers(const Vector<WebCore::CoordinatedLayerID>&);
+ void setLayerState(WebCore::CoordinatedLayerID, const WebCore::CoordinatedGraphicsLayerState&);
+ void setLayerChildrenIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void updateTilesIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void createTilesIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void removeTilesIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void setLayerFiltersIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void setLayerAnimationsIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
#if USE(GRAPHICS_SURFACE)
- void createPlatformLayerIfNeeded(TextureMapperLayer*, const CoordinatedGraphicsLayerState&);
- void syncPlatformLayerIfNeeded(TextureMapperLayer*, const CoordinatedGraphicsLayerState&);
- void destroyPlatformLayerIfNeeded(TextureMapperLayer*, const CoordinatedGraphicsLayerState&);
+ void createPlatformLayerIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void syncPlatformLayerIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void destroyPlatformLayerIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
#endif
- void setLayerRepaintCountIfNeeded(TextureMapperLayer*, const CoordinatedGraphicsLayerState&);
+ void setLayerRepaintCountIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
- void syncUpdateAtlases(const CoordinatedGraphicsState&);
- void createUpdateAtlas(uint32_t atlasID, PassRefPtr<CoordinatedSurface>);
+ void syncUpdateAtlases(const WebCore::CoordinatedGraphicsState&);
+ void createUpdateAtlas(uint32_t atlasID, PassRefPtr<WebCore::CoordinatedSurface>);
void removeUpdateAtlas(uint32_t atlasID);
- void syncImageBackings(const CoordinatedGraphicsState&);
- void createImageBacking(CoordinatedImageBackingID);
- void updateImageBacking(CoordinatedImageBackingID, PassRefPtr<CoordinatedSurface>);
- void clearImageBackingContents(CoordinatedImageBackingID);
- void removeImageBacking(CoordinatedImageBackingID);
+ void syncImageBackings(const WebCore::CoordinatedGraphicsState&);
+ void createImageBacking(WebCore::CoordinatedImageBackingID);
+ void updateImageBacking(WebCore::CoordinatedImageBackingID, PassRefPtr<WebCore::CoordinatedSurface>);
+ void clearImageBackingContents(WebCore::CoordinatedImageBackingID);
+ void removeImageBacking(WebCore::CoordinatedImageBackingID);
- TextureMapperLayer* layerByID(CoordinatedLayerID id)
+ WebCore::TextureMapperLayer* layerByID(WebCore::CoordinatedLayerID id)
{
ASSERT(m_layers.contains(id));
- ASSERT(id != InvalidCoordinatedLayerID);
+ ASSERT(id != WebCore::InvalidCoordinatedLayerID);
return m_layers.get(id);
}
- TextureMapperLayer* getLayerByIDIfExists(CoordinatedLayerID);
- TextureMapperLayer* rootLayer() { return m_rootLayer.get(); }
+ WebCore::TextureMapperLayer* getLayerByIDIfExists(WebCore::CoordinatedLayerID);
+ WebCore::TextureMapperLayer* rootLayer() { return m_rootLayer.get(); }
void syncRemoteContent();
- void adjustPositionForFixedLayers(const FloatPoint& contentPosition);
+ void adjustPositionForFixedLayers(const WebCore::FloatPoint& contentPosition);
void dispatchOnMainThread(std::function<void()>);
void updateViewport();
void renderNextFrame();
void purgeBackingStores();
- void createLayer(CoordinatedLayerID);
- void deleteLayer(CoordinatedLayerID);
+ void createLayer(WebCore::CoordinatedLayerID);
+ void deleteLayer(WebCore::CoordinatedLayerID);
- void assignImageBackingToLayer(TextureMapperLayer*, CoordinatedImageBackingID);
+ void assignImageBackingToLayer(WebCore::TextureMapperLayer*, WebCore::CoordinatedImageBackingID);
void removeReleasedImageBackingsIfNeeded();
void ensureRootLayer();
void commitPendingBackingStoreOperations();
- void prepareContentBackingStore(TextureMapperLayer*);
- void createBackingStoreIfNeeded(TextureMapperLayer*);
- void removeBackingStoreIfNeeded(TextureMapperLayer*);
- void resetBackingStoreSizeToLayerSize(TextureMapperLayer*);
+ void prepareContentBackingStore(WebCore::TextureMapperLayer*);
+ void createBackingStoreIfNeeded(WebCore::TextureMapperLayer*);
+ void removeBackingStoreIfNeeded(WebCore::TextureMapperLayer*);
+ void resetBackingStoreSizeToLayerSize(WebCore::TextureMapperLayer*);
- void dispatchCommitScrollOffset(uint32_t layerID, const IntSize& offset);
+ void dispatchCommitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset);
// Render queue can be accessed ony from main thread or updatePaintNode call stack!
Vector<std::function<void()>> m_renderQueue;
Mutex m_renderQueueMutex;
- std::unique_ptr<TextureMapper> m_textureMapper;
+ std::unique_ptr<WebCore::TextureMapper> m_textureMapper;
- typedef HashMap<CoordinatedImageBackingID, RefPtr<CoordinatedBackingStore> > ImageBackingMap;
+ typedef HashMap<WebCore::CoordinatedImageBackingID, RefPtr<CoordinatedBackingStore>> ImageBackingMap;
ImageBackingMap m_imageBackings;
- Vector<RefPtr<CoordinatedBackingStore> > m_releasedImageBackings;
+ Vector<RefPtr<CoordinatedBackingStore>> m_releasedImageBackings;
- typedef HashMap<TextureMapperLayer*, RefPtr<CoordinatedBackingStore> > BackingStoreMap;
+ typedef HashMap<WebCore::TextureMapperLayer*, RefPtr<CoordinatedBackingStore>> BackingStoreMap;
BackingStoreMap m_backingStores;
- HashSet<RefPtr<CoordinatedBackingStore> > m_backingStoresWithPendingBuffers;
+ HashSet<RefPtr<CoordinatedBackingStore>> m_backingStoresWithPendingBuffers;
#if USE(GRAPHICS_SURFACE)
- typedef HashMap<TextureMapperLayer*, RefPtr<TextureMapperSurfaceBackingStore> > SurfaceBackingStoreMap;
+ typedef HashMap<WebCore::TextureMapperLayer*, RefPtr<WebCore::TextureMapperSurfaceBackingStore>> SurfaceBackingStoreMap;
SurfaceBackingStoreMap m_surfaceBackingStores;
#endif
- typedef HashMap<uint32_t /* atlasID */, RefPtr<CoordinatedSurface> > SurfaceMap;
+ typedef HashMap<uint32_t /* atlasID */, RefPtr<WebCore::CoordinatedSurface>> SurfaceMap;
SurfaceMap m_surfaces;
// Below two members are accessed by only the main thread. The painting thread must lock the main thread to access both members.
CoordinatedGraphicsSceneClient* m_client;
bool m_isActive;
- std::unique_ptr<TextureMapperLayer> m_rootLayer;
+ std::unique_ptr<WebCore::TextureMapperLayer> m_rootLayer;
- typedef HashMap<CoordinatedLayerID, std::unique_ptr<TextureMapperLayer>> LayerMap;
+ typedef HashMap<WebCore::CoordinatedLayerID, std::unique_ptr<WebCore::TextureMapperLayer>> LayerMap;
LayerMap m_layers;
- typedef HashMap<CoordinatedLayerID, TextureMapperLayer*> LayerRawPtrMap;
+ typedef HashMap<WebCore::CoordinatedLayerID, WebCore::TextureMapperLayer*> LayerRawPtrMap;
LayerRawPtrMap m_fixedLayers;
- CoordinatedLayerID m_rootLayerID;
- FloatPoint m_scrollPosition;
- FloatPoint m_renderedContentsScrollPosition;
- Color m_viewBackgroundColor;
+ WebCore::CoordinatedLayerID m_rootLayerID;
+ WebCore::FloatPoint m_scrollPosition;
+ WebCore::FloatPoint m_renderedContentsScrollPosition;
+ WebCore::Color m_viewBackgroundColor;
- TextureMapperFPSCounter m_fpsCounter;
+ WebCore::TextureMapperFPSCounter m_fpsCounter;
};
-} // namespace WebCore
+} // namespace WebKit
#endif // USE(COORDINATED_GRAPHICS)
Modified: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.h (176933 => 176934)
--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.h 2014-12-07 23:25:59 UTC (rev 176933)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.h 2014-12-08 03:50:34 UTC (rev 176934)
@@ -37,7 +37,7 @@
class CoordinatedDrawingAreaProxy;
-class CoordinatedLayerTreeHostProxy : public WebCore::CoordinatedGraphicsSceneClient, public IPC::MessageReceiver {
+class CoordinatedLayerTreeHostProxy : public CoordinatedGraphicsSceneClient, public IPC::MessageReceiver {
WTF_MAKE_NONCOPYABLE(CoordinatedLayerTreeHostProxy);
WTF_MAKE_FAST_ALLOCATED;
public:
@@ -47,7 +47,7 @@
void commitCoordinatedGraphicsState(const WebCore::CoordinatedGraphicsState&);
void setVisibleContentsRect(const WebCore::FloatRect&, const WebCore::FloatPoint& trajectoryVector);
- WebCore::CoordinatedGraphicsScene* coordinatedGraphicsScene() const { return m_scene.get(); }
+ CoordinatedGraphicsScene* coordinatedGraphicsScene() const { return m_scene.get(); }
virtual void updateViewport() override;
virtual void renderNextFrame() override;
@@ -62,7 +62,7 @@
virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) override;
CoordinatedDrawingAreaProxy* m_drawingAreaProxy;
- RefPtr<WebCore::CoordinatedGraphicsScene> m_scene;
+ RefPtr<CoordinatedGraphicsScene> m_scene;
WebCore::FloatRect m_lastSentVisibleRect;
WebCore::FloatPoint m_lastSentTrajectoryVector;
};
Modified: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/WKCoordinatedSceneAPICast.h (176933 => 176934)
--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/WKCoordinatedSceneAPICast.h 2014-12-07 23:25:59 UTC (rev 176933)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/WKCoordinatedSceneAPICast.h 2014-12-08 03:50:34 UTC (rev 176934)
@@ -31,18 +31,19 @@
#include <WebKit/WKCoordinatedScene.h>
namespace WebCore {
+class TextureMapperLayer;
+}
+namespace WebKit {
+
class CoordinatedGraphicsScene;
-class TextureMapperLayer;
-} // namespace WebCore
-
-inline WebCore::CoordinatedGraphicsScene* toImpl(WKCoordinatedScene scene)
+inline WebKit::CoordinatedGraphicsScene* toImpl(WKCoordinatedScene scene)
{
- return reinterpret_cast<WebCore::CoordinatedGraphicsScene*>(scene);
+ return reinterpret_cast<WebKit::CoordinatedGraphicsScene*>(scene);
}
-inline WKCoordinatedScene toAPI(WebCore::CoordinatedGraphicsScene* scene)
+inline WKCoordinatedScene toAPI(WebKit::CoordinatedGraphicsScene* scene)
{
return reinterpret_cast<WKCoordinatedScene>(scene);
}
@@ -57,4 +58,6 @@
return reinterpret_cast<WKCoordinatedSceneLayer>(layer);
}
+} // namespace WebKit
+
#endif // WKCoordinatedSceneAPICast_h
Modified: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.h (176933 => 176934)
--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.h 2014-12-07 23:25:59 UTC (rev 176933)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.h 2014-12-08 03:50:34 UTC (rev 176934)
@@ -40,12 +40,9 @@
#include "WebViewClient.h"
#include <WebCore/TransformationMatrix.h>
-namespace WebCore {
+namespace WebKit {
class CoordinatedGraphicsScene;
-}
-namespace WebKit {
-
class WebView : public API::ObjectImpl<API::Object::Type::View>, public PageClient
#if ENABLE(FULLSCREEN_API)
, public WebFullScreenManagerProxyClient
@@ -118,7 +115,7 @@
protected:
WebView(WebContext*, WebPageGroup*);
- WebCore::CoordinatedGraphicsScene* coordinatedGraphicsScene();
+ CoordinatedGraphicsScene* coordinatedGraphicsScene();
void updateViewportSize();
WebCore::FloatSize dipSize() const;
