Generate gm/Android.mk, minus JSON.

gm/gm_expectations.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * TODO(epoger): Combine this with tools/image_expectations.cpp, or eliminate one of the two.
  */
 
 #include "gm_expectations.h"
@@ skipping 13 matching lines @@
 const static char kJsonKey_ExpectedResults[] = "expected-results";
 const static char kJsonKey_ExpectedResults_AllowedDigests[] = "allowed-digests";
 const static char kJsonKey_ExpectedResults_IgnoreFailure[]  = "ignore-failure";
 
 // Types of result hashes we support in the JSON file.
 const static char kJsonKey_Hashtype_Bitmap_64bitMD5[]  = "bitmap-64bitMD5";
 
 
 namespace skiagm {
 
+#ifdef SK_BUILD_JSON_WRITER
     Json::Value CreateJsonTree(Json::Value expectedResults,
                                Json::Value actualResultsFailed,
                                Json::Value actualResultsFailureIgnored,
                                Json::Value actualResultsNoComparison,
                                Json::Value actualResultsSucceeded) {
         Json::Value actualResults;
         actualResults[kJsonKey_ActualResults_Failed] = actualResultsFailed;
         actualResults[kJsonKey_ActualResults_FailureIgnored] = actualResultsFailureIgnored;
         actualResults[kJsonKey_ActualResults_NoComparison] = actualResultsNoComparison;
         actualResults[kJsonKey_ActualResults_Succeeded] = actualResultsSucceeded;
         Json::Value root;
         root[kJsonKey_ActualResults] = actualResults;
         root[kJsonKey_ExpectedResults] = expectedResults;
         return root;
     }
-
+#endif
 
     // GmResultDigest class...
 
     GmResultDigest::GmResultDigest(const SkBitmap &bitmap) {
         fIsValid = SkBitmapHasher::ComputeDigest(bitmap, &fHashDigest);
     }
 
+#ifdef SK_BUILD_JSON_WRITER
     GmResultDigest::GmResultDigest(const Json::Value &jsonTypeValuePair) {
         fIsValid = false;
         if (!jsonTypeValuePair.isArray()) {
             SkDebugf("found non-array json value when parsing GmResultDigest: %s\n",
                      jsonTypeValuePair.toStyledString().c_str());
             DEBUGFAIL_SEE_STDERR;
         } else if (2 != jsonTypeValuePair.size()) {
             SkDebugf("found json array with wrong size when parsing GmResultDigest: %s\n",
                      jsonTypeValuePair.toStyledString().c_str());
             DEBUGFAIL_SEE_STDERR;
         } else {
             // TODO(epoger): The current implementation assumes that the
             // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5
             Json::Value jsonHashValue = jsonTypeValuePair[1];
             if (!jsonHashValue.isIntegral()) {
                 SkDebugf("found non-integer jsonHashValue when parsing GmResultDigest: %s\n",
                          jsonTypeValuePair.toStyledString().c_str());
                 DEBUGFAIL_SEE_STDERR;
             } else {
                 fHashDigest = jsonHashValue.asUInt64();
                 fIsValid = true;
             }
         }
     }
+#endif
 
     bool GmResultDigest::isValid() const {
         return fIsValid;
     }
 
     bool GmResultDigest::equals(const GmResultDigest &other) const {
         // TODO(epoger): The current implementation assumes that this
         // and other are always of type kJsonKey_Hashtype_Bitmap_64bitMD5
         return (this->fIsValid && other.fIsValid && (this->fHashDigest == other.fHashDigest));
     }
 
+#ifdef SK_BUILD_JSON_WRITER
     Json::Value GmResultDigest::asJsonTypeValuePair() const {
         // TODO(epoger): The current implementation assumes that the
         // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5
         Json::Value jsonTypeValuePair;
         if (fIsValid) {
             jsonTypeValuePair.append(Json::Value(kJsonKey_Hashtype_Bitmap_64bitMD5));
             jsonTypeValuePair.append(Json::UInt64(fHashDigest));
         } else {
             jsonTypeValuePair.append(Json::Value("INVALID"));
         }
         return jsonTypeValuePair;
     }
+#endif
 
     SkString GmResultDigest::getHashType() const {
         // TODO(epoger): The current implementation assumes that the
         // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5
         return SkString(kJsonKey_Hashtype_Bitmap_64bitMD5);
     }
 
     SkString GmResultDigest::getDigestValue() const {
         // TODO(epoger): The current implementation assumes that the
         // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5
@@ skipping 14 matching lines @@
         fIgnoreFailure = ignoreFailure;
         fAllowedResultDigests.push_back(GmResultDigest(bitmap));
     }
 
     Expectations::Expectations(const BitmapAndDigest& bitmapAndDigest) {
         fBitmap = bitmapAndDigest.fBitmap;
         fIgnoreFailure = false;
         fAllowedResultDigests.push_back(bitmapAndDigest.fDigest);
     }
 
+#ifdef SK_BUILD_JSON_WRITER
     Expectations::Expectations(Json::Value jsonElement) {
         if (jsonElement.empty()) {
             fIgnoreFailure = kDefaultIgnoreFailure;
         } else {
             Json::Value ignoreFailure = jsonElement[kJsonKey_ExpectedResults_IgnoreFailure];
             if (ignoreFailure.isNull()) {
                 fIgnoreFailure = kDefaultIgnoreFailure;
             } else if (!ignoreFailure.isBool()) {
                 SkDebugf("found non-boolean json value for key '%s' in element '%s'\n",
                          kJsonKey_ExpectedResults_IgnoreFailure,
@@ skipping 12 matching lines @@
                          kJsonKey_ExpectedResults_AllowedDigests,
                          jsonElement.toStyledString().c_str());
                 DEBUGFAIL_SEE_STDERR;
             } else {
                 for (Json::ArrayIndex i=0; i<allowedDigests.size(); i++) {
                     fAllowedResultDigests.push_back(GmResultDigest(allowedDigests[i]));
                 }
             }
         }
     }
+#endif
 
     bool Expectations::match(GmResultDigest actualGmResultDigest) const {
         for (int i=0; i < this->fAllowedResultDigests.count(); i++) {
             GmResultDigest allowedResultDigest = this->fAllowedResultDigests[i];
             if (allowedResultDigest.equals(actualGmResultDigest)) {
                 return true;
             }
         }
         return false;
     }
 
+#ifdef SK_BUILD_JSON_WRITER
     Json::Value Expectations::asJsonValue() const {
         Json::Value allowedDigestArray;
         if (!this->fAllowedResultDigests.empty()) {
             for (int i=0; i < this->fAllowedResultDigests.count(); i++) {
                 allowedDigestArray.append(this->fAllowedResultDigests[i].asJsonTypeValuePair());
             }
         }
 
         Json::Value jsonExpectations;
         jsonExpectations[kJsonKey_ExpectedResults_AllowedDigests] = allowedDigestArray;
         jsonExpectations[kJsonKey_ExpectedResults_IgnoreFailure]  = this->ignoreFailure();
         return jsonExpectations;
     }
-
+#endif
 
     // IndividualImageExpectationsSource class...
 
     Expectations IndividualImageExpectationsSource::get(const char *testName) const {
         SkString path = SkOSPath::SkPathJoin(fRootDir.c_str(), testName);
         SkBitmap referenceBitmap;
         bool decodedReferenceBitmap =
             SkImageDecoder::DecodeFile(path.c_str(), &referenceBitmap,
                                        SkBitmap::kARGB_8888_Config,
                                        SkImageDecoder::kDecodePixels_Mode,
                                        NULL);
         if (decodedReferenceBitmap) {
             return Expectations(referenceBitmap);
         } else {
             return Expectations();
         }
     }
 
 
+#ifdef SK_BUILD_JSON_WRITER
     // JsonExpectationsSource class...
 
     JsonExpectationsSource::JsonExpectationsSource(const char *jsonPath) {
         Parse(jsonPath, &fJsonRoot);
         fJsonExpectedResults = fJsonRoot[kJsonKey_ExpectedResults];
     }
 
     Expectations JsonExpectationsSource::get(const char *testName) const {
         return Expectations(fJsonExpectedResults[testName]);
     }
 
     /*static*/ bool JsonExpectationsSource::Parse(const char *jsonPath, Json::Value *jsonRoot) {
         SkAutoDataUnref dataRef(SkData::NewFromFileName(jsonPath));
         if (NULL == dataRef.get()) {
             SkDebugf("error reading JSON file %s\n", jsonPath);
             DEBUGFAIL_SEE_STDERR;
             return false;
         }
 
         const char *bytes = reinterpret_cast<const char *>(dataRef.get()->data());
         size_t size = dataRef.get()->size();
         Json::Reader reader;
         if (!reader.parse(bytes, bytes+size, *jsonRoot)) {
             SkDebugf("error parsing JSON file %s\n", jsonPath);
             DEBUGFAIL_SEE_STDERR;
             return false;
         }
         return true;
     }
-
+#endif
 }