Add support for multiple frames in SkCodec

tests/CodecAnimTest.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec.h"
 #include "SkStream.h"
 
@@ skipping 34 matching lines @@
             continue;
         }
 
         std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
         if (!codec) {
             ERRORF(r, "Failed to create an SkCodec from '%s'", rec.fName);
             continue;
         }
 
         const size_t expected = rec.fFrameCount;
-        const size_t frameCount = codec->getFrameCount();
+        const auto frameInfos = codec->getFrameInfo();
+        // getFrameInfo returns empty set for non-animated.
+        const size_t frameCount = frameInfos.size() == 0 ? 1 : frameInfos.size();
         if (frameCount != expected) {
             ERRORF(r, "'%s' expected frame count: %i\tactual: %i", rec.fName, expected, frameCount);
             continue;
         }
 
-        REPORTER_ASSERT(r, codec->getRequiredFrame(0) == SkCodec::kIndependentFrame);
-
         if (rec.fRequiredFrames.size() + 1 != expected) {
             ERRORF(r, "'%s' has wrong number entries in fRequiredFrames; expected: %i\tactual: %i",
                    rec.fName, expected, rec.fRequiredFrames.size());
             continue;
         }
 
         if (1 == frameCount) {
             continue;
         }
 
         // From here on, we are only concerned with animated images.
+        REPORTER_ASSERT(r, frameInfos[0].fRequiredFrame == SkCodec::kIndependentFrame);
         for (size_t i = 1; i < frameCount; i++) {
-            REPORTER_ASSERT(r, rec.fRequiredFrames[i-1] == codec->getRequiredFrame(i));
+            REPORTER_ASSERT(r, rec.fRequiredFrames[i-1] == frameInfos[i].fRequiredFrame);
         }
 
         // Compare decoding in two ways:
         // 1. Provide the frame that a frame depends on, so the codec just has to blend.
         //    (in the array cachedFrames)
         // 2. Do not provide the frame that a frame depends on, so the codec has to decode all the
         //    way back to a key-frame. (in a local variable uncachedFrame)
         // The two should look the same.
         std::vector<SkBitmap> cachedFrames(frameCount);
         const auto& info = codec->getInfo().makeColorType(kN32_SkColorType);
 
         auto decode = [&](SkBitmap* bm, bool cached, size_t index) {
             bm->allocPixels(info);
             if (cached) {
                 // First copy the pixels from the cached frame
-                const size_t requiredFrame = codec->getRequiredFrame(index);
+                const size_t requiredFrame = frameInfos[index].fRequiredFrame;
                 if (requiredFrame != SkCodec::kIndependentFrame) {
                     const bool success = cachedFrames[requiredFrame].copyTo(bm);
                     REPORTER_ASSERT(r, success);
                 }
             }
             SkCodec::Options opts;
             SkCodec::MultiFrameOptions multiOpts;
             multiOpts.fIndex = index;
             multiOpts.fHasPriorFrame = cached;
             opts.fFrameOptions = &multiOpts;
@@ skipping 23 matching lines @@
             }
         }
 
         if (rec.fDurations.size() != expected) {
             ERRORF(r, "'%s' has wrong number entries in fDurations; expected: %i\tactual: %i",
                    rec.fName, expected, rec.fDurations.size());
             continue;
         }
 
         for (size_t i = 0; i < frameCount; i++) {
-            REPORTER_ASSERT(r, rec.fDurations[i] == codec->getFrameDuration(i));
+            REPORTER_ASSERT(r, rec.fDurations[i] == frameInfos[i].fDuration);
         }
     }
 }