remove SkDeviceProperties

src/core/SkPaint.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPaint.h"
 #include "SkAnnotation.h"
 #include "SkAutoKern.h"
 #include "SkChecksum.h"
 #include "SkColorFilter.h"
 #include "SkData.h"
-#include "SkDeviceProperties.h"
 #include "SkDraw.h"
 #include "SkFontDescriptor.h"
 #include "SkGlyphCache.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkMaskGamma.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkPaintDefaults.h"
 #include "SkPathEffect.h"
 #include "SkRasterizer.h"
 #include "SkScalar.h"
 #include "SkScalerContext.h"
 #include "SkShader.h"
 #include "SkStringUtils.h"
 #include "SkStroke.h"
 #include "SkTextFormatParams.h"
 #include "SkTextToPathIter.h"
 #include "SkTLazy.h"
 #include "SkTypeface.h"
+#include "SkSurfacePriv.h"
 #include "SkXfermode.h"
 
 // define this to get a printf for out-of-range parameter in setters
 // e.g. setTextSize(-1)
 //#define SK_REPORT_API_RANGE_CHECK
 
 SkPaint::SkPaint() {
     fTypeface    = NULL;
     fPathEffect  = NULL;
     fShader      = NULL;
@@ skipping 1277 matching lines @@
  *  Return the scalar with only limited fractional precision. Used to consolidate matrices
  *  that vary only slightly when we create our key into the font cache, since the font scaler
  *  typically returns the same looking resuts for tiny changes in the matrix.
  */
 static SkScalar sk_relax(SkScalar x) {
     int n = sk_float_round2int(x * 1024);
     return n / 1024.0f;
 }
 
 void SkScalerContext::MakeRec(const SkPaint& paint,
-                              const SkDeviceProperties* deviceProperties,
+                              const SkSurfaceProps* surfaceProps,
                               const SkMatrix* deviceMatrix,
                               Rec* rec) {
     SkASSERT(deviceMatrix == NULL || !deviceMatrix->hasPerspective());
 
     SkTypeface* typeface = paint.getTypeface();
     if (NULL == typeface) {
         typeface = SkTypeface::GetDefaultTypeface();
     }
     rec->fFontID = typeface->uniqueID();
     rec->fTextSize = paint.getTextSize();
@@ skipping 65 matching lines @@
         rec->fStrokeJoin = 0;
     }
 
     rec->fMaskFormat = SkToU8(computeMaskFormat(paint));
 
     if (SkMask::kLCD16_Format == rec->fMaskFormat) {
         if (too_big_for_lcd(*rec, checkPost2x2)) {
             rec->fMaskFormat = SkMask::kA8_Format;
             flags |= SkScalerContext::kGenA8FromLCD_Flag;
         } else {
-            SkPixelGeometry geometry = deviceProperties
-                                     ? deviceProperties->pixelGeometry()
+            SkPixelGeometry geometry = surfaceProps
+                                     ? surfaceProps->pixelGeometry()
                                      : SkSurfacePropsDefaultPixelGeometry();
             switch (geometry) {
                 case kUnknown_SkPixelGeometry:
                     // eeek, can't support LCD
                     rec->fMaskFormat = SkMask::kA8_Format;
                     flags |= SkScalerContext::kGenA8FromLCD_Flag;
                     break;
                 case kRGB_H_SkPixelGeometry:
                     // our default, do nothing.
                     break;
@@ skipping 166 matching lines @@
         add_flattenable(desc, kMaskFilter_SkDescriptorTag, mfBuffer);
     }
     if (ra) {
         add_flattenable(desc, kRasterizer_SkDescriptorTag, raBuffer);
     }
 
     desc->computeChecksum();
 }
 
 static size_t fill_out_rec(const SkPaint& paint, SkScalerContext::Rec* rec,
-                           const SkDeviceProperties* deviceProperties,
+                           const SkSurfaceProps* surfaceProps,
                            const SkMatrix* deviceMatrix, bool ignoreGamma,
                            const SkPathEffect* pe, SkWriteBuffer* peBuffer,
                            const SkMaskFilter* mf, SkWriteBuffer* mfBuffer,
                            const SkRasterizer* ra, SkWriteBuffer* raBuffer) {
-    SkScalerContext::MakeRec(paint, deviceProperties, deviceMatrix, rec);
+    SkScalerContext::MakeRec(paint, surfaceProps, deviceMatrix, rec);
     if (ignoreGamma) {
         rec->ignorePreBlend();
     }
 
     int entryCount = 1;
     size_t descSize = sizeof(*rec);
 
     if (pe) {
         peBuffer->writeFlattenable(pe);
         descSize += peBuffer->bytesWritten();
@@ skipping 69 matching lines @@
     SkASSERT(descSize == desc2->getLength());
     desc1->computeChecksum();
     desc2->computeChecksum();
     SkASSERT(!memcmp(desc, desc1, descSize));
     SkASSERT(!memcmp(desc, desc2, descSize));
 }
 #endif
 
 /* see the note on ignoreGamma on descriptorProc */
 void SkPaint::getScalerContextDescriptor(SkAutoDescriptor* ad,
-                                         const SkDeviceProperties* deviceProperties,
+                                         const SkSurfaceProps& surfaceProps,
                                          const SkMatrix* deviceMatrix, bool ignoreGamma) const {
     SkScalerContext::Rec    rec;
 
     SkPathEffect*   pe = this->getPathEffect();
     SkMaskFilter*   mf = this->getMaskFilter();
     SkRasterizer*   ra = this->getRasterizer();
 
     SkWriteBuffer   peBuffer, mfBuffer, raBuffer;
-    size_t descSize = fill_out_rec(*this, &rec, deviceProperties, deviceMatrix, ignoreGamma,
+    size_t descSize = fill_out_rec(*this, &rec, &surfaceProps, deviceMatrix, ignoreGamma,
                                    pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer);
 
     ad->reset(descSize);
     SkDescriptor* desc = ad->getDesc();
 
     write_out_descriptor(desc, rec, pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer, descSize);
 
     SkASSERT(descSize == desc->getLength());
 
 #ifdef TEST_DESC
     test_desc(rec, pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer, desc, descSize);
 #endif
 }
 
 /*
  *  ignoreGamma tells us that the caller just wants metrics that are unaffected
  *  by gamma correction, so we set the rec to ignore preblend: i.e. gamma = 1,
  *  contrast = 0, luminanceColor = transparent black.
  */
-void SkPaint::descriptorProc(const SkDeviceProperties* deviceProperties,
+void SkPaint::descriptorProc(const SkSurfaceProps* surfaceProps,
                              const SkMatrix* deviceMatrix,
                              void (*proc)(SkTypeface*, const SkDescriptor*, void*),
                              void* context, bool ignoreGamma) const {
     SkScalerContext::Rec    rec;
 
     SkPathEffect*   pe = this->getPathEffect();
     SkMaskFilter*   mf = this->getMaskFilter();
     SkRasterizer*   ra = this->getRasterizer();
 
     SkWriteBuffer   peBuffer, mfBuffer, raBuffer;
-    size_t descSize = fill_out_rec(*this, &rec, deviceProperties, deviceMatrix, ignoreGamma,
+    size_t descSize = fill_out_rec(*this, &rec, surfaceProps, deviceMatrix, ignoreGamma,
                                    pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer);
 
     SkAutoDescriptor    ad(descSize);
     SkDescriptor*       desc = ad.getDesc();
 
     write_out_descriptor(desc, rec, pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer, descSize);
 
     SkASSERT(descSize == desc->getLength());
 
 #ifdef TEST_DESC
     test_desc(rec, pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer, desc, descSize);
 #endif
 
     proc(fTypeface, desc, context);
 }
 
-SkGlyphCache* SkPaint::detachCache(const SkDeviceProperties* deviceProperties,
+SkGlyphCache* SkPaint::detachCache(const SkSurfaceProps* surfaceProps,
                                    const SkMatrix* deviceMatrix,
                                    bool ignoreGamma) const {
     SkGlyphCache* cache;
-    this->descriptorProc(deviceProperties, deviceMatrix, DetachDescProc, &cache, ignoreGamma);
+    this->descriptorProc(surfaceProps, deviceMatrix, DetachDescProc, &cache, ignoreGamma);
     return cache;
 }
 
 /**
  * Expands fDeviceGamma, fPaintGamma, fContrast, and fLumBits into a mask pre-blend.
  */
 //static
 SkMaskGamma::PreBlend SkScalerContext::GetMaskPreBlend(const SkScalerContext::Rec& rec) {
     SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
     const SkMaskGamma& maskGamma = cachedMaskGamma(rec.getContrast(),
@@ skipping 509 matching lines @@
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool has_thick_frame(const SkPaint& paint) {
     return  paint.getStrokeWidth() > 0 &&
             paint.getStyle() != SkPaint::kFill_Style;
 }
 
-SkTextToPathIter::SkTextToPathIter( const char text[], size_t length,
-                                    const SkPaint& paint,
-                                    bool applyStrokeAndPathEffects)
-                                    : fPaint(paint) {
+SkTextToPathIter::SkTextToPathIter(const char text[], size_t length,
+                                   const SkPaint& paint,
+                                   bool applyStrokeAndPathEffects)
+    : fPaint(paint) {
     fGlyphCacheProc = paint.getMeasureCacheProc(true);
 
     fPaint.setLinearText(true);
     fPaint.setMaskFilter(NULL);   // don't want this affecting our path-cache lookup
 
     if (fPaint.getPathEffect() == NULL && !has_thick_frame(fPaint)) {
         applyStrokeAndPathEffects = false;
     }
 
     // can't use our canonical size if we need to apply patheffects
@@ skipping 114 matching lines @@
 }
 
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
     SK_COMPILE_ASSERT(offsetof(SkPaint, fBitfields) == 10 * sizeof(void*) + 6 * sizeof(uint32_t),
                       SkPaint_notPackedTightly);
     return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(this),
                                offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }