Optimize the SkRawStream when the input is an asset stream

tests/CodexTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Resources.h"
 #include "SkAndroidCodec.h"
 #include "SkBitmap.h"
@@ skipping 371 matching lines @@
     check(r, "mandrill_64.png", SkISize::Make(64, 64), true, false, false);
     check(r, "plane.png", SkISize::Make(250, 126), true, false, false);
     // FIXME: We are not ready to test incomplete interlaced pngs
     check(r, "plane_interlaced.png", SkISize::Make(250, 126), true, false, false);
     check(r, "randPixels.png", SkISize::Make(8, 8), true, false, false);
     check(r, "yellow_rose.png", SkISize::Make(400, 301), true, false, false);
 
     // RAW
 #if defined(SK_CODEC_DECODES_RAW)
     check(r, "sample_1mp.dng", SkISize::Make(600, 338), false, false, false);
+    check(r, "dng_with_preview.dng", SkISize::Make(600, 338), true, false, false);
 #endif
 }
 
 // Test interlaced PNG in stripes, similar to DM's kStripe_Mode
 DEF_TEST(Codec_stripes, r) {
     const char * path = "plane_interlaced.png";
     SkAutoTDelete<SkStream> stream(resource(path));
     if (!stream) {
         SkDebugf("Missing resource '%s'\n", path);
     }
@@ skipping 177 matching lines @@
     test_dimensions(r, "3x3.png");
     test_dimensions(r, "3x1.png");
     test_dimensions(r, "1x1.png");
     test_dimensions(r, "16x1.png");
     test_dimensions(r, "1x16.png");
     test_dimensions(r, "mandrill_16.png");
 
     // RAW
 #if defined(SK_CODEC_DECODES_RAW)
     test_dimensions(r, "sample_1mp.dng");
+    test_dimensions(r, "dng_with_preview.dng");
 #endif
 }
 
 static void test_invalid(skiatest::Reporter* r, const char path[]) {
     SkAutoTDelete<SkStream> stream(resource(path));
     if (!stream) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.detach()));
@@ skipping 223 matching lines @@
         return fStream.rewind();
     }
     bool isAtEnd() const override {
         return false;
     }
 private:
     SkMemoryStream fStream;
     const size_t   fLimit;
 };
 
+// Stream that is not an asset stream (!hasPosition() or !hasLength())
+class NotAssetMemStream : public SkStream {
+public:
+    NotAssetMemStream(SkData* data) : fStream(data) {}
+
+    bool hasPosition() const override {
+        return false;
+    }
+
+    bool hasLength() const override {
+        return false;
+    }
+
+    size_t peek(void* buf, size_t bytes) const override {
+        return fStream.peek(buf, bytes);
+    }
+    size_t read(void* buf, size_t bytes) override {
+        return fStream.read(buf, bytes);
+    }
+    bool rewind() override {
+        return fStream.rewind();
+    }
+    bool isAtEnd() const override {
+        return fStream.isAtEnd();
+    }
+private:
+    SkMemoryStream fStream;
+};
+
+// Test that the RawCodec works also for not asset stream. This will test the code path using
+// SkRawBufferedStream instead of SkRawAssetStream.
+#if defined(SK_CODEC_DECODES_RAW)
+DEF_TEST(Codec_raw_notseekable, r) {
+    const char* path = "dng_with_preview.dng";
+    SkString fullPath(GetResourcePath(path));
+    SkAutoTUnref<SkData> data(SkData::NewFromFileName(fullPath.c_str()));
+    if (!data) {
+        SkDebugf("Missing resource '%s'\n", path);
+        return;
+    }
+
+    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(new NotAssetMemStream(data)));
+    REPORTER_ASSERT(r, codec);
+
+    test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
+}
+#endif
+
 // Test that even if webp_parse_header fails to peek enough, it will fall back to read()
 // + rewind() and succeed.
 DEF_TEST(Codec_webp_peek, r) {
     const char* path = "baby_tux.webp";
     SkString fullPath(GetResourcePath(path));
     SkAutoTUnref<SkData> data(SkData::NewFromFileName(fullPath.c_str()));
     if (!data) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
@@ skipping 62 matching lines @@
     // Now test an image which is too big. Any image with a larger header (i.e.
     // has bigger width/height) is also too big.
     const unsigned char tooBigWbmp[] = { 0x00, 0x00,           // Header
                                          0x84, 0x80, 0x00,     // W: 65536
                                          0x84, 0x80, 0x00 };   // H: 65536
     stream.reset(new SkMemoryStream(tooBigWbmp, sizeof(tooBigWbmp), false));
     codec.reset(SkCodec::NewFromStream(stream.detach()));
 
     REPORTER_ASSERT(r, !codec);
 }