Back to hashing source content, not .png.

dm/DMWriteTask.cpp

 #include "DMWriteTask.h"
 
 #include "DMUtil.h"
 #include "SkColorPriv.h"
 #include "SkCommonFlags.h"
 #include "SkData.h"
 #include "SkImageEncoder.h"
 #include "SkMD5.h"
 #include "SkMallocPixelRef.h"
 #include "SkOSFile.h"
@@ skipping 46 matching lines @@
     SkASSERT(fData.get());
     SkASSERT(fData->unique());
 }
 
 void WriteTask::makeDirOrFail(SkString dir) {
     if (!sk_mkdir(dir.c_str())) {
         this->fail();
     }
 }
 
-static SkStreamAsset* encode_to_png(const SkBitmap& bitmap) {
-    SkDynamicMemoryWStream png;
-    if (!SkImageEncoder::EncodeStream(&png, bitmap, SkImageEncoder::kPNG_Type, 100)) {
-        return NULL;
-    }
-    png.copyToData()->unref();  // Forces detachAsStream() to be contiguous.
-    return png.detachAsStream();
-}
-
-static SkString get_md5(SkStreamAsset* src) {
+static SkString get_md5(const void* ptr, size_t len) {
     SkMD5 hasher;
-    hasher.write(src->getMemoryBase(), src->getLength());
+    hasher.write(ptr, len);
     SkMD5::Digest digest;
     hasher.finish(digest);
 
     SkString md5;
     for (int i = 0; i < 16; i++) {
         md5.appendf("%02x", digest.data[i]);
     }
     return md5;
 }
 
 struct JsonData {
     SkString name;        // E.g. "ninepatch-stretch", "desk-gws_skp"
     SkString config;      //      "gpu", "8888"
     SkString sourceType;  //      "GM", "SKP"
     SkString md5;  // In ASCII, so 32 bytes long.
 };
 SkTArray<JsonData> gJsonData;
 SK_DECLARE_STATIC_MUTEX(gJsonDataLock);
 
 void WriteTask::draw() {
-    if (!fData.get()) {
-        fData.reset(encode_to_png(fBitmap));
-        if (!fData.get()) {
-            this->fail("Can't encode to PNG.");
-        }
+    SkString md5;
+    {
+        SkAutoLockPixels lock(fBitmap);
+        md5 = fData ? get_md5(fData->getMemoryBase(), fData->getLength())
+                    : get_md5(fBitmap.getPixels(), fBitmap.getSize());
     }
 
-    JsonData entry = { fBaseName, fSuffixes[0], fSourceType, get_md5(fData) };
+    JsonData entry = { fBaseName, fSuffixes[0], fSourceType, md5 };
     {
         SkAutoMutexAcquire lock(&gJsonDataLock);
         gJsonData.push_back(entry);
     }
 
     SkString dir(FLAGS_writePath[0]);
 #if SK_BUILD_FOR_IOS
     if (dir.equals("@")) {
         dir.set(FLAGS_resourcePath[0]);
     }
 #endif
     this->makeDirOrFail(dir);
 
     SkString path;
     if (FLAGS_nameByHash) {
         // Flat directory of hash-named files.
-        path = SkOSPath::Join(dir.c_str(), entry.md5.c_str());
+        path = SkOSPath::Join(dir.c_str(), md5.c_str());
         path.append(fExtension);
         // We're content-addressed, so it's possible two threads race to write
         // this file.  We let the first one win.  This also means we won't
         // overwrite identical files from previous runs.
         if (sk_exists(path.c_str())) {
             return;
         }
     } else {
         // Nested by mode, config, etc.
         for (int i = 0; i < fSuffixes.count(); i++) {
             dir = SkOSPath::Join(dir.c_str(), fSuffixes[i].c_str());
             this->makeDirOrFail(dir);
         }
         path = SkOSPath::Join(dir.c_str(), fBaseName.c_str());
         path.append(fExtension);
         // The path is unique, so two threads can't both write to the same file.
         // If already present we overwrite here, since the content may have changed.
     }
 
     SkFILEWStream file(path.c_str());
     if (!file.isValid()) {
         return this->fail("Can't open file.");
     }
 
-    fData->rewind();
-    if (!file.writeStream(fData, fData->getLength())) {
+    bool ok = fData ? file.writeStream(fData, fData->getLength())
+                    : SkImageEncoder::EncodeStream(&file, fBitmap, SkImageEncoder::kPNG_Type, 100);
+    if (!ok) {
         return this->fail("Can't write to file.");
     }
 }
 
 SkString WriteTask::name() const {
     SkString name("writing ");
     for (int i = 0; i < fSuffixes.count(); i++) {
         name.appendf("%s/", fSuffixes[i].c_str());
     }
     name.append(fBaseName.c_str());
@@ skipping 31 matching lines @@
         }
     }
 
     SkString path = SkOSPath::Join(FLAGS_writePath[0], "dm.json");
     SkFILEWStream stream(path.c_str());
     stream.writeText(Json::StyledWriter().write(root).c_str());
     stream.flush();
 }
 
 }  // namespace DM