Enabled partial swap support for 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"
 #include "cc/software_output_device.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/tile_draw_quad.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebImage.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/include/effects/SkLayerRasterizer.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 namespace {
@@ skipping 24 matching lines @@
 } // anonymous namespace
 
 scoped_ptr<SoftwareRenderer> SoftwareRenderer::create(RendererClient* client, ResourceProvider* resourceProvider, SoftwareOutputDevice* outputDevice)
 {
     return make_scoped_ptr(new SoftwareRenderer(client, resourceProvider, outputDevice));
 }
 
 SoftwareRenderer::SoftwareRenderer(RendererClient* client, ResourceProvider* resourceProvider, SoftwareOutputDevice* outputDevice)
     : DirectRenderer(client, resourceProvider)
     , m_visible(true)
+    , m_isScissorEnabled(false)
     , 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
 {
@@ skipping 20 matching lines @@
     m_outputDevice->Unlock();
 }
 
 bool SoftwareRenderer::flippedFramebuffer() const
 {
     return false;
 }
 
 void SoftwareRenderer::ensureScissorTestEnabled()
 {
-    // Nothing to do here. Current implementation of software rendering has no
-    // notion of enabling/disabling the feature.
+    m_isScissorEnabled = true;
+    setClipRect(m_scissorRect);
 }
 
 void SoftwareRenderer::ensureScissorTestDisabled()
 {
     // There is no explicit notion of enabling/disabling scissoring in software
     // rendering, but the underlying effect we want is to clear any existing
     // clipRect on the current SkCanvas. This is done by setting clipRect to
     // the viewport's dimensions.
-    SkISize canvasSize = m_skCurrentCanvas->getDeviceSize();
-    SkRect canvasRect = SkRect::MakeXYWH(0, 0, canvasSize.width(), canvasSize.height());
-    m_skCurrentCanvas->clipRect(canvasRect, SkRegion::kReplace_Op);
+    m_isScissorEnabled = false;
+    SkDevice* device = m_skCurrentCanvas->getDevice();
+    setClipRect(gfx::Rect(device->width(), device->height()));
 }
 
 void SoftwareRenderer::finish()
 {
 }
 
 void SoftwareRenderer::bindFramebufferToOutputSurface(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
     m_skCurrentCanvas = m_skRootCanvas.get();
 }
 
 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);
+    m_isScissorEnabled = true;
+    m_scissorRect = scissorRect;
+    setClipRect(scissorRect);
+}
+
+void SoftwareRenderer::setClipRect(const gfx::Rect& rect)
+{
+    // Skia applies the current matrix to clip rects so we reset it temporary.
+    SkMatrix currentMatrix = m_skCurrentCanvas->getTotalMatrix();
+    m_skCurrentCanvas->resetMatrix();
+    m_skCurrentCanvas->clipRect(gfx::RectToSkRect(rect), SkRegion::kReplace_Op);
+    m_skCurrentCanvas->setMatrix(currentMatrix);
+}
+
+void SoftwareRenderer::clearCanvas(SkColor color)
+{
+    // SkCanvas::clear doesn't respect the current clipping region
+    // so we SkCanvas::drawColor instead if scissoring is active.
+    if (m_isScissorEnabled)
+        m_skCurrentCanvas->drawColor(color, SkXfermode::kSrc_Mode);
+    else
+        m_skCurrentCanvas->clear(color);
 }
 
 void SoftwareRenderer::clearFramebuffer(DrawingFrame& frame)
 {
     if (frame.currentRenderPass->has_transparent_background) {
-        m_skCurrentCanvas->clear(SkColorSetARGB(0, 0, 0, 0));
+        clearCanvas(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));
+        clearCanvas(SkColorSetARGB(255, 0, 0, 255));
 #endif
     }
 }
 
 void SoftwareRenderer::setDrawViewportSize(const gfx::Size& viewportSize)
 {
 }
 
 bool SoftwareRenderer::isSoftwareResource(ResourceProvider::ResourceId id) const
 {
@@ skipping 115 matching lines @@
 void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const RenderPassDrawQuad* quad)
 {
     CachedResource* contentTexture = m_renderPassTextures.get(quad->render_pass_id);
     if (!contentTexture || !contentTexture->id())
         return;
 
     DCHECK(isSoftwareResource(contentTexture->id()));
     ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, contentTexture->id());
 
     SkRect destRect = gfx::RectFToSkRect(quadVertexRect());
-
-    const SkBitmap* content = lock.skBitmap();
-
-    SkRect contentRect;
-    content->getBounds(&contentRect);
+    SkRect contentRect = SkRect::MakeWH(quad->rect.width(), quad->rect.height());
 
     SkMatrix contentMat;
     contentMat.setRectToRect(contentRect, destRect, SkMatrix::kFill_ScaleToFit);
 
+    const SkBitmap* content = lock.skBitmap();
     skia::RefPtr<SkShader> shader = skia::AdoptRef(
         SkShader::CreateBitmapShader(*content,
                                      SkShader::kClamp_TileMode,
                                      SkShader::kClamp_TileMode));
     shader->setLocalMatrix(contentMat);
     m_skCurrentPaint.setShader(shader.get());
 
     SkImageFilter* filter = quad->filter.get();
     if (filter)
         m_skCurrentPaint.setImageFilter(filter);
@@ skipping 58 matching lines @@
 }
 
 void SoftwareRenderer::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
     m_visible = visible;
 }
 
 }  // namespace cc