Implementing ACCELERATED_COMPOSITING via Skia

WebKit/chromium/src/WebViewImpl.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 92 matching lines @@
 #include "KeyboardCodesWin.h"
 #include "RenderThemeChromiumWin.h"
 #else
 #if OS(LINUX)
 #include "RenderThemeChromiumLinux.h"
 #endif
 #include "KeyboardCodesPosix.h"
 #include "RenderTheme.h"
 #endif
 
+#if USE(ACCELERATED_COMPOSITING)
+#include "webkit/glue/webkit_glue.h"
+#if WEBKIT_USING_SKIA
+#include "skia/LayerSkia.h"
+#endif
+#endif
+
 // Get rid of WTF's pow define so we can use std::pow.
 #undef pow
 #include <cmath> // for std::pow
 
 using namespace WebCore;
 
 namespace WebKit {
 
 // Change the text zoom level by kTextSizeMultiplierRatio each time the user
 // zooms text in or out (ie., change by 20%).  The min and max values limit
@@ skipping 115 matching lines @@
     , m_dragTargetDispatch(false)
     , m_dragIdentity(0)
     , m_dropEffect(DropEffectDefault)
     , m_operationsAllowed(WebDragOperationNone)
     , m_dragOperation(WebDragOperationNone)
     , m_suggestionsPopupShowing(false)
     , m_suggestionsPopupClient(0)
     , m_suggestionsPopup(0)
     , m_isTransparent(false)
     , m_tabsToLinks(false)
+#if USE(ACCELERATED_COMPOSITING)
+    , m_layerRenderer(0)
+    , m_isAcceleratedCompositing(false)
+#endif
 {
     // WebKit/win/WebView.cpp does the same thing, except they call the
     // KJS specific wrapper around this method. We need to have threading
     // initialized because CollatorICU requires it.
     WTF::initializeThreading();
 
     // set to impossible point so we always get the first mouse pos
     m_lastMousePosition = WebPoint(-1, -1);
 
     // the page will take ownership of the various clients
@@ skipping 608 matching lines @@
 
         // setFrameRect may have the side-effect of causing existing page
         // layout to be invalidated, so layout needs to be called last.
 
         webframe->layout();
     }
 }
 
 void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect)
 {
-    WebFrameImpl* webframe = mainFrameImpl();
-    if (webframe)
-        webframe->paint(canvas, rect);
+
+#if USE(ACCELERATED_COMPOSITING)
+    if (!isAcceleratedCompositing()) {
+#endif
+        WebFrameImpl* webframe = mainFrameImpl();
+        if (webframe)
+            webframe->paint(canvas, rect);
+#if USE(ACCELERATED_COMPOSITING)
+    } else {
+        // Draw the contents of the root layer
+        updateRootLayerContents(rect);
+
+        // Composite everything into the canvas that's passed to us.
+        m_layerRenderer->updateLayerContents();
+        SkIRect canvasIRect;
+        canvasIRect.set(rect.x, rect.y, rect.x+rect.width, rect.y+rect.height);
+        SkRect canvasRect;
+        canvasRect.set(canvasIRect);
+        m_layerRenderer->drawLayersInCanvas(static_cast<skia::PlatformCanvas*>(canvas), canvasRect);
+    }
+#endif
 }
 
 // FIXME: m_currentInputEvent should be removed once ChromeClient::show() can
 // get the current-event information from WebCore.
 const WebInputEvent* WebViewImpl::m_currentInputEvent = 0;
 
 bool WebViewImpl::handleInputEvent(const WebInputEvent& inputEvent)
 {
     // If we've started a drag and drop operation, ignore input events until
     // we're done.
@@ skipping 1020 matching lines @@
 void WebViewImpl::setTabsToLinks(bool enable)
 {
     m_tabsToLinks = enable;
 }
 
 bool WebViewImpl::tabsToLinks() const
 {
     return m_tabsToLinks;
 }
 
+#if USE(ACCELERATED_COMPOSITING)
+void WebViewImpl::setRootGraphicsLayer(WebCore::PlatformLayer* layer)
+{
+    setAcceleratedCompositing(layer ? true : false);
+    if (m_layerRenderer)
+        m_layerRenderer->setRootLayer(layer);
+}
+
+void WebViewImpl::setAcceleratedCompositing(bool accelerated)
+{
+    if (m_isAcceleratedCompositing == accelerated)
+        return;
+
+    if (accelerated) {
+        m_layerRenderer = LayerRendererSkia::create();
+        if (m_layerRenderer) {
+            m_isAcceleratedCompositing = true;
+        }
+    } else {
+        m_layerRenderer = 0;
+        m_isAcceleratedCompositing = false;
+    }
+}
+
+void WebViewImpl::updateRootLayerContents(const WebRect& rect)
+{
+    if (!isAcceleratedCompositing())
+        return;
+
+    WebFrameImpl* webframe = mainFrameImpl();
+    if (webframe) {
+        FrameView* view = webframe->frameView();
+        if (view) {
+            WebRect viewRect = view->frameRect();
+            
+
+            SkIRect scrollFrame;
+            scrollFrame.set(view->scrollX(), view->scrollY(), view->layoutWidth()+view->scrollX(), view->layoutHeight()+view->scrollY());
+            m_layerRenderer->setScrollFrame(scrollFrame);
+            LayerSkia* rootLayer = m_layerRenderer->rootLayer();
+            if (rootLayer) {
+                SkIRect rootLayerBounds;
+                IntRect visibleRect = view->visibleContentRect(true);
+
+                // Set the backing store size used by the root layer to be the size of the visible
+                // area.  Note that the root layer bounds could be larger than the backing store size
+                // but there's no reason to waste memory by allocating backing store larger than the
+                // visible portion.
+                rootLayerBounds.set(0, 0, visibleRect.width(), visibleRect.height());
+                rootLayer->setBackingStoreRect(rootLayerBounds);
+                GraphicsContext* rootLayerContext = rootLayer->graphicsContext();
+                rootLayerContext->save();
+
+                webframe->paintWithContext(*(rootLayer->graphicsContext()), rect);
+                rootLayerContext->restore();
+            }
+        }
+    }
+}
+
+void WebViewImpl::setRootLayerNeedsDisplay()
+{
+    // TODO(vangelis): For now we're posting a repaint event for the entire page
+    //                 which is an overkill.
+    WebFrameImpl* webframe = mainFrameImpl();
+    if (webframe) {
+        FrameView* view = webframe->frameView();
+        if (view) {
+            IntRect visibleRect = view->visibleContentRect(true);
+            m_client->didInvalidateRect(visibleRect);
+        }
+    }
+
+    if (m_layerRenderer)
+        m_layerRenderer->setNeedsDisplay();
+}
+
+#endif
+
 } // namespace WebKit