Add SkData::NewFromFD.

tests/DataRefTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Test.h"
 #include "SkData.h"
 #include "SkDataSet.h"
 #include "SkDataTable.h"
-#include "SkStream.h"
 #include "SkOrderedReadBuffer.h"
 #include "SkOrderedWriteBuffer.h"
-
-template <typename T> class SkTUnref {
-public:
-    SkTUnref(T* ref) : fRef(ref) {}
-    ~SkTUnref() { fRef->unref(); }
-
-    operator T*() { return fRef; }
-    operator const T*() { return fRef; }
-
-private:
-    T*  fRef;
-};
+#include "SkOSFile.h"
+#include "SkStream.h"
 
 static void test_is_equal(skiatest::Reporter* reporter,
                           const SkDataTable* a, const SkDataTable* b) {
     REPORTER_ASSERT(reporter, a->count() == b->count());
     for (int i = 0; i < a->count(); ++i) {
         size_t sizea, sizeb;
         const void* mema = a->at(i, &sizea);
         const void* memb = b->at(i, &sizeb);
         REPORTER_ASSERT(reporter, sizea == sizeb);
         REPORTER_ASSERT(reporter, !memcmp(mema, memb, sizea));
@@ skipping 179 matching lines @@
     ds.writeToStream(&ostream);
     SkMemoryStream istream;
     istream.setData(ostream.copyToData())->unref();
     SkDataSet copy(&istream);
 
     test_datasets_equal(reporter, ds, copy);
 }
 
 static void test_dataset(skiatest::Reporter* reporter) {
     SkDataSet set0(NULL, 0);
-    SkDataSet set1("hello", SkTUnref<SkData>(SkData::NewWithCString("world")));
+    SkDataSet set1("hello", SkAutoTUnref<SkData>(SkData::NewWithCString("world")));
 
     const SkDataSet::Pair pairs[] = {
         { "one", SkData::NewWithCString("1") },
         { "two", SkData::NewWithCString("2") },
         { "three", SkData::NewWithCString("3") },
     };
     SkDataSet set3(pairs, 3);
     unrefAll(pairs, 3);
 
     test_dataset(reporter, set0, 0);
@@ skipping 26 matching lines @@
     SkAutoTUnref<SkData> r0(SkData::NewWithCopy(str, len + 1));
     SkAutoTUnref<SkData> r1(SkData::NewWithCString(str));
 
     REPORTER_ASSERT(reporter, r0->equals(r1));
 
     SkAutoTUnref<SkData> r2(SkData::NewWithCString(NULL));
     REPORTER_ASSERT(reporter, 1 == r2->size());
     REPORTER_ASSERT(reporter, 0 == *r2->bytes());
 }
 
+static void test_files(skiatest::Reporter* reporter) {
+    if (skiatest::Test::GetTmpDir().isEmpty()) {
+        return;
+    }
+    
+    const char* tmpDir = skiatest::Test::GetTmpDir().c_str();
+    SkString path;
+    path.printf("%s%s", tmpDir, "data_test");
+    
+    const char s[] = "abcdefghijklmnopqrstuvwxyz";
+    {
+        SkFILEWStream writer(path.c_str());
+        if (!writer.isValid()) {
+            SkString msg;
+            msg.printf("Failed to create tmp file %s\n", path.c_str());
+            reporter->reportFailed(msg.c_str());
+            return;
+        }
+        writer.write(s, 26);
+    }
+
+    SkFILE* file = sk_fopen(path.c_str(), kRead_SkFILE_Flag);
+    SkAutoTUnref<SkData> r1(SkData::NewFromFILE(file));
+    REPORTER_ASSERT(reporter, r1.get() != NULL);
+    REPORTER_ASSERT(reporter, r1->size() == 26);
+    REPORTER_ASSERT(reporter, strncmp(static_cast<const char*>(r1->data()), s, 26) == 0);
+    
+    int fd = sk_fileno(file);
+    SkAutoTUnref<SkData> r2(SkData::NewFromFD(fd));
+    REPORTER_ASSERT(reporter, r2.get() != NULL);
+    REPORTER_ASSERT(reporter, r2->size() == 26);
+    REPORTER_ASSERT(reporter, strncmp(static_cast<const char*>(r2->data()), s, 26) == 0);
+}
+
 static void TestData(skiatest::Reporter* reporter) {
     const char* str = "We the people, in order to form a more perfect union.";
     const int N = 10;
 
     SkAutoTUnref<SkData> r0(SkData::NewEmpty());
     SkAutoTUnref<SkData> r1(SkData::NewWithCopy(str, strlen(str)));
     SkAutoTUnref<SkData> r2(SkData::NewWithProc(new int[N], N*sizeof(int),
                                            delete_int_proc, gGlobal));
     SkAutoTUnref<SkData> r3(SkData::NewSubset(r1, 7, 6));
 
     assert_len(reporter, r0, 0);
     assert_len(reporter, r1, strlen(str));
     assert_len(reporter, r2, N * sizeof(int));
     assert_len(reporter, r3, 6);
 
     assert_data(reporter, r1, str, strlen(str));
     assert_data(reporter, r3, "people", 6);
 
     SkData* tmp = SkData::NewSubset(r1, strlen(str), 10);
     assert_len(reporter, tmp, 0);
     tmp->unref();
     tmp = SkData::NewSubset(r1, 0, 0);
     assert_len(reporter, tmp, 0);
     tmp->unref();
 
     test_cstring(reporter);
     test_dataset(reporter);
+    test_files(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Data", DataTestClass, TestData)
 DEFINE_TESTCLASS("DataTable", DataTableTestClass, TestDataTable)