tree 54f94d9df69334cea157354883eadc7c9a704807
parent 9e7388e8e7ebbf5be6964f61b040297a17a16652
author Lei Zhang <thestig@chromium.org> 1626301675 +0000
committer Pdfium LUCI CQ <pdfium-scoped@luci-project-accounts.iam.gserviceaccount.com> 1626301675 +0000

Revert "Fix enum type mismatch in CPDF_FontEncoding."

This reverts commit 18192fde8ddc9cb87afd8a5f1c869e73bcb3484d.

Reason for revert: Regressed text extraction for bigtable-osdi06.pdf.

Original change's description:
> Fix enum type mismatch in CPDF_FontEncoding.
>
> Apart from PDFFONT_ENCODING_BUILTIN and FT_ENCODING_NONE, none of
> the PDFFONT_* definitions and FT_Encoding definitions have equivalent
> values. Since we pass these around as ints, it is easy to mix them up
> without compile-time detection. Once we re-write the FT_ functions to
> take FT_Encoding enums, a couple of problems crop up:
>
> CPDF_Type1Font.cpp:213 (and 275) are calling with the wrong enum, but
> CPDF_FontEncoding.cpp:1810 handles a mismatched enum, but the
> mismatched enum is not the one being passed by any of the mismatched
> callers. The result is those calls always get back a 0.
>
> So we are left to guess intent. The FT_ENCODING_ADOBE_STANDARD enum
> matches against our StandardEncoding table, so perhaps that was the
> intent when passing the mismatched PDFFONT_ENCODING_STANDARD value.
> Alternatively, maybe the intent was to match against the odd
> PDFFONT_ENCODING_PDFDOC case in the switch. Or it may just be that
> getting 0 and removing dead code is the best option.
>
> This CL tries the first option to see how it affects rendering,
> since it the most uptight about type safety, and we remove the
> mismatched case from the switch.
>
> Change-Id: I08cf85a8adf1ddabc6c2aa4484972b262af7ee49
> Reviewed-on: https://pdfium-review.googlesource.com/c/pdfium/+/80610
> Commit-Queue: Tom Sepez <tsepez@chromium.org>
> Reviewed-by: Lei Zhang <thestig@chromium.org>

# Not skipping CQ checks because original CL landed > 1 day ago.

Change-Id: If1233bc8b67dcf23e5827e9d4adda22d24483e79
Reviewed-on: https://pdfium-review.googlesource.com/c/pdfium/+/83070
Reviewed-by: Lei Zhang <thestig@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>
