PDF: why do we have flags no one uses (or can use)?

tests/PDFPrimitivesTest.cpp

 /*
  * Copyright 2010 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkData.h"
@@ skipping 57 matching lines @@
 static size_t get_output_size(SkPDFObject* object,
                               SkPDFCatalog* catalog,
                               bool indirect) {
     SkDynamicMemoryWStream buffer;
     emit_object(object, &buffer, catalog, indirect);
     return buffer.getOffset();
 }
 
 static void CheckObjectOutput(skiatest::Reporter* reporter, SkPDFObject* obj,
                               const char* expectedData, size_t expectedSize,
-                              bool indirect, bool compression) {
-    SkPDFDocument::Flags docFlags = (SkPDFDocument::Flags) 0;
-    if (!compression) {
-        docFlags = SkTBitOr(docFlags, SkPDFDocument::kFavorSpeedOverSize_Flags);
-    }
-    SkPDFCatalog catalog(docFlags);
+                              bool indirect) {
+    SkPDFCatalog catalog;
     size_t directSize = get_output_size(obj, &catalog, false);
     REPORTER_ASSERT(reporter, directSize == expectedSize);
 
     SkDynamicMemoryWStream buffer;
     emit_object(obj, &buffer, &catalog, false);
     REPORTER_ASSERT(reporter, directSize == buffer.getOffset());
     REPORTER_ASSERT(reporter, stream_equals(buffer, 0, expectedData,
                                             directSize));
 
     if (indirect) {
@@ skipping 17 matching lines @@
                                                 directSize));
         REPORTER_ASSERT(reporter, stream_equals(buffer, headerLen + directSize,
                                                 footer, footerLen));
     }
 }
 
 static void SimpleCheckObjectOutput(skiatest::Reporter* reporter,
                                     SkPDFObject* obj,
                                     const char* expectedResult) {
     CheckObjectOutput(reporter, obj, expectedResult,
-                      strlen(expectedResult), true, false);
+                      strlen(expectedResult), true);
 }
 
 static void TestPDFStream(skiatest::Reporter* reporter) {
     char streamBytes[] = "Test\nFoo\tBar";
     SkAutoTDelete<SkMemoryStream> streamData(new SkMemoryStream(
         streamBytes, strlen(streamBytes), true));
     SkAutoTUnref<SkPDFStream> stream(new SkPDFStream(streamData.get()));
     SimpleCheckObjectOutput(
         reporter, stream.get(),
         "<</Length 12\n>> stream\nTest\nFoo\tBar\nendstream");
     stream->insert("Attribute", new SkPDFInt(42))->unref();
     SimpleCheckObjectOutput(reporter, stream.get(),
                             "<</Length 12\n/Attribute 42\n>> stream\n"
                                 "Test\nFoo\tBar\nendstream");
 
 #ifndef SK_NO_FLATE
     {
         char streamBytes2[] = "This is a longer string, so that compression "
                               "can do something with it. With shorter strings, "
                               "the short circuit logic cuts in and we end up "
                               "with an uncompressed string.";
         SkAutoDataUnref streamData2(SkData::NewWithCopy(streamBytes2,
                                                         strlen(streamBytes2)));
         SkAutoTUnref<SkPDFStream> stream(new SkPDFStream(streamData2.get()));
 
         SkDynamicMemoryWStream compressedByteStream;
         SkFlate::Deflate(streamData2.get(), &compressedByteStream);
         SkAutoDataUnref compressedData(compressedByteStream.copyToData());
 
-        // Check first without compression.
-        SkDynamicMemoryWStream expectedResult1;
-        expectedResult1.writeText("<</Length 167\n>> stream\n");
-        expectedResult1.writeText(streamBytes2);
-        expectedResult1.writeText("\nendstream");
-        SkAutoDataUnref expectedResultData1(expectedResult1.copyToData());
-        CheckObjectOutput(reporter, stream.get(),
-                          (const char*) expectedResultData1->data(),
-                          expectedResultData1->size(), true, false);
-
-        // Then again with compression.
-        SkDynamicMemoryWStream expectedResult2;
-        expectedResult2.writeText("<</Filter /FlateDecode\n/Length 116\n"
+        SkDynamicMemoryWStream expected;
+        expected.writeText("<</Filter /FlateDecode\n/Length 116\n"
                                  ">> stream\n");
-        expectedResult2.write(compressedData->data(), compressedData->size());
-        expectedResult2.writeText("\nendstream");
-        SkAutoDataUnref expectedResultData2(expectedResult2.copyToData());
+        expected.write(compressedData->data(), compressedData->size());
+        expected.writeText("\nendstream");
+        SkAutoDataUnref expectedResultData2(expected.copyToData());
         CheckObjectOutput(reporter, stream.get(),
                           (const char*) expectedResultData2->data(),
-                          expectedResultData2->size(), true, true);
+                          expectedResultData2->size(), true);
     }
 #endif  // SK_NO_FLATE
 }
 
 static void TestCatalog(skiatest::Reporter* reporter) {
-    SkPDFCatalog catalog((SkPDFDocument::Flags)0);
+    SkPDFCatalog catalog;
     SkAutoTUnref<SkPDFInt> int1(new SkPDFInt(1));
     SkAutoTUnref<SkPDFInt> int2(new SkPDFInt(2));
     SkAutoTUnref<SkPDFInt> int3(new SkPDFInt(3));
     int1.get()->ref();
     SkAutoTUnref<SkPDFInt> int1Again(int1.get());
 
     catalog.addObject(int1.get(), false);
     catalog.addObject(int2.get(), false);
     catalog.addObject(int3.get(), false);
 
     REPORTER_ASSERT(reporter, catalog.getObjectNumber(int1.get()) == 1);
     REPORTER_ASSERT(reporter, catalog.getObjectNumber(int2.get()) == 2);
     REPORTER_ASSERT(reporter, catalog.getObjectNumber(int3.get()) == 3);
     REPORTER_ASSERT(reporter, catalog.getObjectNumber(int1Again.get()) == 1);
 }
 
 static void TestObjectRef(skiatest::Reporter* reporter) {
     SkAutoTUnref<SkPDFInt> int1(new SkPDFInt(1));
     SkAutoTUnref<SkPDFInt> int2(new SkPDFInt(2));
     SkAutoTUnref<SkPDFObjRef> int2ref(new SkPDFObjRef(int2.get()));
 
-    SkPDFCatalog catalog((SkPDFDocument::Flags)0);
+    SkPDFCatalog catalog;
     catalog.addObject(int1.get(), false);
     catalog.addObject(int2.get(), false);
     REPORTER_ASSERT(reporter, catalog.getObjectNumber(int1.get()) == 1);
     REPORTER_ASSERT(reporter, catalog.getObjectNumber(int2.get()) == 2);
 
     char expectedResult[] = "2 0 R";
     SkDynamicMemoryWStream buffer;
     int2ref->emitObject(&buffer, &catalog);
     REPORTER_ASSERT(reporter, buffer.getOffset() == strlen(expectedResult));
     REPORTER_ASSERT(reporter, stream_equals(buffer, 0, expectedResult,
                                             buffer.getOffset()));
 }
 
 static void TestSubstitute(skiatest::Reporter* reporter) {
     SkAutoTUnref<SkPDFTestDict> proxy(new SkPDFTestDict());
     SkAutoTUnref<SkPDFTestDict> stub(new SkPDFTestDict());
 
     proxy->insert("Value", new SkPDFInt(33))->unref();
     stub->insert("Value", new SkPDFInt(44))->unref();
 
-    SkPDFCatalog catalog((SkPDFDocument::Flags)0);
+    SkPDFCatalog catalog;
     catalog.addObject(proxy.get(), false);
     catalog.setSubstitute(proxy.get(), stub.get());
 
     REPORTER_ASSERT(reporter, stub.get() == catalog.getSubstituteObject(proxy));
     REPORTER_ASSERT(reporter, proxy.get() != catalog.getSubstituteObject(stub));
 }
 
 // This test used to assert without the fix submitted for
 // http://code.google.com/p/skia/issues/detail?id=1083.
 // SKP files might have invalid glyph ids. This test ensures they are ignored,
@@ skipping 41 matching lines @@
     SimpleCheckObjectOutput(reporter, stringSimple.get(),
                             "(test \\) string \\( foo)");
     SkAutoTUnref<SkPDFString> stringComplex(
         new SkPDFString("\ttest ) string ( foo"));
     SimpleCheckObjectOutput(reporter, stringComplex.get(),
                             "<0974657374202920737472696E67202820666F6F>");
 
     SkAutoTUnref<SkPDFName> name(new SkPDFName("Test name\twith#tab"));
     const char expectedResult[] = "/Test#20name#09with#23tab";
     CheckObjectOutput(reporter, name.get(), expectedResult,
-                      strlen(expectedResult), false, false);
+                      strlen(expectedResult), false);
 
     SkAutoTUnref<SkPDFName> escapedName(new SkPDFName("A#/%()<>[]{}B"));
     const char escapedNameExpected[] = "/A#23#2F#25#28#29#3C#3E#5B#5D#7B#7DB";
     CheckObjectOutput(reporter, escapedName.get(), escapedNameExpected,
-                      strlen(escapedNameExpected), false, false);
+                      strlen(escapedNameExpected), false);
 
     // Test that we correctly handle characters with the high-bit set.
     const unsigned char highBitCString[] = {0xDE, 0xAD, 'b', 'e', 0xEF, 0};
     SkAutoTUnref<SkPDFName> highBitName(
         new SkPDFName((const char*)highBitCString));
     const char highBitExpectedResult[] = "/#DE#ADbe#EF";
     CheckObjectOutput(reporter, highBitName.get(), highBitExpectedResult,
-                      strlen(highBitExpectedResult), false, false);
+                      strlen(highBitExpectedResult), false);
 
     SkAutoTUnref<SkPDFArray> array(new SkPDFArray);
     SimpleCheckObjectOutput(reporter, array.get(), "[]");
     array->append(int42.get());
     SimpleCheckObjectOutput(reporter, array.get(), "[42]");
     array->append(realHalf.get());
     SimpleCheckObjectOutput(reporter, array.get(), "[42 0.5]");
     SkAutoTUnref<SkPDFInt> int0(new SkPDFInt(0));
     array->append(int0.get());
     SimpleCheckObjectOutput(reporter, array.get(), "[42 0.5 0]");
@@ skipping 70 matching lines @@
 
     // Filter just created; should be unvisited.
     REPORTER_ASSERT(reporter, !filter->visited());
     SkPaint paint;
     paint.setImageFilter(filter.get());
     canvas.drawRect(SkRect::MakeWH(100, 100), paint);
 
     // Filter was used in rendering; should be visited.
     REPORTER_ASSERT(reporter, filter->visited());
 }