Spin off incidental changes from DM CL (22839016).

gm/gm_expectations.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef gm_expectations_DEFINED
 #define gm_expectations_DEFINED
 
 #include "gm.h"
@@ skipping 31 matching lines @@
      * The digest of a GM test result.
      *
      * Currently, this is always a uint64_t hash digest of an SkBitmap...
      * but we will add other flavors soon.
      */
     class GmResultDigest {
     public:
         /**
          * Create a ResultDigest representing an actual image result.
          */
-        GmResultDigest(const SkBitmap &bitmap);
+        explicit GmResultDigest(const SkBitmap &bitmap);

[epoger, 2013/10/11 18:45:19]

Why make these explicit-only?

[mtklein, 2013/10/11 19:05:20]

Readability, though I notice Skia style guide doesn't care about this explicitly
(ahem).  Non-explicit single argument constructors can be really spooky.  Being
able to, say, pass false where you'd expect an Expectations is pretty weird. 
It's just a habit I've gotten into any time I see a single argument constructor.
 Generally, if some code stops compiling when you add an explicit like this,
that code was probably too subtle to begin with.

[bsalomon, 2013/10/11 19:50:54]

Update the style guide! We definitely prefer to use explicit and most instances
where we don't are violations of the undocumented preference.

[mtklein, 2013/10/14 15:16:18]

Done.

 
         /**
          * Create a ResultDigest representing an allowed result
          * checksum within JSON expectations file, in the form
          * ["bitmap-64bitMD5", 12345].
          */
-        GmResultDigest(const Json::Value &jsonTypeValuePair);
+        explicit GmResultDigest(const Json::Value &jsonTypeValuePair);
 
         /**
          * Returns true if this GmResultDigest was fully and successfully
          * created.
          */
         bool isValid() const;
 
         /**
          * Returns true if this and other GmResultDigest could
          * represent identical results.
@@ skipping 19 matching lines @@
     private:
         bool fIsValid; // always check this first--if it's false, other fields are meaningless
         uint64_t fHashDigest;
     };
 
     /**
      * Encapsulates an SkBitmap and its GmResultDigest, guaranteed to keep them in sync.
      */
     class BitmapAndDigest {
     public:
-        BitmapAndDigest(const SkBitmap &bitmap) : fBitmap(bitmap), fDigest(bitmap) {}
+        explicit BitmapAndDigest(const SkBitmap &bitmap) : fBitmap(bitmap), fDigest(bitmap) {}
 
         const SkBitmap fBitmap;
         const GmResultDigest fDigest;
     };
 
     /**
      * Test expectations (allowed image results, etc.)
      */
     class Expectations {
     public:
         /**
          * No expectations at all.
          */
-        Expectations(bool ignoreFailure=kDefaultIgnoreFailure);
+        explicit Expectations(bool ignoreFailure=kDefaultIgnoreFailure);
 
         /**
          * Expect exactly one image (appropriate for the case when we
          * are comparing against a single PNG file).
          */
         Expectations(const SkBitmap& bitmap, bool ignoreFailure=kDefaultIgnoreFailure);
 
         /**
          * Create Expectations from a JSON element as found within the
          * kJsonKey_ExpectedResults section.
          *
          * It's fine if the jsonElement is null or empty; in that case, we just
          * don't have any expectations.
          */
-        Expectations(Json::Value jsonElement);
+        explicit Expectations(Json::Value jsonElement);
 
         /**
          * Returns true iff we want to ignore failed expectations.
          */
         bool ignoreFailure() const { return this->fIgnoreFailure; }
 
         /**
          * Override default setting of fIgnoreFailure.
          */
         void setIgnoreFailure(bool val) { this->fIgnoreFailure = val; }
@@ skipping 33 matching lines @@
         SkBitmap fBitmap;
     };
 
     /**
      * Abstract source of Expectations objects for individual tests.
      */
     class ExpectationsSource : public SkRefCnt {
     public:
         SK_DECLARE_INST_COUNT(ExpectationsSource)
 
-        virtual Expectations get(const char *testName) = 0;
+        virtual Expectations get(const char *testName) const = 0;
 
     private:
         typedef SkRefCnt INHERITED;
     };
 
     /**
      * Return Expectations based on individual image files on disk.
      */
     class IndividualImageExpectationsSource : public ExpectationsSource {
     public:
         /**
          * Create an ExpectationsSource that will return Expectations based on
          * image files found within rootDir.
          *
          * rootDir: directory under which to look for image files
          *          (this string will be copied to storage within this object)
          */
-        IndividualImageExpectationsSource(const char *rootDir) : fRootDir(rootDir) {}
+        explicit IndividualImageExpectationsSource(const char *rootDir) : fRootDir(rootDir) {}
 
-        Expectations get(const char *testName) SK_OVERRIDE ;
+        Expectations get(const char *testName) const SK_OVERRIDE ;
 
     private:
         const SkString fRootDir;
     };
 
     /**
      * Return Expectations based on JSON summary file.
      */
     class JsonExpectationsSource : public ExpectationsSource {
     public:
         /**
          * Create an ExpectationsSource that will return Expectations based on
          * a JSON file.
          *
          * jsonPath: path to JSON file to read
          */
-        JsonExpectationsSource(const char *jsonPath);
+        explicit JsonExpectationsSource(const char *jsonPath);
 
-        Expectations get(const char *testName) SK_OVERRIDE;
+        Expectations get(const char *testName) const SK_OVERRIDE;
 
     private:
 
         /**
          * Read as many bytes as possible (up to maxBytes) from the stream into
          * an SkData object.
          *
          * If the returned SkData contains fewer than maxBytes, then EOF has been
          * reached and no more data would be available from subsequent calls.
          * (If EOF has already been reached, then this call will return an empty
@@ skipping 37 matching lines @@
          * Returns true if successful.
          */
         static bool Parse(const char *jsonPath, Json::Value *jsonRoot);
 
         Json::Value fJsonRoot;
         Json::Value fJsonExpectedResults;
     };
 
 }
 #endif