Move CACFLayerTreeHostClient to its own header file
[WebKit-https.git] / Source / WebCore / platform / graphics / ca / win / CACFLayerTreeHost.cpp
1 /*
2  * Copyright (C) 2009 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "CACFLayerTreeHost.h"
28
29 #if USE(ACCELERATED_COMPOSITING)
30
31 #include "CACFLayerTreeHostClient.h"
32 #include "LayerChangesFlusher.h"
33 #include "PlatformCALayer.h"
34 #include "WebCoreInstanceHandle.h"
35 #include <WebKitSystemInterface/WebKitSystemInterface.h>
36 #include <limits.h>
37 #include <wtf/CurrentTime.h>
38 #include <wtf/HashMap.h>
39 #include <wtf/OwnArrayPtr.h>
40 #include <wtf/OwnPtr.h>
41 #include <wtf/PassOwnPtr.h>
42 #include <wtf/StdLibExtras.h>
43
44 #ifndef NDEBUG
45 #define D3D_DEBUG_INFO
46 #endif
47
48 #include <d3d9.h>
49 #include <d3dx9.h>
50
51 using namespace std;
52
53 #pragma comment(lib, "d3d9")
54 #pragma comment(lib, "d3dx9")
55 #ifdef DEBUG_ALL
56 #pragma comment(lib, "QuartzCore_debug")
57 #else
58 #pragma comment(lib, "QuartzCore")
59 #endif
60
61 static IDirect3D9* s_d3d = 0;
62 static IDirect3D9* d3d()
63 {
64     if (s_d3d)
65         return s_d3d;
66
67     if (!LoadLibrary(TEXT("d3d9.dll")))
68         return 0;
69
70     s_d3d = Direct3DCreate9(D3D_SDK_VERSION);
71
72     return s_d3d;
73 }
74
75 inline static CGRect winRectToCGRect(RECT rc)
76 {
77     return CGRectMake(rc.left, rc.top, (rc.right - rc.left), (rc.bottom - rc.top));
78 }
79
80 inline static CGRect winRectToCGRect(RECT rc, RECT relativeToRect)
81 {
82     return CGRectMake(rc.left, (relativeToRect.bottom-rc.bottom), (rc.right - rc.left), (rc.bottom - rc.top));
83 }
84
85 namespace WebCore {
86
87 static D3DPRESENT_PARAMETERS initialPresentationParameters()
88 {
89     D3DPRESENT_PARAMETERS parameters = {0};
90     parameters.Windowed = TRUE;
91     parameters.SwapEffect = D3DSWAPEFFECT_COPY;
92     parameters.BackBufferCount = 1;
93     parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
94     parameters.MultiSampleType = D3DMULTISAMPLE_NONE;
95
96     return parameters;
97 }
98
99 // FIXME: <rdar://6507851> Share this code with CoreAnimation.
100 static bool hardwareCapabilitiesIndicateCoreAnimationSupport(const D3DCAPS9& caps)
101 {
102     // CoreAnimation needs two or more texture units.
103     if (caps.MaxTextureBlendStages < 2)
104         return false;
105
106     // CoreAnimation needs non-power-of-two textures.
107     if ((caps.TextureCaps & D3DPTEXTURECAPS_POW2) && !(caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL))
108         return false;
109
110     // CoreAnimation needs vertex shader 2.0 or greater.
111     if (D3DSHADER_VERSION_MAJOR(caps.VertexShaderVersion) < 2)
112         return false;
113
114     // CoreAnimation needs pixel shader 2.0 or greater.
115     if (D3DSHADER_VERSION_MAJOR(caps.PixelShaderVersion) < 2)
116         return false;
117
118     return true;
119 }
120
121 bool CACFLayerTreeHost::acceleratedCompositingAvailable()
122 {
123     static bool available;
124     static bool tested;
125
126     if (tested)
127         return available;
128
129     tested = true;
130
131     // Initialize available to true since this function will be called from a 
132     // propagation within createRenderer(). We want to be able to return true 
133     // when that happens so that the test can continue.
134     available = true;
135     
136     HMODULE library = LoadLibrary(TEXT("d3d9.dll"));
137     if (!library) {
138         available = false;
139         return available;
140     }
141
142     FreeLibrary(library);
143 #ifdef DEBUG_ALL
144     library = LoadLibrary(TEXT("QuartzCore_debug.dll"));
145 #else
146     library = LoadLibrary(TEXT("QuartzCore.dll"));
147 #endif
148     if (!library) {
149         available = false;
150         return available;
151     }
152
153     FreeLibrary(library);
154
155     // Make a dummy HWND.
156     WNDCLASSEX wcex = { 0 };
157     wcex.cbSize = sizeof(WNDCLASSEX);
158     wcex.lpfnWndProc = DefWindowProc;
159     wcex.hInstance = WebCore::instanceHandle();
160     wcex.lpszClassName = L"CoreAnimationTesterWindowClass";
161     ::RegisterClassEx(&wcex);
162     HWND testWindow = ::CreateWindow(L"CoreAnimationTesterWindowClass", L"CoreAnimationTesterWindow", WS_POPUP, -500, -500, 0, 0, 0, 0, 0, 0);
163
164     if (!testWindow) {
165         available = false;
166         return available;
167     }
168
169     RefPtr<CACFLayerTreeHost> host = CACFLayerTreeHost::create();
170     host->setWindow(testWindow);
171     available = host->createRenderer();
172     ::DestroyWindow(testWindow);
173
174     return available;
175 }
176
177 PassRefPtr<CACFLayerTreeHost> CACFLayerTreeHost::create()
178 {
179     if (!acceleratedCompositingAvailable())
180         return 0;
181     return adoptRef(new CACFLayerTreeHost());
182 }
183
184 CACFLayerTreeHost::CACFLayerTreeHost()
185     : m_client(0)
186     , m_mightBeAbleToCreateDeviceLater(true)
187     , m_rootLayer(PlatformCALayer::create(PlatformCALayer::LayerTypeRootLayer, 0))
188     , m_context(wkCACFContextCreate())
189     , m_window(0)
190     , m_renderTimer(this, &CACFLayerTreeHost::renderTimerFired)
191     , m_mustResetLostDeviceBeforeRendering(false)
192     , m_shouldFlushPendingGraphicsLayerChanges(false)
193     , m_isFlushingLayerChanges(false)
194 #if !ASSERT_DISABLED
195     , m_state(WindowNotSet)
196 #endif
197 {
198     // Point the CACFContext to this
199     wkCACFContextSetUserData(m_context, this);
200
201     // Under the root layer, we have a clipping layer to clip the content,
202     // that contains a scroll layer that we use for scrolling the content.
203     // The root layer is the size of the client area of the window.
204     // The clipping layer is the size of the WebView client area (window less the scrollbars).
205     // The scroll layer is the size of the root child layer.
206     // Resizing the window will change the bounds of the rootLayer and the clip layer and will not
207     // cause any repositioning.
208     // Scrolling will affect only the position of the scroll layer without affecting the bounds.
209
210     m_rootLayer->setName("CACFLayerTreeHost rootLayer");
211     m_rootLayer->setAnchorPoint(FloatPoint3D(0, 0, 0));
212     m_rootLayer->setGeometryFlipped(true);
213
214 #ifndef NDEBUG
215     CGColorRef debugColor = CGColorCreateGenericRGB(1, 0, 0, 0.8);
216     m_rootLayer->setBackgroundColor(debugColor);
217     CGColorRelease(debugColor);
218 #endif
219
220     if (m_context)
221         wkCACFContextSetLayer(m_context, m_rootLayer->platformLayer());
222
223 #ifndef NDEBUG
224     char* printTreeFlag = getenv("CA_PRINT_TREE");
225     m_printTree = printTreeFlag && atoi(printTreeFlag);
226 #endif
227 }
228
229 CACFLayerTreeHost::~CACFLayerTreeHost()
230 {
231     setWindow(0);
232     wkCACFContextDestroy(m_context);
233 }
234
235 void CACFLayerTreeHost::setWindow(HWND window)
236 {
237     if (window == m_window)
238         return;
239
240 #if !ASSERT_DISABLED
241     switch (m_state) {
242     case WindowNotSet:
243         ASSERT_ARG(window, window);
244         ASSERT(!m_window);
245         m_state = WindowSet;
246         break;
247     case WindowSet:
248         ASSERT_ARG(window, !window);
249         ASSERT(m_window);
250         m_state = WindowCleared;
251         break;
252     case WindowCleared:
253         ASSERT_NOT_REACHED();
254         break;
255     }
256 #endif
257
258     if (m_window)
259         destroyRenderer();
260
261     m_window = window;
262 }
263
264 PlatformCALayer* CACFLayerTreeHost::rootLayer() const
265 {
266     return m_rootLayer.get();
267 }
268
269 void CACFLayerTreeHost::addPendingAnimatedLayer(PassRefPtr<PlatformCALayer> layer)
270 {
271     m_pendingAnimatedLayers.add(layer);
272 }
273
274 void CACFLayerTreeHost::setRootChildLayer(PlatformCALayer* layer)
275 {
276     m_rootLayer->removeAllSublayers();
277     m_rootChildLayer = layer;
278     if (m_rootChildLayer)
279         m_rootLayer->appendSublayer(m_rootChildLayer.get());
280 }
281    
282 void CACFLayerTreeHost::layerTreeDidChange()
283 {
284     if (m_isFlushingLayerChanges) {
285         // The layer tree is changing as a result of flushing GraphicsLayer changes to their
286         // underlying PlatformCALayers. We'll flush those changes to the context as part of that
287         // process, so there's no need to schedule another flush here.
288         return;
289     }
290
291     // The layer tree is changing as a result of someone modifying a PlatformCALayer that doesn't
292     // have a corresponding GraphicsLayer. Schedule a flush since we won't schedule one through the
293     // normal GraphicsLayer mechanisms.
294     LayerChangesFlusher::shared().flushPendingLayerChangesSoon(this);
295 }
296
297 bool CACFLayerTreeHost::createRenderer()
298 {
299     if (m_d3dDevice || !m_mightBeAbleToCreateDeviceLater)
300         return m_d3dDevice;
301
302     m_mightBeAbleToCreateDeviceLater = false;
303     D3DPRESENT_PARAMETERS parameters = initialPresentationParameters();
304
305     if (!d3d() || !::IsWindow(m_window))
306         return false;
307
308     // D3D doesn't like to make back buffers for 0 size windows. We skirt this problem if we make the
309     // passed backbuffer width and height non-zero. The window will necessarily get set to a non-zero
310     // size eventually, and then the backbuffer size will get reset.
311     RECT rect;
312     GetClientRect(m_window, &rect);
313
314     if (rect.left-rect.right == 0 || rect.bottom-rect.top == 0) {
315         parameters.BackBufferWidth = 1;
316         parameters.BackBufferHeight = 1;
317     }
318
319     D3DCAPS9 d3dCaps;
320     if (FAILED(d3d()->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dCaps)))
321         return false;
322
323     DWORD behaviorFlags = D3DCREATE_FPU_PRESERVE;
324     if ((d3dCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) && d3dCaps.VertexProcessingCaps)
325         behaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
326     else
327         behaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
328
329     COMPtr<IDirect3DDevice9> device;
330     if (FAILED(d3d()->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_window, behaviorFlags, &parameters, &device))) {
331         // In certain situations (e.g., shortly after waking from sleep), Direct3DCreate9() will
332         // return an IDirect3D9 for which IDirect3D9::CreateDevice will always fail. In case we
333         // have one of these bad IDirect3D9s, get rid of it so we'll fetch a new one the next time
334         // we want to call CreateDevice.
335         s_d3d->Release();
336         s_d3d = 0;
337
338         // Even if we don't have a bad IDirect3D9, in certain situations (e.g., shortly after
339         // waking from sleep), CreateDevice will fail, but will later succeed if called again.
340         m_mightBeAbleToCreateDeviceLater = true;
341
342         return false;
343     }
344
345     // Now that we've created the IDirect3DDevice9 based on the capabilities we
346     // got from the IDirect3D9 global object, we requery the device for its
347     // actual capabilities. The capabilities returned by the device can
348     // sometimes be more complete, for example when using software vertex
349     // processing.
350     D3DCAPS9 deviceCaps;
351     if (FAILED(device->GetDeviceCaps(&deviceCaps)))
352         return false;
353
354     if (!hardwareCapabilitiesIndicateCoreAnimationSupport(deviceCaps))
355         return false;
356
357     m_d3dDevice = device;
358
359     initD3DGeometry();
360
361     wkCACFContextSetD3DDevice(m_context, m_d3dDevice.get());
362
363     if (IsWindow(m_window)) {
364         m_rootLayer->setBounds(bounds());
365         wkCACFContextFlush(m_context);
366     }
367
368     return true;
369 }
370
371 void CACFLayerTreeHost::destroyRenderer()
372 {
373     LayerChangesFlusher::shared().cancelPendingFlush(this);
374
375     wkCACFContextSetLayer(m_context, 0);
376
377     wkCACFContextSetD3DDevice(m_context, 0);
378     m_d3dDevice = 0;
379     if (s_d3d)
380         s_d3d->Release();
381
382     s_d3d = 0;
383     m_rootLayer = 0;
384     m_rootChildLayer = 0;
385
386     m_mightBeAbleToCreateDeviceLater = true;
387 }
388
389 void CACFLayerTreeHost::resize()
390 {
391     if (!m_d3dDevice)
392         return;
393
394     // Resetting the device might fail here. But that's OK, because if it does it we will attempt to
395     // reset the device the next time we try to render.
396     resetDevice(ChangedWindowSize);
397
398     if (m_rootLayer) {
399         m_rootLayer->setBounds(bounds());
400         wkCACFContextFlush(m_context);
401     }
402 }
403
404 static void getDirtyRects(HWND window, Vector<CGRect>& outRects)
405 {
406     ASSERT_ARG(outRects, outRects.isEmpty());
407
408     RECT clientRect;
409     if (!GetClientRect(window, &clientRect))
410         return;
411
412     OwnPtr<HRGN> region(CreateRectRgn(0, 0, 0, 0));
413     int regionType = GetUpdateRgn(window, region.get(), false);
414     if (regionType != COMPLEXREGION) {
415         RECT dirtyRect;
416         if (GetUpdateRect(window, &dirtyRect, false))
417             outRects.append(winRectToCGRect(dirtyRect, clientRect));
418         return;
419     }
420
421     DWORD dataSize = GetRegionData(region.get(), 0, 0);
422     OwnArrayPtr<unsigned char> regionDataBuffer(new unsigned char[dataSize]);
423     RGNDATA* regionData = reinterpret_cast<RGNDATA*>(regionDataBuffer.get());
424     if (!GetRegionData(region.get(), dataSize, regionData))
425         return;
426
427     outRects.resize(regionData->rdh.nCount);
428
429     RECT* rect = reinterpret_cast<RECT*>(regionData->Buffer);
430     for (size_t i = 0; i < outRects.size(); ++i, ++rect)
431         outRects[i] = winRectToCGRect(*rect, clientRect);
432 }
433
434 void CACFLayerTreeHost::renderTimerFired(Timer<CACFLayerTreeHost>*)
435 {
436     paint();
437 }
438
439 void CACFLayerTreeHost::paint()
440 {
441     createRenderer();
442     if (!m_d3dDevice) {
443         if (m_mightBeAbleToCreateDeviceLater)
444             renderSoon();
445         return;
446     }
447
448     Vector<CGRect> dirtyRects;
449     getDirtyRects(m_window, dirtyRects);
450     render(dirtyRects);
451 }
452
453 void CACFLayerTreeHost::render(const Vector<CGRect>& windowDirtyRects)
454 {
455     ASSERT(m_d3dDevice);
456
457     if (m_mustResetLostDeviceBeforeRendering && !resetDevice(LostDevice)) {
458         // We can't reset the device right now. Try again soon.
459         renderSoon();
460         return;
461     }
462
463     CGRect bounds = this->bounds();
464
465     // Give the renderer some space to use. This needs to be valid until the
466     // wkCACFContextFinishUpdate() call below.
467     char space[4096];
468     if (!wkCACFContextBeginUpdate(m_context, space, sizeof(space), CACurrentMediaTime(), bounds, windowDirtyRects.data(), windowDirtyRects.size()))
469         return;
470
471     HRESULT err = S_OK;
472     CFTimeInterval timeToNextRender = numeric_limits<CFTimeInterval>::infinity();
473
474     do {
475         // FIXME: don't need to clear dirty region if layer tree is opaque.
476
477         WKCACFUpdateRectEnumerator* e = wkCACFContextCopyUpdateRectEnumerator(m_context);
478         if (!e)
479             break;
480
481         Vector<D3DRECT, 64> rects;
482         for (const CGRect* r = wkCACFUpdateRectEnumeratorNextRect(e); r; r = wkCACFUpdateRectEnumeratorNextRect(e)) {
483             D3DRECT rect;
484             rect.x1 = r->origin.x;
485             rect.x2 = rect.x1 + r->size.width;
486             rect.y1 = bounds.origin.y + bounds.size.height - (r->origin.y + r->size.height);
487             rect.y2 = rect.y1 + r->size.height;
488
489             rects.append(rect);
490         }
491         wkCACFUpdateRectEnumeratorRelease(e);
492
493         timeToNextRender = wkCACFContextGetNextUpdateTime(m_context);
494
495         if (rects.isEmpty())
496             break;
497
498         m_d3dDevice->Clear(rects.size(), rects.data(), D3DCLEAR_TARGET, 0, 1.0f, 0);
499
500         m_d3dDevice->BeginScene();
501         wkCACFContextRenderUpdate(m_context);
502         m_d3dDevice->EndScene();
503
504         err = m_d3dDevice->Present(0, 0, 0, 0);
505
506         if (err == D3DERR_DEVICELOST) {
507             wkCACFContextAddUpdateRect(m_context, bounds);
508             if (!resetDevice(LostDevice)) {
509                 // We can't reset the device right now. Try again soon.
510                 renderSoon();
511                 return;
512             }
513         }
514     } while (err == D3DERR_DEVICELOST);
515
516     wkCACFContextFinishUpdate(m_context);
517
518 #ifndef NDEBUG
519     if (m_printTree)
520         m_rootLayer->printTree();
521 #endif
522
523     // If timeToNextRender is not infinity, it means animations are running, so queue up to render again
524     if (timeToNextRender != numeric_limits<CFTimeInterval>::infinity())
525         renderSoon();
526 }
527
528 void CACFLayerTreeHost::renderSoon()
529 {
530     if (!m_renderTimer.isActive())
531         m_renderTimer.startOneShot(0);
532 }
533
534 void CACFLayerTreeHost::flushPendingGraphicsLayerChangesSoon()
535 {
536     m_shouldFlushPendingGraphicsLayerChanges = true;
537     LayerChangesFlusher::shared().flushPendingLayerChangesSoon(this);
538 }
539
540 void CACFLayerTreeHost::flushPendingLayerChangesNow()
541 {
542     // Calling out to the client could cause our last reference to go away.
543     RefPtr<CACFLayerTreeHost> protector(this);
544
545     m_isFlushingLayerChanges = true;
546
547     // Flush changes stored up in GraphicsLayers to their underlying PlatformCALayers, if
548     // requested.
549     if (m_client && m_shouldFlushPendingGraphicsLayerChanges) {
550         m_shouldFlushPendingGraphicsLayerChanges = false;
551         m_client->flushPendingGraphicsLayerChanges();
552     }
553
554     // Flush changes stored up in PlatformCALayers to the context so they will be rendered.
555     wkCACFContextFlush(m_context);
556
557     renderSoon();
558
559     // All pending animations will have been started with the flush. Fire the animationStarted calls.
560     notifyAnimationsStarted();
561
562     m_isFlushingLayerChanges = false;
563 }
564
565 void CACFLayerTreeHost::notifyAnimationsStarted()
566 {
567     double currentTime = WTF::currentTime();
568     double time = currentTime + wkCACFContextGetLastCommitTime(m_context) - CACurrentMediaTime();
569     ASSERT(time <= currentTime);
570
571     HashSet<RefPtr<PlatformCALayer> >::iterator end = m_pendingAnimatedLayers.end();
572     for (HashSet<RefPtr<PlatformCALayer> >::iterator it = m_pendingAnimatedLayers.begin(); it != end; ++it)
573         (*it)->animationStarted(time);
574
575     m_pendingAnimatedLayers.clear();
576 }
577
578 CGRect CACFLayerTreeHost::bounds() const
579 {
580     RECT clientRect;
581     GetClientRect(m_window, &clientRect);
582
583     return winRectToCGRect(clientRect);
584 }
585
586 void CACFLayerTreeHost::initD3DGeometry()
587 {
588     ASSERT(m_d3dDevice);
589
590     CGRect bounds = this->bounds();
591
592     float x0 = bounds.origin.x;
593     float y0 = bounds.origin.y;
594     float x1 = x0 + bounds.size.width;
595     float y1 = y0 + bounds.size.height;
596
597     D3DXMATRIXA16 projection;
598     D3DXMatrixOrthoOffCenterRH(&projection, x0, x1, y0, y1, -1.0f, 1.0f);
599
600     m_d3dDevice->SetTransform(D3DTS_PROJECTION, &projection);
601 }
602
603 bool CACFLayerTreeHost::resetDevice(ResetReason reason)
604 {
605     ASSERT(m_d3dDevice);
606     ASSERT(m_context);
607
608     HRESULT hr = m_d3dDevice->TestCooperativeLevel();
609
610     if (hr == D3DERR_DEVICELOST || hr == D3DERR_DRIVERINTERNALERROR) {
611         // The device cannot be reset at this time. Try again soon.
612         m_mustResetLostDeviceBeforeRendering = true;
613         return false;
614     }
615
616     m_mustResetLostDeviceBeforeRendering = false;
617
618     if (reason == LostDevice && hr == D3D_OK) {
619         // The device wasn't lost after all.
620         return true;
621     }
622
623     // We can reset the device.
624
625     // We have to release the context's D3D resrouces whenever we reset the IDirect3DDevice9 in order to
626     // destroy any D3DPOOL_DEFAULT resources that Core Animation has allocated (e.g., textures used
627     // for mask layers). See <http://msdn.microsoft.com/en-us/library/bb174425(v=VS.85).aspx>.
628     wkCACFContextReleaseD3DResources(m_context);
629
630     D3DPRESENT_PARAMETERS parameters = initialPresentationParameters();
631     hr = m_d3dDevice->Reset(&parameters);
632
633     // TestCooperativeLevel told us the device may be reset now, so we should
634     // not be told here that the device is lost.
635     ASSERT(hr != D3DERR_DEVICELOST);
636
637     initD3DGeometry();
638
639     return true;
640 }
641
642 }
643
644 #endif // USE(ACCELERATED_COMPOSITING)