Use antialiasing and bitmap filtering when needed in software compositor.

cc/CCRendererSoftware.cpp

 // 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 "config.h"
 
 #include "CCRendererSoftware.h"
 
 #include "CCDebugBorderDrawQuad.h"
 #include "CCSolidColorDrawQuad.h"
 #include "CCTextureDrawQuad.h"
 #include "CCTileDrawQuad.h"
 #include "CCRenderPassDrawQuad.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.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 <public/WebImage.h>
 #include <public/WebSize.h>
 #include <public/WebTransformationMatrix.h>
+#include <limits>
 
 using WebKit::WebCompositorSoftwareOutputDevice;
 using WebKit::WebImage;
 using WebKit::WebSize;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 namespace {
 
@@ skipping 14 matching lines @@
     flattened->set(1, m.m21());
     flattened->set(2, m.m41());
     flattened->set(3, m.m12());
     flattened->set(4, m.m22());
     flattened->set(5, m.m42());
     flattened->set(6, m.m14());
     flattened->set(7, m.m24());
     flattened->set(8, m.m44());
 }
 
+bool isZero(float f)

[aelias_OOO_until_Jul13, 2012/10/12 21:26:56]

No need for this method.  You can use SkScalarNearlyZero and SkScalarNearlyEqual
from SkScalar.h.

+{
+    return abs(f) < std::numeric_limits<float>::epsilon();

[danakj, 2012/10/12 21:24:37]

thanks! i think this should be std::abs() as well or it might break when we
remove webcore headers.

+}
+
+bool isScaleAndTranslate(const SkMatrix& matrix)
+{
+    return isZero(matrix[SkMatrix::kMSkewX]) &&
+           isZero(matrix[SkMatrix::kMSkewY]) &&
+           isZero(matrix[SkMatrix::kMPersp0]) &&
+           isZero(matrix[SkMatrix::kMPersp1]) &&
+           isZero(matrix[SkMatrix::kMPersp2] - 1.0f);
+}
+
 } // anonymous namespace
 
 PassOwnPtr<CCRendererSoftware> CCRendererSoftware::create(CCRendererClient* client, CCResourceProvider* resourceProvider, WebCompositorSoftwareOutputDevice* outputDevice)
 {
     return adoptPtr(new CCRendererSoftware(client, resourceProvider, outputDevice));
 }
 
 CCRendererSoftware::CCRendererSoftware(CCRendererClient* client, CCResourceProvider* resourceProvider, WebCompositorSoftwareOutputDevice* outputDevice)
     : CCDirectRenderer(client, resourceProvider)
     , m_visible(true)
@@ skipping 105 matching lines @@
 void CCRendererSoftware::drawQuad(DrawingFrame& frame, const CCDrawQuad* quad)
 {
     WebTransformationMatrix quadRectMatrix;
     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->quadRect());
     WebTransformationMatrix contentsDeviceTransform = (frame.windowMatrix * frame.projectionMatrix * quadRectMatrix).to2dTransform();
     SkMatrix skDeviceMatrix;
     toSkMatrix(&skDeviceMatrix, contentsDeviceTransform);
     m_skCurrentCanvas->setMatrix(skDeviceMatrix);
 
     m_skCurrentPaint.reset();
+    if (!isScaleAndTranslate(skDeviceMatrix)) {
+        m_skCurrentPaint.setAntiAlias(true);
+        m_skCurrentPaint.setFilterBitmap(true);
+    }
     if (quad->needsBlending()) {
         m_skCurrentPaint.setAlpha(quad->opacity() * 255);
         m_skCurrentPaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
     } else {
         m_skCurrentPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
     }
 
     switch (quad->material()) {
     case CCDrawQuad::DebugBorder:
         drawDebugBorderQuad(frame, CCDebugBorderDrawQuad::materialCast(quad));
@@ skipping 145 matching lines @@
 }
 
 void CCRendererSoftware::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
     m_visible = visible;
 }
 
 }