[CLOSED] In-browser software compositing

cc/software_renderer.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/software_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/math_util.h"
 #include "cc/render_pass_draw_quad.h"
@@ skipping 51 matching lines @@
     , m_outputDevice(outputDevice)
     , m_skCurrentCanvas(0)
 {
     m_resourceProvider->setDefaultResourceType(ResourceProvider::Bitmap);
 
     m_capabilities.maxTextureSize = m_resourceProvider->maxTextureSize();
     m_capabilities.bestTextureFormat = m_resourceProvider->bestTextureFormat();
     m_capabilities.usingSetVisibility = true;
     // The updater can access bitmaps while the SoftwareRenderer is using them.
     m_capabilities.allowPartialTextureUpdates = true;
+    m_capabilities.usingPartialSwap = true;
 
     viewportChanged();
 }
 
 SoftwareRenderer::~SoftwareRenderer()
 {
 }
 
 const RendererCapabilities& SoftwareRenderer::capabilities() const
 {
     return m_capabilities;
 }
 
 void SoftwareRenderer::viewportChanged()
 {
-    m_outputDevice->DidChangeViewportSize(viewportSize());
+    m_outputDevice->Resize(viewportSize());
 }
 
 void SoftwareRenderer::beginDrawingFrame(DrawingFrame& frame)
 {
     TRACE_EVENT0("cc", "SoftwareRenderer::beginDrawingFrame");
-    m_skRootCanvas = make_scoped_ptr(new SkCanvas(m_outputDevice->Lock(true)->getSkBitmap()));
+    m_skRootCanvas = m_outputDevice->BeginPaint();
 }
 
 void SoftwareRenderer::finishDrawingFrame(DrawingFrame& frame)
 {
     TRACE_EVENT0("cc", "SoftwareRenderer::finishDrawingFrame");
     m_currentFramebufferLock.reset();
-    m_skCurrentCanvas = 0;
-    m_skRootCanvas.reset();
-    m_outputDevice->Unlock();
+    m_skCurrentCanvas = NULL;
+    m_skRootCanvas = NULL;
+    m_outputDevice->EndPaint(gfx::ToEnclosingRect(frame.rootDamageRect));
 }
 
 bool SoftwareRenderer::flippedFramebuffer() const
 {
     return false;
 }
 
 void SoftwareRenderer::ensureScissorTestEnabled()
 {
     // Nothing to do here. Current implementation of software rendering has no
@@ skipping 11 matching lines @@
     m_skCurrentCanvas->clipRect(canvasRect, SkRegion::kReplace_Op);
 }
 
 void SoftwareRenderer::finish()
 {
 }
 
 void SoftwareRenderer::bindFramebufferToOutputSurface(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
-    m_skCurrentCanvas = m_skRootCanvas.get();
+    m_skCurrentCanvas = m_skRootCanvas;
 }
 
 bool SoftwareRenderer::bindFramebufferToTexture(DrawingFrame& frame, const ScopedResource* texture, const gfx::Rect& framebufferRect)
 {
     m_currentFramebufferLock = make_scoped_ptr(new ResourceProvider::ScopedWriteLockSoftware(m_resourceProvider, texture->id()));
     m_skCurrentCanvas = m_currentFramebufferLock->skCanvas();
     initializeMatrices(frame, framebufferRect, false);
     setDrawViewportSize(framebufferRect.size());
 
     return true;
 }
 
 void SoftwareRenderer::setScissorTestRect(const gfx::Rect& scissorRect)
 {
     m_skCurrentCanvas->clipRect(gfx::RectToSkRect(scissorRect), SkRegion::kReplace_Op);
 }
 
 void SoftwareRenderer::clearFramebuffer(DrawingFrame& frame)
 {
     if (frame.currentRenderPass->has_transparent_background) {
         m_skCurrentCanvas->clear(SkColorSetARGB(0, 0, 0, 0));
     } else {
 #ifndef NDEBUG
         // On DEBUG builds, opaque render passes are cleared to blue to easily see regions that were not drawn on the screen.
-        m_skCurrentCanvas->clear(SkColorSetARGB(255, 0, 0, 255));
+        SkPaint paint = m_skCurrentPaint;
+        paint.setColor(SkColorSetARGB(255, 0, 0, 255));
+        m_skCurrentCanvas->drawPaint(paint);
 #endif
     }
 }
 
 void SoftwareRenderer::setDrawViewportSize(const gfx::Size& viewportSize)
 {
 }
 
 bool SoftwareRenderer::isSoftwareResource(ResourceProvider::ResourceId id) const
 {
@@ skipping 186 matching lines @@
 bool SoftwareRenderer::swapBuffers()
 {
     if (m_client->hasImplThread())
         m_client->onSwapBuffersComplete();
     return true;
 }
 
 void SoftwareRenderer::getFramebufferPixels(void *pixels, const gfx::Rect& rect)
 {
     TRACE_EVENT0("cc", "SoftwareRenderer::getFramebufferPixels");
-    SkBitmap fullBitmap = m_outputDevice->Lock(false)->getSkBitmap();
     SkBitmap subsetBitmap;
-    SkIRect invertRect = SkIRect::MakeXYWH(rect.x(), viewportSize().height() - rect.bottom(), rect.width(), rect.height());
-    fullBitmap.extractSubset(&subsetBitmap, invertRect);
-    subsetBitmap.copyPixelsTo(pixels, rect.width() * rect.height() * 4, rect.width() * 4);
-    m_outputDevice->Unlock();
+    m_outputDevice->CopyToBitmap(rect, &subsetBitmap);
+    subsetBitmap.copyPixelsTo(pixels,
+                              4 * rect.width() * rect.height(),
+                              4 * rect.width());
 }
 
 void SoftwareRenderer::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
     m_visible = visible;
 }
 
 }  // namespace cc