Merge webkit.org at r60469 : Initial merge by git.

Change-Id: I66a0047aa2af802f66bb0c7f2a8b02247a596234

14 files changed, 738 insertions, 95 deletions

diff --git a/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.cpp b/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.cpp
new file mode 100644
index 0000000..c6be087
--- /dev/null
+++ b/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.cpp
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS “AS IS” 
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "MediaPlayerPrivateFullscreenWindow.h"
+
+#include "IntRect.h"
+#include "WebCoreInstanceHandle.h"
+#include <CoreGraphics/CGColor.h>
+#include <windows.h>
+
+namespace WebCore {
+
+MediaPlayerPrivateFullscreenWindow::MediaPlayerPrivateFullscreenWindow(MediaPlayerPrivateFullscreenClient* client)
+    : m_client(client)
+    , m_hwnd(0)
+#if USE(ACCELERATED_COMPOSITING)
+    , m_layerRenderer(WKCACFLayerRenderer::create(0))
+#endif
+{
+}
+
+MediaPlayerPrivateFullscreenWindow::~MediaPlayerPrivateFullscreenWindow()
+{
+    if (m_hwnd)
+        close();
+}
+
+void MediaPlayerPrivateFullscreenWindow::createWindow(HWND parentHwnd)
+{
+    static ATOM windowAtom;
+    static LPCWSTR windowClassName = L"MediaPlayerPrivateFullscreenWindowClass";
+    if (!windowAtom) {
+        WNDCLASSEX wcex = {0};
+        wcex.cbSize = sizeof(WNDCLASSEX);
+        wcex.style = CS_HREDRAW | CS_VREDRAW;
+        wcex.lpfnWndProc = staticWndProc;
+        wcex.hInstance = instanceHandle();
+        wcex.lpszClassName = windowClassName;
+        windowAtom = ::RegisterClassEx(&wcex);
+    }
+
+    if (m_hwnd)
+        close();
+
+    MONITORINFO mi = {0};
+    mi.cbSize = sizeof(MONITORINFO);
+    if (!GetMonitorInfo(MonitorFromWindow(parentHwnd, MONITOR_DEFAULTTONEAREST), &mi))
+        return;
+
+    IntRect monitorRect = mi.rcMonitor;
+    
+    ::CreateWindowExW(WS_EX_TOOLWINDOW, windowClassName, L"", WS_POPUP | WS_VISIBLE, 
+        monitorRect.x(), monitorRect.y(), monitorRect.width(), monitorRect.height(),
+        parentHwnd, 0, WebCore::instanceHandle(), this);
+    ASSERT(IsWindow(m_hwnd));
+
+    ::SetFocus(m_hwnd);
+}
+
+void MediaPlayerPrivateFullscreenWindow::close()
+{
+    ::DestroyWindow(m_hwnd);
+    ASSERT(!m_hwnd);
+}
+
+#if USE(ACCELERATED_COMPOSITING)
+void MediaPlayerPrivateFullscreenWindow::setRootChildLayer(PassRefPtr<WKCACFLayer> rootChild)
+{
+    if (m_rootChild == rootChild)
+        return;
+
+    if (m_rootChild)
+        m_rootChild->removeFromSuperlayer();
+
+    m_rootChild = rootChild;
+
+    if (!m_rootChild)
+        return;
+
+    m_layerRenderer->setRootChildLayer(m_rootChild.get());
+    WKCACFLayer* rootLayer = m_rootChild->rootLayer();
+    CGRect rootBounds = m_rootChild->rootLayer()->bounds();
+    m_rootChild->setFrame(rootBounds);
+    m_layerRenderer->setScrollFrame(IntPoint(rootBounds.origin), IntSize(rootBounds.size));
+    m_rootChild->setBackgroundColor(CGColorGetConstantColor(kCGColorBlack));
+#ifndef NDEBUG
+    RetainPtr<CGColorRef> redColor(AdoptCF, CGColorCreateGenericRGB(1, 0, 0, 1));
+    rootLayer->setBackgroundColor(redColor.get());
+#else
+    rootLayer->setBackgroundColor(CGColorGetConstantColor(kCGColorBlack));
+#endif
+}
+#endif
+
+LRESULT MediaPlayerPrivateFullscreenWindow::staticWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    LONG_PTR longPtr = GetWindowLongPtr(hWnd, GWLP_USERDATA);
+
+    if (!longPtr && message == WM_CREATE) {
+        LPCREATESTRUCT lpcs = reinterpret_cast<LPCREATESTRUCT>(lParam);
+        longPtr = reinterpret_cast<LONG_PTR>(lpcs->lpCreateParams);
+        ::SetWindowLongPtr(hWnd, GWLP_USERDATA, longPtr);
+    }
+
+    if (MediaPlayerPrivateFullscreenWindow* window = reinterpret_cast<MediaPlayerPrivateFullscreenWindow*>(longPtr))
+        return window->wndProc(hWnd, message, wParam, lParam);
+
+    return ::DefWindowProc(hWnd, message, wParam, lParam);    
+}
+
+LRESULT MediaPlayerPrivateFullscreenWindow::wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    LRESULT lResult = 0;
+    switch (message) {
+    case WM_CREATE:
+        m_hwnd = hWnd;
+#if USE(ACCELERATED_COMPOSITING)
+        m_layerRenderer->setHostWindow(m_hwnd);
+        m_layerRenderer->createRenderer();
+        if (m_rootChild)
+            m_layerRenderer->setNeedsDisplay();
+#endif
+        break;
+    case WM_DESTROY:
+        m_hwnd = 0;
+#if USE(ACCELERATED_COMPOSITING)
+        m_layerRenderer->destroyRenderer();
+        m_layerRenderer->setHostWindow(0);
+#endif
+        break;
+    case WM_WINDOWPOSCHANGED:
+        {
+            LPWINDOWPOS wp = reinterpret_cast<LPWINDOWPOS>(lParam);
+            if (wp->flags & SWP_NOSIZE)
+                break;
+#if USE(ACCELERATED_COMPOSITING)
+            m_layerRenderer->resize();
+            WKCACFLayer* rootLayer = m_rootChild->rootLayer();
+            CGRect rootBounds = m_rootChild->rootLayer()->bounds();
+            m_rootChild->setFrame(rootBounds);
+            m_rootChild->setNeedsLayout();
+            m_layerRenderer->setScrollFrame(IntPoint(rootBounds.origin), IntSize(rootBounds.size));
+#endif
+        }
+        break;
+    case WM_PAINT:
+#if USE(ACCELERATED_COMPOSITING)
+        m_layerRenderer->renderSoon();
+#endif
+        break;
+    }
+
+    if (m_client)
+        lResult = m_client->fullscreenClientWndProc(hWnd, message, wParam, lParam);
+
+    return lResult;
+}
+
+}
diff --git a/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.h b/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.h
new file mode 100644
index 0000000..d42f7f3
--- /dev/null
+++ b/WebCore/platform/graphics/win/MediaPlayerPrivateFullscreenWindow.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS “AS IS” 
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MediaPlayerPrivateFullscreenWindow_h
+#define MediaPlayerPrivateFullscreenWindow_h
+
+#if USE(ACCELERATED_COMPOSITING)
+#include "WKCACFLayer.h"
+#include "WKCACFLayerRenderer.h"
+#endif
+#include <wtf/OwnPtr.h>
+
+typedef unsigned WPARAM;
+typedef long LPARAM;
+typedef struct HWND__* HWND;
+typedef _W64 long LONG_PTR;
+typedef LONG_PTR LRESULT;
+typedef unsigned int UINT;
+
+namespace WebCore {
+
+class MediaPlayerPrivateFullscreenClient {
+public:
+    virtual LRESULT fullscreenClientWndProc(HWND, UINT message, WPARAM, LPARAM) = 0;
+protected:
+    virtual ~MediaPlayerPrivateFullscreenClient() {} 
+};
+
+class MediaPlayerPrivateFullscreenWindow {
+public:
+    MediaPlayerPrivateFullscreenWindow(MediaPlayerPrivateFullscreenClient*);
+    ~MediaPlayerPrivateFullscreenWindow();
+
+    void createWindow(HWND ownerWindow);
+    void close();
+    
+    HWND hwnd() const { return m_hwnd; }
+
+#if USE(ACCELERATED_COMPOSITING)
+    WKCACFLayerRenderer* layerRenderer() const { return m_layerRenderer.get(); }
+
+    WKCACFLayer* rootChildLayer() const { return m_rootChild.get(); }
+    void setRootChildLayer(PassRefPtr<WKCACFLayer>);
+#endif
+
+private:
+    static LRESULT __stdcall staticWndProc(HWND, UINT message, WPARAM, LPARAM);
+    LRESULT wndProc(HWND, UINT message, WPARAM, LPARAM);
+
+    MediaPlayerPrivateFullscreenClient* m_client;
+#if USE(ACCELERATED_COMPOSITING)
+    OwnPtr<WKCACFLayerRenderer> m_layerRenderer;
+    RefPtr<WKCACFLayer> m_rootChild;
+#endif
+    HWND m_hwnd;
+};
+
+}
+
+#endif
diff --git a/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp b/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp
index e1d457f..aa7bdd4 100644
--- a/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp
+++ b/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp
@@ -40,6 +40,7 @@
 #include "QTMovieTask.h"
 #include "QTMovieVisualContext.h"
 #include "ScrollView.h"
+#include "Settings.h"
 #include "SoftLinking.h"
 #include "StringBuilder.h"
 #include "StringHash.h"
@@ -56,16 +57,15 @@
 #if USE(ACCELERATED_COMPOSITING)
 #include "GraphicsLayerCACF.h"
 #include "WKCACFLayer.h"
+#include "WKCAImageQueue.h"
 #endif
 
 using namespace std;
 
-const CFStringRef kMinQuartzCoreVersion = CFSTR("1.0.43.0");
-const CFStringRef kMinCoreVideoVersion = CFSTR("1.0.0.2");
-
 namespace WebCore {
 
 static CGImageRef CreateCGImageFromPixelBuffer(QTPixelBuffer buffer);
+static bool requiredDllsAvailable();
 
 SOFT_LINK_LIBRARY(Wininet)
 SOFT_LINK(Wininet, InternetSetCookieExW, DWORD, WINAPI, (LPCWSTR lpszUrl, LPCWSTR lpszCookieName, LPCWSTR lpszCookieData, DWORD dwFlags, DWORD_PTR dwReserved), (lpszUrl, lpszCookieName, lpszCookieData, dwFlags, dwReserved))
@@ -144,12 +144,16 @@ MediaPlayerPrivateQuickTimeVisualContext::MediaPlayerPrivateQuickTimeVisualConte
 MediaPlayerPrivateQuickTimeVisualContext::~MediaPlayerPrivateQuickTimeVisualContext()
 {
     tearDownVideoRendering();
-    m_visualContext->setMovie(0);
     cancelCallOnMainThread(&VisualContextClient::retrieveCurrentImageProc, this);
 }
 
 bool MediaPlayerPrivateQuickTimeVisualContext::supportsFullscreen() const
 {
+#if USE(ACCELERATED_COMPOSITING)
+    Document* document = m_player->mediaPlayerClient()->mediaPlayerOwningDocument(); 
+    if (document && document->settings())
+        return document->settings()->acceleratedCompositingEnabled();
+#endif
     return false;
 }
 
@@ -285,10 +289,6 @@ void MediaPlayerPrivateQuickTimeVisualContext::load(const String& url)
     m_movie = adoptRef(new QTMovie(m_movieClient.get()));
     m_movie->load(url.characters(), url.length(), m_player->preservesPitch());
     m_movie->setVolume(m_player->volume());
-
-    CFDictionaryRef options = QTMovieVisualContext::getCGImageOptions();
-    m_visualContext = adoptRef(new QTMovieVisualContext(m_visualContextClient.get(), options));
-    m_visualContext->setMovie(m_movie.get());
 }
 
 void MediaPlayerPrivateQuickTimeVisualContext::play()
@@ -630,6 +630,14 @@ void MediaPlayerPrivateQuickTimeVisualContext::setVisible(bool visible)
 
 void MediaPlayerPrivateQuickTimeVisualContext::paint(GraphicsContext* p, const IntRect& r)
 {
+    MediaRenderingMode currentMode = currentRenderingMode();
+ 
+    if (currentMode == MediaRenderingNone)
+        return;
+
+    if (currentMode == MediaRenderingSoftwareRenderer && !m_visualContext)
+        return;
+
 #if USE(ACCELERATED_COMPOSITING)
     if (m_qtVideoLayer)
         return;
@@ -756,16 +764,40 @@ void MediaPlayerPrivateQuickTimeVisualContext::retrieveCurrentImage()
 
         WKCACFLayer* layer = static_cast<WKCACFLayer*>(m_qtVideoLayer->platformLayer());
 
-            if (!buffer.lockBaseAddress()) {
-               CFTimeInterval imageTime = QTMovieVisualContext::currentHostTime();
+        if (!buffer.lockBaseAddress()) {
+            if (requiredDllsAvailable()) {
+                if (!m_imageQueue) {
+                    m_imageQueue = new WKCAImageQueue(buffer.width(), buffer.height(), 30);
+                    m_imageQueue->setFlags(WKCAImageQueue::Fill, WKCAImageQueue::Fill);
+                    layer->setContents(m_imageQueue->get());
+                }
+
+                // Debug QuickTime links against a non-Debug version of CoreFoundation, so the
+                // CFDictionary attached to the CVPixelBuffer cannot be directly passed on into the
+                // CAImageQueue without being converted to a non-Debug CFDictionary.  Additionally,
+                // old versions of QuickTime used a non-AAS CoreFoundation, so the types are not 
+                // interchangable even in the release case.
+                RetainPtr<CFDictionaryRef> attachments(AdoptCF, QTCFDictionaryCreateCopyWithDataCallback(kCFAllocatorDefault, buffer.attachments(), &QTCFDictionaryCreateWithDataCallback));
+                CFTimeInterval imageTime = QTMovieVisualContext::currentHostTime();
+
+                m_imageQueue->collect();
 
+                uint64_t imageId = m_imageQueue->registerPixelBuffer(buffer.baseAddress(), buffer.dataSize(), buffer.bytesPerRow(), buffer.width(), buffer.height(), buffer.pixelFormatType(), attachments.get(), 0);
+
+                if (m_imageQueue->insertImage(imageTime, WKCAImageQueue::Buffer, imageId, WKCAImageQueue::Opaque | WKCAImageQueue::Flush, &QTPixelBuffer::imageQueueReleaseCallback, buffer.pixelBufferRef())) {
+                    // Retain the buffer one extra time so it doesn't dissappear before CAImageQueue decides to release it:
+                    QTPixelBuffer::retainCallback(buffer.pixelBufferRef());
+                }
+
+            } else {
                 CGImageRef image = CreateCGImageFromPixelBuffer(buffer);
                 layer->setContents(image);
                 CGImageRelease(image);
-
-                buffer.unlockBaseAddress();
-                layer->rootLayer()->setNeedsRender();
             }
+
+            buffer.unlockBaseAddress();
+            layer->rootLayer()->setNeedsRender();
+        }
     } else
 #endif
         m_player->repaint();
@@ -794,6 +826,69 @@ static HashSet<String> mimeTypeCache()
     return typeCache;
 }
 
+static CFStringRef createVersionStringFromModuleName(LPCWSTR moduleName)
+{
+    HMODULE module = GetModuleHandleW(moduleName);
+    if (!module) 
+        return 0;
+
+    wchar_t filePath[MAX_PATH] = {0};
+    if (!GetModuleFileNameW(module, filePath, MAX_PATH)) 
+        return 0;
+
+    DWORD versionInfoSize = GetFileVersionInfoSizeW(filePath, 0);
+    if (!versionInfoSize)
+        return 0;
+
+    CFStringRef versionString = 0;
+    void* versionInfo = calloc(versionInfoSize, sizeof(char));
+    if (GetFileVersionInfo(filePath, 0, versionInfoSize, versionInfo)) {
+        VS_FIXEDFILEINFO* fileInfo = 0;
+        UINT fileInfoLength = 0;
+
+        if (VerQueryValueW(versionInfo, L"\\", reinterpret_cast<LPVOID*>(&fileInfo), &fileInfoLength)) {
+            versionString = CFStringCreateWithFormat(kCFAllocatorDefault, 0, CFSTR("%d.%d.%d.%d"), 
+                HIWORD(fileInfo->dwFileVersionMS), LOWORD(fileInfo->dwFileVersionMS), 
+                HIWORD(fileInfo->dwFileVersionLS), LOWORD(fileInfo->dwFileVersionLS));
+        }
+    }
+    free(versionInfo);
+
+    return versionString;
+}
+
+static bool requiredDllsAvailable() 
+{
+    static bool s_prerequisitesChecked = false;
+    static bool s_prerequisitesSatisfied;
+    static const CFStringRef kMinQuartzCoreVersion = CFSTR("1.0.42.0");
+    static const CFStringRef kMinCoreVideoVersion = CFSTR("1.0.1.0");
+
+    if (s_prerequisitesChecked)
+        return s_prerequisitesSatisfied;
+    s_prerequisitesChecked = true;
+    s_prerequisitesSatisfied = false;
+
+    CFStringRef quartzCoreString = createVersionStringFromModuleName(L"QuartzCore");
+    if (!quartzCoreString)
+        quartzCoreString = createVersionStringFromModuleName(L"QuartzCore_debug");
+
+    CFStringRef coreVideoString = createVersionStringFromModuleName(L"CoreVideo");
+    if (!coreVideoString)
+        coreVideoString = createVersionStringFromModuleName(L"CoreVideo_debug");
+
+    s_prerequisitesSatisfied = (quartzCoreString && coreVideoString
+        && CFStringCompare(quartzCoreString, kMinQuartzCoreVersion, kCFCompareNumerically) != kCFCompareLessThan 
+        && CFStringCompare(coreVideoString, kMinCoreVideoVersion, kCFCompareNumerically) != kCFCompareLessThan);
+
+    if (quartzCoreString)
+        CFRelease(quartzCoreString);
+    if (coreVideoString)
+        CFRelease(coreVideoString);
+
+    return s_prerequisitesSatisfied;
+}
+
 void MediaPlayerPrivateQuickTimeVisualContext::getSupportedTypes(HashSet<String>& types)
 {
     types = mimeTypeCache();
@@ -858,7 +953,7 @@ MediaPlayerPrivateQuickTimeVisualContext::MediaRenderingMode MediaPlayerPrivateQ
         return MediaRenderingMovieLayer;
 #endif
 
-    return MediaRenderingSoftwareRenderer;
+    return m_visualContext ? MediaRenderingSoftwareRenderer : MediaRenderingNone;
 }
 
 MediaPlayerPrivateQuickTimeVisualContext::MediaRenderingMode MediaPlayerPrivateQuickTimeVisualContext::preferredRenderingMode() const
@@ -896,6 +991,10 @@ void MediaPlayerPrivateQuickTimeVisualContext::setUpVideoRendering()
     if (currentMode == MediaRenderingMovieLayer || preferredMode == MediaRenderingMovieLayer)
         m_player->mediaPlayerClient()->mediaPlayerRenderingModeChanged(m_player);
 #endif
+
+    QTMovieVisualContext::Type contextType = requiredDllsAvailable() && preferredMode == MediaRenderingMovieLayer ? QTMovieVisualContext::ConfigureForCAImageQueue : QTMovieVisualContext::ConfigureForCGImage;
+    m_visualContext = QTMovieVisualContext::create(m_visualContextClient.get(), contextType);
+    m_visualContext->setMovie(m_movie.get());
 }
 
 void MediaPlayerPrivateQuickTimeVisualContext::tearDownVideoRendering()
@@ -904,12 +1003,14 @@ void MediaPlayerPrivateQuickTimeVisualContext::tearDownVideoRendering()
     if (m_qtVideoLayer)
         destroyLayerForMovie();
 #endif
+
+    m_visualContext = 0;
 }
 
 bool MediaPlayerPrivateQuickTimeVisualContext::hasSetUpVideoRendering() const
 {
 #if USE(ACCELERATED_COMPOSITING)
-    return m_qtVideoLayer || currentRenderingMode() != MediaRenderingMovieLayer;
+    return m_qtVideoLayer || (currentRenderingMode() != MediaRenderingMovieLayer && m_visualContext);
 #else
     return true;
 #endif
@@ -939,14 +1040,22 @@ void MediaPlayerPrivateQuickTimeVisualContext::createLayerForMovie()
 #endif
     // 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
+    // be a long time if we're paused.
+    if (m_visualContext)
+        retrieveCurrentImage();
 }
 
 void MediaPlayerPrivateQuickTimeVisualContext::destroyLayerForMovie()
 {
 #if USE(ACCELERATED_COMPOSITING)
-    if (!m_qtVideoLayer)
-        return;
-    m_qtVideoLayer = 0;
+    if (m_qtVideoLayer)
+        m_qtVideoLayer = 0;
+
+    if (m_imageQueue)
+        m_imageQueue = 0;
 #endif
 }
 
diff --git a/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h b/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h
index 12166a3..7bf796c 100644
--- a/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h
+++ b/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h
@@ -41,7 +41,6 @@
 typedef struct CGImage *CGImageRef;
 class QTMovie;
 class QTMovieVisualContext;
-class WKCAImageQueue;
 
 namespace WebCore {
 
@@ -50,6 +49,10 @@ class IntSize;
 class IntRect;
 class String;
 
+#if USE(ACCELERATED_COMPOSITING)
+class WKCAImageQueue;
+#endif
+
 class MediaPlayerPrivateQuickTimeVisualContext : public MediaPlayerPrivateInterface {
 public:
     static void registerMediaEngine(MediaEngineRegistrar);
@@ -161,6 +164,7 @@ private:
     RefPtr<QTMovie> m_movie;
 #if USE(ACCELERATED_COMPOSITING)
     OwnPtr<GraphicsLayer> m_qtVideoLayer;
+    OwnPtr<WKCAImageQueue> m_imageQueue;
 #endif
     RefPtr<QTMovieVisualContext> m_visualContext;
     float m_seekTo;
diff --git a/WebCore/platform/graphics/win/QTMovieVisualContext.cpp b/WebCore/platform/graphics/win/QTMovieVisualContext.cpp
index 9c08cd9..0232d3b 100644
--- a/WebCore/platform/graphics/win/QTMovieVisualContext.cpp
+++ b/WebCore/platform/graphics/win/QTMovieVisualContext.cpp
@@ -39,7 +39,7 @@ struct QTCVTimeStamp {
 
 class QTMovieVisualContextPriv {
 public:
-    QTMovieVisualContextPriv(QTMovieVisualContext* parent, QTMovieVisualContextClient* client, CFDictionaryRef options);
+    QTMovieVisualContextPriv(QTMovieVisualContext* parent, QTMovieVisualContextClient* client, QTMovieVisualContext::Type contextType);
     ~QTMovieVisualContextPriv();
 
     bool isImageAvailableForTime(const QTCVTimeStamp*) const;
@@ -61,7 +61,61 @@ private:
 
 };
 
-QTMovieVisualContextPriv::QTMovieVisualContextPriv(QTMovieVisualContext* parent, QTMovieVisualContextClient* client, CFDictionaryRef options) 
+static OSStatus SetNumberValue(CFMutableDictionaryRef inDict, CFStringRef inKey, SInt32 inValue)
+{
+    CFNumberRef number;
+ 
+    number = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &inValue);
+    if (!number) 
+        return coreFoundationUnknownErr;
+ 
+    CFDictionarySetValue(inDict, inKey, number);
+    CFRelease(number);
+
+    return noErr;
+}
+
+static CFDictionaryRef createPixelBufferOptionsDictionary(QTMovieVisualContext::Type contextType)
+{
+    static const CFStringRef kDirect3DCompatibilityKey = CFSTR("Direct3DCompatibility");
+
+    CFMutableDictionaryRef pixelBufferOptions = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+
+    CFMutableDictionaryRef pixelBufferAttributes = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+    if (contextType == QTMovieVisualContext::ConfigureForCAImageQueue) {
+        // Ask for D3D compatible pixel buffers so no further work is needed.
+        CFDictionarySetValue(pixelBufferAttributes, kDirect3DCompatibilityKey, kCFBooleanTrue);
+    } else {
+        // Use the k32BGRAPixelFormat, as QuartzCore will be able to use the pixels directly,
+        // without needing an additional copy or rendering pass.
+        SetNumberValue(pixelBufferAttributes, kCVPixelBufferPixelFormatTypeKey, k32BGRAPixelFormat);
+            
+        // Set kCVPixelBufferBytesPerRowAlignmentKey to 16 to ensure that each row of pixels 
+        // starts at a 16 byte aligned address for most efficient data reading.
+        SetNumberValue(pixelBufferAttributes, kCVPixelBufferBytesPerRowAlignmentKey, 16);
+        CFDictionarySetValue(pixelBufferAttributes, kCVPixelBufferCGImageCompatibilityKey, kCFBooleanTrue);
+    }
+ 
+    CFDictionarySetValue(pixelBufferOptions, kQTVisualContextPixelBufferAttributesKey, pixelBufferAttributes);
+
+    CFRelease(pixelBufferAttributes);
+
+    return pixelBufferOptions;
+}
+
+static CFDictionaryRef pixelBufferCreationOptions(QTMovieVisualContext::Type contextType)
+{
+    if (contextType == QTMovieVisualContext::ConfigureForCAImageQueue) {
+        static CFDictionaryRef imageQueueOptions = createPixelBufferOptionsDictionary(contextType);
+        return imageQueueOptions;
+    } 
+
+    ASSERT(contextType == QTMovieVisualContext::ConfigureForCGImage);
+    static CFDictionaryRef cgImageOptions = createPixelBufferOptionsDictionary(contextType);
+    return cgImageOptions;
+}
+
+QTMovieVisualContextPriv::QTMovieVisualContextPriv(QTMovieVisualContext* parent, QTMovieVisualContextClient* client, QTMovieVisualContext::Type contextType) 
         : m_parent(parent)
         , m_client(client)
         , m_visualContext(0)
@@ -77,13 +131,15 @@ QTMovieVisualContextPriv::QTMovieVisualContextPriv(QTMovieVisualContext* parent,
             return;
     }
 
-    OSStatus status = pPixelBufferContextCreate(kCFAllocatorDefault, options, &m_visualContext);
+    OSStatus status = pPixelBufferContextCreate(kCFAllocatorDefault, pixelBufferCreationOptions(contextType), &m_visualContext);
     if (status == noErr && m_visualContext)
         QTVisualContextSetImageAvailableCallback(m_visualContext, &QTMovieVisualContextPriv::imageAvailableCallback, static_cast<void*>(this));
 }
 
 QTMovieVisualContextPriv::~QTMovieVisualContextPriv()
 {
+    if (m_visualContext)
+        QTVisualContextSetImageAvailableCallback(m_visualContext, 0, 0);
 }
 
 bool QTMovieVisualContextPriv::isImageAvailableForTime(const QTCVTimeStamp* timeStamp) const
@@ -150,66 +206,13 @@ void QTMovieVisualContextPriv::imageAvailableCallback(QTVisualContextRef visualC
     vc->m_client->imageAvailableForTime(reinterpret_cast<const QTCVTimeStamp*>(timeStamp));
 }
 
-static OSStatus SetNumberValue(CFMutableDictionaryRef inDict, CFStringRef inKey, SInt32 inValue)
+PassRefPtr<QTMovieVisualContext> QTMovieVisualContext::create(QTMovieVisualContextClient* client, Type contextType)
 {
-    CFNumberRef number;
- 
-    number = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &inValue);
-    if (!number) 
-        return coreFoundationUnknownErr;
- 
-    CFDictionarySetValue(inDict, inKey, number);
- 
-    CFRelease(number);
- 
-    return noErr;
-}
-
-CFDictionaryRef QTMovieVisualContext::getCGImageOptions()
-{
-    static CFDictionaryRef options = 0;
-
-    if (!options) {
-        CFMutableDictionaryRef  pixelBufferOptions = 0;
-        CFMutableDictionaryRef  visualContextOptions = 0;
-        OSStatus                status = noErr;
-        
-        // Pixel Buffer attributes
-        pixelBufferOptions = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
-                                                       &kCFTypeDictionaryKeyCallBacks,
-                                                       &kCFTypeDictionaryValueCallBacks);
-
-        // Use the k32BGRAPixelFormat, as QuartzCore will be able to use the pixels directly,
-        // without needing an aditional copy or rendering pass:s
-        SetNumberValue(pixelBufferOptions, kCVPixelBufferPixelFormatTypeKey, k32BGRAPixelFormat);
-            
-        // alignment
-        SetNumberValue(pixelBufferOptions, kCVPixelBufferBytesPerRowAlignmentKey, 16);
-
-        // compatability
-        SetNumberValue(pixelBufferOptions, kCVPixelBufferCGImageCompatibilityKey, 1);
-     
-        // QT Visual Context attributes
-        visualContextOptions = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
-                                                         &kCFTypeDictionaryKeyCallBacks,
-                                                         &kCFTypeDictionaryValueCallBacks);
-     
-        // set the pixel buffer attributes for the visual context
-        CFDictionarySetValue(visualContextOptions,
-                             kQTVisualContextPixelBufferAttributesKey,
-                             pixelBufferOptions);
-
-        if (pixelBufferOptions)
-            CFRelease(pixelBufferOptions);
-    
-        options = visualContextOptions;
-    }
-
-    return options;
+    return adoptRef(new QTMovieVisualContext(client, contextType));
 }
 
-QTMovieVisualContext::QTMovieVisualContext(QTMovieVisualContextClient* client, CFDictionaryRef options) 
-    : m_private(new QTMovieVisualContextPriv(this, client, options))
+QTMovieVisualContext::QTMovieVisualContext(QTMovieVisualContextClient* client, Type contextType) 
+    : m_private(new QTMovieVisualContextPriv(this, client, contextType))
 {
 }
 
diff --git a/WebCore/platform/graphics/win/QTMovieVisualContext.h b/WebCore/platform/graphics/win/QTMovieVisualContext.h
index 8846416..057031e 100644
--- a/WebCore/platform/graphics/win/QTMovieVisualContext.h
+++ b/WebCore/platform/graphics/win/QTMovieVisualContext.h
@@ -54,7 +54,9 @@ public:
 
 class QTMOVIEWIN_API QTMovieVisualContext : public RefCounted<QTMovieVisualContext> {
 public:
-    QTMovieVisualContext(QTMovieVisualContextClient*, CFDictionaryRef options = 0);
+    enum Type { ConfigureForCGImage, ConfigureForCAImageQueue };
+
+    static PassRefPtr<QTMovieVisualContext> create(QTMovieVisualContextClient*, Type);
     ~QTMovieVisualContext();
 
     bool isImageAvailableForTime(const QTCVTimeStamp*) const;
@@ -66,10 +68,10 @@ public:
     void setMovie(PassRefPtr<QTMovie>);
     QTMovie* movie() const;
 
-    static CFDictionaryRef getCGImageOptions();
     static double currentHostTime();
 
 protected:
+    QTMovieVisualContext(QTMovieVisualContextClient*, Type);
     void setupVisualContext();
 
     friend class QTMovieVisualContextPriv;
diff --git a/WebCore/platform/graphics/win/QTPixelBuffer.cpp b/WebCore/platform/graphics/win/QTPixelBuffer.cpp
index f874287..657b68e 100644
--- a/WebCore/platform/graphics/win/QTPixelBuffer.cpp
+++ b/WebCore/platform/graphics/win/QTPixelBuffer.cpp
@@ -172,6 +172,11 @@ void QTPixelBuffer::getExtendedPixels(size_t* left, size_t* right, size_t* top,
     return CVPixelBufferGetExtendedPixels(m_pixelBuffer, left, right, top, bottom);
 }
 
+CFDictionaryRef QTPixelBuffer::attachments() const
+{
+    return CVBufferGetAttachments(m_pixelBuffer, kCVAttachmentMode_ShouldPropagate);
+}
+
 void QTPixelBuffer::retainCallback(void* refcon)
 {
     CVPixelBufferRetain(static_cast<CVPixelBufferRef>(refcon));
diff --git a/WebCore/platform/graphics/win/QTPixelBuffer.h b/WebCore/platform/graphics/win/QTPixelBuffer.h
index 3af2197..22f8ba4 100644
--- a/WebCore/platform/graphics/win/QTPixelBuffer.h
+++ b/WebCore/platform/graphics/win/QTPixelBuffer.h
@@ -38,6 +38,7 @@ typedef struct __CVBuffer *CVBufferRef;
 typedef CVBufferRef CVPixelBufferRef;
 typedef struct CGImage* CGImageRef;
 typedef int32_t CVReturn;
+typedef const struct __CFDictionary * CFDictionaryRef;
 
 // QTPixelBuffer wraps QuickTime's implementation of CVPixelBuffer, so its functions are
 // safe to call within WebKit.
@@ -74,6 +75,7 @@ public:
     size_t bytesPerRowOfPlane(size_t) const;
 
     void getExtendedPixels(size_t* left, size_t* right, size_t* top, size_t* bottom) const;
+    CFDictionaryRef attachments() const;
 
     // Generic CFRetain/CFRelease callbacks
     static void releaseCallback(void* refcon);
diff --git a/WebCore/platform/graphics/win/WKCACFLayer.cpp b/WebCore/platform/graphics/win/WKCACFLayer.cpp
index 3f332d8..d3928f1 100644
--- a/WebCore/platform/graphics/win/WKCACFLayer.cpp
+++ b/WebCore/platform/graphics/win/WKCACFLayer.cpp
@@ -154,6 +154,7 @@ PassRefPtr<WKCACFLayer> WKCACFLayer::create(LayerType type)
 
 WKCACFLayer::WKCACFLayer(LayerType type)
     : m_layer(AdoptCF, CACFLayerCreate(toCACFLayerType(type)))
+    , m_layoutClient(0)
     , m_needsDisplayOnBoundsChange(false)
 {
     CACFLayerSetUserData(layer(), this);
@@ -286,11 +287,10 @@ void  WKCACFLayer::adoptSublayers(WKCACFLayer* source)
 void WKCACFLayer::removeFromSuperlayer()
 {
     WKCACFLayer* superlayer = this->superlayer();
-    if (!superlayer)
-        return;
-
     CACFLayerRemoveFromSuperlayer(layer());
-    superlayer->setNeedsCommit();
+
+    if (superlayer)
+        superlayer->setNeedsCommit();
 }
 
 WKCACFLayer* WKCACFLayer::internalSublayerAtIndex(int index) const
@@ -343,6 +343,19 @@ void WKCACFLayer::setBounds(const CGRect& rect)
         setNeedsDisplay();
 }
 
+void WKCACFLayer::setFrame(const CGRect& rect)
+{
+    CGRect oldFrame = frame();
+    if (CGRectEqualToRect(rect, oldFrame))
+        return;
+
+    CACFLayerSetFrame(layer(), rect);
+    setNeedsCommit();
+
+    if (m_needsDisplayOnBoundsChange && !CGSizeEqualToSize(rect.size, oldFrame.size))
+        setNeedsDisplay();
+}
+
 void WKCACFLayer::setContentsGravity(ContentsGravityType type)
 {
     CACFLayerSetContentsGravity(layer(), toCACFContentsGravityType(type));
@@ -418,6 +431,22 @@ void WKCACFLayer::internalSetNeedsDisplay(const CGRect* dirtyRect)
     CACFLayerSetNeedsDisplay(layer(), dirtyRect);
 }
 
+void WKCACFLayer::setLayoutClient(WKCACFLayerLayoutClient* layoutClient)
+{
+    if (layoutClient == m_layoutClient)
+        return;
+
+    m_layoutClient = layoutClient;
+    CACFLayerSetLayoutCallback(layer(), m_layoutClient ? layoutSublayersProc : 0);    
+}
+
+void WKCACFLayer::layoutSublayersProc(CACFLayerRef caLayer) 
+{
+    WKCACFLayer* layer = WKCACFLayer::layer(caLayer);
+    if (layer && layer->m_layoutClient)
+        layer->m_layoutClient->layoutSublayersOfLayer(layer);
+}
+
 #ifndef NDEBUG
 static void printIndent(int indent)
 {
@@ -497,11 +526,14 @@ void WKCACFLayer::printLayer(int indent) const
     }
 
     // Print contents if needed
-    CGImageRef layerContents = contents();
+    CFTypeRef layerContents = contents();
     if (layerContents) {
-        printIndent(indent + 1);
-        fprintf(stderr, "(contents (image [%d %d]))\n",
-            CGImageGetWidth(layerContents), CGImageGetHeight(layerContents));
+        if (CFGetTypeID(layerContents) == CGImageGetTypeID()) {
+            CGImageRef imageContents = static_cast<CGImageRef>(const_cast<void*>(layerContents));
+            printIndent(indent + 1);
+            fprintf(stderr, "(contents (image [%d %d]))\n",
+                CGImageGetWidth(imageContents), CGImageGetHeight(imageContents));
+        }
     }
 
     // Print sublayers if needed
diff --git a/WebCore/platform/graphics/win/WKCACFLayer.h b/WebCore/platform/graphics/win/WKCACFLayer.h
index bdc427e..5e8eb05 100644
--- a/WebCore/platform/graphics/win/WKCACFLayer.h
+++ b/WebCore/platform/graphics/win/WKCACFLayer.h
@@ -44,8 +44,14 @@
 
 namespace WebCore {
 
-class WKCACFAnimation;
-class WKCACFTimingFunction;
+class WKCACFLayer;
+
+class WKCACFLayerLayoutClient {
+public:
+    virtual void layoutSublayersOfLayer(WKCACFLayer*) = 0;
+protected:
+    virtual ~WKCACFLayerLayoutClient() {}
+};
 
 class WKCACFLayer : public RefCounted<WKCACFLayer> {
 public:
@@ -63,6 +69,10 @@ public:
 
     virtual void drawInContext(PlatformGraphicsContext*) { }
 
+    void setLayoutClient(WKCACFLayerLayoutClient*);
+    WKCACFLayerLayoutClient* layoutClient() const { return m_layoutClient; }
+    void setNeedsLayout() { CACFLayerSetNeedsLayout(layer()); }
+
     void setNeedsDisplay(const CGRect* dirtyRect = 0)
     {
         internalSetNeedsDisplay(dirtyRect);
@@ -155,8 +165,8 @@ public:
     void setClearsContext(bool clears) { CACFLayerSetClearsContext(layer(), clears); setNeedsCommit(); }
     bool clearsContext() const { return CACFLayerGetClearsContext(layer()); }
 
-    void setContents(CGImageRef contents) { CACFLayerSetContents(layer(), contents); setNeedsCommit(); }
-    CGImageRef contents() const { return static_cast<CGImageRef>(const_cast<void*>(CACFLayerGetContents(layer()))); }
+    void setContents(CFTypeRef contents) { CACFLayerSetContents(layer(), contents); setNeedsCommit(); }
+    CFTypeRef contents() const { return CACFLayerGetContents(layer()); }
 
     void setContentsRect(const CGRect& contentsRect) { CACFLayerSetContentsRect(layer(), contentsRect); setNeedsCommit(); }
     CGRect contentsRect() const { return CACFLayerGetContentsRect(layer()); }
@@ -173,6 +183,9 @@ public:
     void setFilters(CFArrayRef filters) { CACFLayerSetFilters(layer(), filters); setNeedsCommit(); }
     CFArrayRef filters() const { return CACFLayerGetFilters(layer()); }
 
+    virtual void setFrame(const CGRect&);
+    CGRect frame() const { return CACFLayerGetFrame(layer()); }
+
     void setHidden(bool hidden) { CACFLayerSetHidden(layer(), hidden); setNeedsCommit(); }
     bool isHidden() const { return CACFLayerIsHidden(layer()); }
 
@@ -206,10 +219,10 @@ public:
     CGFloat zPosition() const { return CACFLayerGetZPosition(layer()); }
 
     void setSpeed(float speed) { CACFLayerSetSpeed(layer(), speed); }
-    CFTimeInterval speed() const { CACFLayerGetSpeed(layer()); }
+    CFTimeInterval speed() const { return CACFLayerGetSpeed(layer()); }
 
     void setTimeOffset(CFTimeInterval t) { CACFLayerSetTimeOffset(layer(), t); }
-    CFTimeInterval timeOffset() const { CACFLayerGetTimeOffset(layer()); }
+    CFTimeInterval timeOffset() const { return CACFLayerGetTimeOffset(layer()); }
 
     WKCACFLayer* rootLayer() const;
 
@@ -261,7 +274,10 @@ protected:
 #endif
 
 private:
+    static void layoutSublayersProc(CACFLayerRef);
+
     RetainPtr<CACFLayerRef> m_layer;
+    WKCACFLayerLayoutClient* m_layoutClient;
     bool m_needsDisplayOnBoundsChange;
 };
 
diff --git a/WebCore/platform/graphics/win/WKCAImageQueue.cpp b/WebCore/platform/graphics/win/WKCAImageQueue.cpp
new file mode 100644
index 0000000..b52b9a4
--- /dev/null
+++ b/WebCore/platform/graphics/win/WKCAImageQueue.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS “AS IS” 
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#if USE(ACCELERATED_COMPOSITING)
+
+#include "WKCAImageQueue.h"
+
+#include <WebKitSystemInterface/WebKitSystemInterface.h>
+#include <wtf/RetainPtr.h>
+
+namespace WebCore {
+
+class WKCAImageQueuePrivate {
+public:
+    RetainPtr<CAImageQueueRef> m_imageQueue;
+};
+
+static CAImageQueueRef WKCAImageQueueRetain(CAImageQueueRef iq) 
+{
+    if (iq)
+        return (CAImageQueueRef)CFRetain(iq);
+    return 0;
+}
+
+static void WKCAImageQueueRelease(CAImageQueueRef iq)
+{
+    if (iq)
+        CFRelease(iq);
+}
+
+WKCAImageQueue::WKCAImageQueue(uint32_t width, uint32_t height, uint32_t capacity)
+    : m_private(new WKCAImageQueuePrivate())
+{
+    m_private->m_imageQueue.adoptCF(wkCAImageQueueCreate(width, height, capacity));
+}
+
+WKCAImageQueue::WKCAImageQueue(const WKCAImageQueue& o)
+    : m_private(new WKCAImageQueuePrivate())
+{
+    m_private->m_imageQueue = o.m_private->m_imageQueue;
+}
+
+WKCAImageQueue::~WKCAImageQueue(void)
+{
+}
+
+WKCAImageQueue& WKCAImageQueue::operator=(const WKCAImageQueue& o)
+{
+    m_private->m_imageQueue = o.m_private->m_imageQueue;
+    return *this;
+}
+
+size_t WKCAImageQueue::collect()
+{
+    return wkCAImageQueueCollect(m_private->m_imageQueue.get());
+}
+
+bool WKCAImageQueue::insertImage(double t, unsigned int type, uint64_t id, uint32_t flags, ReleaseCallback release, void* info)
+{
+    return wkCAImageQueueInsertImage(m_private->m_imageQueue.get(), t, type, id, flags, release, info);
+}
+
+uint64_t WKCAImageQueue::registerPixelBuffer(void *data, size_t data_size, size_t rowbytes, size_t width, size_t height, uint32_t pixel_format, CFDictionaryRef attachments, uint32_t flags)
+{
+    return wkCAImageQueueRegisterPixelBuffer(m_private->m_imageQueue.get(), data, data_size, rowbytes, width, height, pixel_format, attachments, flags);
+}
+
+void WKCAImageQueue::setFlags(uint32_t mask, uint32_t flags)
+{
+    wkCAImageQueueSetFlags(m_private->m_imageQueue.get(), mask, flags);
+}
+
+CFTypeRef WKCAImageQueue::get()
+{
+    return m_private->m_imageQueue.get();
+}
+
+}
+
+#endif
diff --git a/WebCore/platform/graphics/win/WKCAImageQueue.h b/WebCore/platform/graphics/win/WKCAImageQueue.h
new file mode 100644
index 0000000..5c17575
--- /dev/null
+++ b/WebCore/platform/graphics/win/WKCAImageQueue.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS “AS IS” 
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef WKCAImageQueue_h
+#define WKCAImageQueue_h
+
+#if USE(ACCELERATED_COMPOSITING)
+
+typedef const void * CFTypeRef;
+typedef const struct __CFDictionary * CFDictionaryRef;
+
+#include <stdint.h>
+#include <wtf/OwnPtr.h>
+
+namespace WebCore {
+
+class WKCAImageQueuePrivate;
+
+class WKCAImageQueue {
+public:
+    enum Flags {
+        Async = 1U << 0,
+        Fill  = 1U << 1,
+        Protected = 1U << 2,
+        UseCleanAperture = 1U << 3,
+        UseAspectRatio = 1U << 4,
+        LowQualityColor = 1U << 5,
+    };
+
+    enum ImageType {
+        Nil = 1,
+        Surface,
+        Buffer,
+        IOSurface,
+    };
+
+    enum ImageFlags {
+        Opaque = 1U << 0,
+        Flush = 1U << 1,
+        WillFlush = 1U << 2,
+        Flipped = 1U << 3,
+        WaitGPU = 1U << 4,
+    };
+
+    typedef void (*ReleaseCallback)(unsigned int type, uint64_t id, void* info);
+
+    WKCAImageQueue(uint32_t width, uint32_t height, uint32_t capacity);
+    ~WKCAImageQueue(void);
+
+    size_t collect();
+
+    bool insertImage(double t, unsigned int type, uint64_t id, uint32_t flags, ReleaseCallback release, void* info);
+    uint64_t registerPixelBuffer(void *data, size_t data_size, size_t rowbytes, size_t width, size_t height, uint32_t pixel_format, CFDictionaryRef attachments, uint32_t flags);
+
+    uint32_t flags() const;
+    void setFlags(uint32_t mask, uint32_t flags);
+
+    CFTypeRef get();
+
+private:
+    WKCAImageQueue(const WKCAImageQueue&);
+    WKCAImageQueue& operator=(const WKCAImageQueue&);
+    OwnPtr<WKCAImageQueuePrivate> m_private;
+};
+
+}
+
+#endif
+
+#endif
diff --git a/WebCore/platform/graphics/win/WebTiledLayer.cpp b/WebCore/platform/graphics/win/WebTiledLayer.cpp
index 0cf3f9d..d8c02d2 100755
--- a/WebCore/platform/graphics/win/WebTiledLayer.cpp
+++ b/WebCore/platform/graphics/win/WebTiledLayer.cpp
@@ -73,6 +73,15 @@ void WebTiledLayer::setBounds(const CGRect& rect)
     updateTiles();
 }
 
+void WebTiledLayer::setFrame(const CGRect& rect)
+{
+    if (CGRectEqualToRect(rect, frame()))
+        return;
+
+    WebLayer::setFrame(rect);
+    updateTiles();
+}
+
 void WebTiledLayer::internalSetNeedsDisplay(const CGRect* dirtyRect)
 {
     // FIXME: Only setNeedsDisplay for tiles that are currently visible
diff --git a/WebCore/platform/graphics/win/WebTiledLayer.h b/WebCore/platform/graphics/win/WebTiledLayer.h
index ed61656..fdf0205 100755
--- a/WebCore/platform/graphics/win/WebTiledLayer.h
+++ b/WebCore/platform/graphics/win/WebTiledLayer.h
@@ -39,6 +39,7 @@ public:
     virtual ~WebTiledLayer();
 
     virtual void setBounds(const CGRect&);
+    virtual void setFrame(const CGRect&);
 
 protected:
     WebTiledLayer(const CGSize& tileSize, GraphicsLayer* owner);