Revert of Fix color emoji.

src/gpu/GrTextStrike.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGpu.h"
 #include "GrRectanizer.h"
 #include "GrSurfacePriv.h"
@@ skipping 62 matching lines @@
         GrFontCache::k8888_AtlasType,
         GrFontCache::k8888_AtlasType
     };
     SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sAtlasIndices) == kMaskFormatCount, array_size_mismatch);
 
     SkASSERT(sAtlasIndices[format] < GrFontCache::kAtlasCount);
     return sAtlasIndices[format];
 }
 
 GrTextStrike* GrFontCache::generateStrike(GrFontScaler* scaler) {
-    GrTextStrike* strike = SkNEW_ARGS(GrTextStrike, (this, scaler->getKey()));
-    fCache.add(strike);
-
-    if (fHead) {
-        fHead->fPrev = strike;
-    } else {
-        SkASSERT(NULL == fTail);
-        fTail = strike;
-    }
-    strike->fPrev = NULL;
-    strike->fNext = fHead;
-    fHead = strike;
-
-    return strike;
-}
-
-void GrFontCache::freeAll() {
-    SkTDynamicHash<GrTextStrike, GrFontDescKey>::Iter iter(&fCache);
-    while (!iter.done()) {
-        SkDELETE(&(*iter));
-        ++iter;
-    }
-    fCache.rewind();
-    for (int i = 0; i < kAtlasCount; ++i) {
-        delete fAtlases[i];
-        fAtlases[i] = NULL;
-    }
-    fHead = NULL;
-    fTail = NULL;
-}
-
-void GrFontCache::purgeStrike(GrTextStrike* strike) {
-    fCache.remove(*(strike->fFontScalerKey));
-    this->detachStrikeFromList(strike);
-    delete strike;
-}
-
-
-GrPlot* GrFontCache::addToAtlas(GrMaskFormat format, GrAtlas::ClientPlotUsage* usage,
-                                int width, int height, const void* image,
-                                SkIPoint16* loc) {
+    GrMaskFormat format = scaler->getMaskFormat();
     GrPixelConfig config = mask_format_to_pixel_config(format);
     int atlasIndex = mask_format_to_atlas_index(format);
     if (NULL == fAtlases[atlasIndex]) {
         SkISize textureSize = SkISize::Make(GR_ATLAS_TEXTURE_WIDTH,
                                             GR_ATLAS_TEXTURE_HEIGHT);
         fAtlases[atlasIndex] = SkNEW_ARGS(GrAtlas, (fGpu, config, kNone_GrTextureFlags,
                                                     textureSize,
                                                     GR_NUM_PLOTS_X,
                                                     GR_NUM_PLOTS_Y,
                                                     true));
     }
-    return fAtlases[atlasIndex]->addToAtlas(usage, width, height, image, loc);
+    GrTextStrike* strike = SkNEW_ARGS(GrTextStrike,
+                                      (this, scaler->getKey(), format, fAtlases[atlasIndex]));
+    fCache.add(strike);
+
+    if (fHead) {
+        fHead->fPrev = strike;
+    } else {
+        SkASSERT(NULL == fTail);
+        fTail = strike;
+    }
+    strike->fPrev = NULL;
+    strike->fNext = fHead;
+    fHead = strike;
+
+    return strike;
 }
 
+void GrFontCache::freeAll() {
+    SkTDynamicHash<GrTextStrike, GrFontDescKey>::Iter iter(&fCache);
+    while (!iter.done()) {
+        SkDELETE(&(*iter));
+        ++iter;
+    }
+    fCache.rewind();
+    for (int i = 0; i < kAtlasCount; ++i) {
+        delete fAtlases[i];
+        fAtlases[i] = NULL;
+    }
+    fHead = NULL;
+    fTail = NULL;
+}
 
-bool GrFontCache::freeUnusedPlot(GrTextStrike* preserveStrike, const GrGlyph* glyph) {
+void GrFontCache::purgeStrike(GrTextStrike* strike) {
+    fCache.remove(*(strike->fFontScalerKey));
+    this->detachStrikeFromList(strike);
+    delete strike;
+}
+
+bool GrFontCache::freeUnusedPlot(GrTextStrike* preserveStrike) {
     SkASSERT(preserveStrike);
 
-    int index = mask_format_to_atlas_index(glyph->fMaskFormat);
-    GrAtlas* atlas = fAtlases[index];
+    GrAtlas* atlas = preserveStrike->fAtlas;
     GrPlot* plot = atlas->getUnusedPlot();
     if (NULL == plot) {
         return false;
     }
     plot->resetRects();
 
     GrTextStrike* strike = fHead;
+    GrMaskFormat maskFormat = preserveStrike->fMaskFormat;
     while (strike) {
+        if (maskFormat != strike->fMaskFormat) {
+            strike = strike->fNext;
+            continue;
+        }
+
         GrTextStrike* strikeToPurge = strike;
         strike = strikeToPurge->fNext;
         strikeToPurge->removePlot(plot);
 
         // clear out any empty strikes (except this one)
         if (strikeToPurge != preserveStrike && strikeToPurge->fPlotUsage.isEmpty()) {
             this->purgeStrike(strikeToPurge);
         }
     }
 
@@ skipping 60 matching lines @@
 #endif
 
 /*
     The text strike is specific to a given font/style/matrix setup, which is
     represented by the GrHostFontScaler object we are given in getGlyph().
 
     We map a 32bit glyphID to a GrGlyph record, which in turn points to a
     atlas and a position within that texture.
  */
 
-GrTextStrike::GrTextStrike(GrFontCache* cache, const GrFontDescKey* key) : fPool(64) {
+GrTextStrike::GrTextStrike(GrFontCache* cache, const GrFontDescKey* key,
+                           GrMaskFormat format,
+                           GrAtlas* atlas) : fPool(64) {
     fFontScalerKey = key;
     fFontScalerKey->ref();
 
     fFontCache = cache;     // no need to ref, it won't go away before we do
+    fAtlas = atlas;         // no need to ref, it won't go away before we do
+
+    fMaskFormat = format;
 
 #ifdef SK_DEBUG
 //    GrPrintf(" GrTextStrike %p %d\n", this, gCounter);
     gCounter += 1;
 #endif
 }
 
 GrTextStrike::~GrTextStrike() {
     fFontScalerKey->unref();
     SkTDynamicHash<GrGlyph, GrGlyph::PackedID>::Iter iter(&fCache);
@@ skipping 13 matching lines @@
     SkIRect bounds;
     if (fUseDistanceField) {
         if (!scaler->getPackedGlyphDFBounds(packed, &bounds)) {
             return NULL;
         }
     } else {
         if (!scaler->getPackedGlyphBounds(packed, &bounds)) {
             return NULL;
         }
     }
-    GrMaskFormat format = scaler->getPackedGlyphMaskFormat(packed);
-    
+
     GrGlyph* glyph = fPool.alloc();
-    glyph->init(packed, bounds, format);
+    glyph->init(packed, bounds);
     fCache.add(glyph);
     return glyph;
 }
 
 void GrTextStrike::removePlot(const GrPlot* plot) {
     SkTDynamicHash<GrGlyph, GrGlyph::PackedID>::Iter iter(&fCache);
     while (!iter.done()) {
         if (plot == (*iter).fPlot) {
             (*iter).fPlot = NULL;
         }
@@ skipping 23 matching lines @@
     if ((++gCounter % 10) == 0) return false;
 #endif
 
     SkASSERT(glyph);
     SkASSERT(scaler);
     SkASSERT(fCache.find(glyph->fPackedID));
     SkASSERT(NULL == glyph->fPlot);
 
     SkAutoUnref ar(SkSafeRef(scaler));
 
-    int bytesPerPixel = GrMaskFormatBytesPerPixel(glyph->fMaskFormat);
+    int bytesPerPixel = GrMaskFormatBytesPerPixel(fMaskFormat);
 
     size_t size = glyph->fBounds.area() * bytesPerPixel;
     GrAutoMalloc<1024> storage(size);
 
     if (fUseDistanceField) {
         if (!scaler->getPackedGlyphDFImage(glyph->fPackedID, glyph->width(),
                                            glyph->height(),
                                            storage.get())) {
             return false;
         }
     } else {
         if (!scaler->getPackedGlyphImage(glyph->fPackedID, glyph->width(),
                                          glyph->height(),
                                          glyph->width() * bytesPerPixel,
                                          storage.get())) {
             return false;
         }
     }
 
-    GrPlot* plot = fFontCache->addToAtlas(glyph->fMaskFormat, &fPlotUsage,
-                                          glyph->width(), glyph->height(),
-                                          storage.get(), &glyph->fAtlasLocation);
+    GrPlot* plot  = fAtlas->addToAtlas(&fPlotUsage, glyph->width(),
+                                       glyph->height(), storage.get(),
+                                       &glyph->fAtlasLocation);
 
     if (NULL == plot) {
         return false;
     }
 
     glyph->fPlot = plot;
     return true;
 }