[pdf] Change DocumentPermission to an enum class

Enum classes are better for type safety.

Change-Id: I65d9d6809d225ef68b9a64350540daf84011850c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3055470
Commit-Queue: Daniel Hosseinian <dhoss@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Cr-Commit-Position: refs/heads/master@{#905551}

pdf/out_of_process_instance.cc

@@ -630,9 +630,9 @@ int32_t OutOfProcessInstance::PdfPrintBegin(
 }
 
 uint32_t OutOfProcessInstance::QuerySupportedPrintOutputFormats() {
-  if (engine()->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY))
+  if (engine()->HasPermission(DocumentPermission::kPrintHighQuality))
     return PP_PRINTOUTPUTFORMAT_PDF | PP_PRINTOUTPUTFORMAT_RASTER;
-  if (engine()->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY))
+  if (engine()->HasPermission(DocumentPermission::kPrintLowQuality))
     return PP_PRINTOUTPUTFORMAT_RASTER;
   return 0;
 }

pdf/pdf_engine.h

@@ -82,6 +82,13 @@ enum class FontMappingMode {
   kPepper,
 };
 
+enum class DocumentPermission {
+  kCopy,
+  kCopyAccessible,
+  kPrintLowQuality,
+  kPrintHighQuality,
+};
+
 // Do one time initialization of the SDK.
 // If `enable_v8` is false, then the PDFEngine will not be able to run
 // JavaScript.
@@ -92,13 +99,6 @@ void ShutdownSDK();
 // This class encapsulates a PDF rendering engine.
 class PDFEngine {
  public:
-  enum DocumentPermission {
-    PERMISSION_COPY,
-    PERMISSION_COPY_ACCESSIBLE,
-    PERMISSION_PRINT_LOW_QUALITY,
-    PERMISSION_PRINT_HIGH_QUALITY,
-  };
-
   // Maximum number of parameters a nameddest view can contain.
   static constexpr size_t kMaxViewParams = 4;
 

pdf/pdf_view_plugin_base.cc

@@ -290,8 +290,8 @@ void PdfViewPluginBase::Print() {
     return;
 
   const bool can_print =
-      engine_->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) ||
-      engine_->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY);
+      engine_->HasPermission(DocumentPermission::kPrintLowQuality) ||
+      engine_->HasPermission(DocumentPermission::kPrintHighQuality);
   if (!can_print)
     return;
 
@@ -638,11 +638,11 @@ void PdfViewPluginBase::HandleAccessibilityAction(
 
 int PdfViewPluginBase::GetContentRestrictions() const {
   int content_restrictions = kContentRestrictionCut | kContentRestrictionPaste;
-  if (!engine()->HasPermission(PDFEngine::PERMISSION_COPY))
+  if (!engine()->HasPermission(DocumentPermission::kCopy))
     content_restrictions |= kContentRestrictionCopy;
 
-  if (!engine()->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) &&
-      !engine()->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY)) {
+  if (!engine()->HasPermission(DocumentPermission::kPrintLowQuality) &&
+      !engine()->HasPermission(DocumentPermission::kPrintHighQuality)) {
     content_restrictions |= kContentRestrictionPrint;
   }
 
@@ -653,8 +653,8 @@ AccessibilityDocInfo PdfViewPluginBase::GetAccessibilityDocInfo() const {
   AccessibilityDocInfo doc_info;
   doc_info.page_count = engine()->GetNumberOfPages();
   doc_info.text_accessible =
-      engine()->HasPermission(PDFEngine::PERMISSION_COPY_ACCESSIBLE);
-  doc_info.text_copyable = engine()->HasPermission(PDFEngine::PERMISSION_COPY);
+      engine()->HasPermission(DocumentPermission::kCopyAccessible);
+  doc_info.text_copyable = engine()->HasPermission(DocumentPermission::kCopy);
   return doc_info;
 }
 
@@ -732,9 +732,9 @@ int PdfViewPluginBase::PrintBegin(const blink::WebPrintParams& print_params) {
     return 0;
 
   const bool can_print =
-      engine()->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY) ||
+      engine()->HasPermission(DocumentPermission::kPrintHighQuality) ||
       (print_params.rasterize_pdf &&
-       engine()->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY));
+       engine()->HasPermission(DocumentPermission::kPrintLowQuality));
 
   if (!can_print)
     return 0;
@@ -1484,8 +1484,8 @@ void PdfViewPluginBase::LoadAccessibility() {
   SetAccessibilityDocInfo(GetAccessibilityDocInfo());
 
   // If the document contents isn't accessible, don't send anything more.
-  if (!(engine_->HasPermission(PDFEngine::PERMISSION_COPY) ||
-        engine_->HasPermission(PDFEngine::PERMISSION_COPY_ACCESSIBLE))) {
+  if (!(engine_->HasPermission(DocumentPermission::kCopy) ||
+        engine_->HasPermission(DocumentPermission::kCopyAccessible))) {
     return;
   }
 

pdf/pdf_view_plugin_base_unittest.cc

@@ -56,7 +56,7 @@ class TestPDFiumEngine : public PDFiumEngine {
 
   ~TestPDFiumEngine() override = default;
 
-  bool HasPermission(PDFEngine::DocumentPermission permission) const override {
+  bool HasPermission(DocumentPermission permission) const override {
     return base::Contains(permissions_, permission);
   }
 
@@ -90,8 +90,7 @@ class TestPDFiumEngine : public PDFiumEngine {
     return std::vector<uint8_t>(std::begin(kSaveData), std::end(kSaveData));
   }
 
-  void SetPermissions(
-      const std::vector<PDFEngine::DocumentPermission>& permissions) {
+  void SetPermissions(const std::vector<DocumentPermission>& permissions) {
     permissions_.clear();
 
     for (auto& permission : permissions)
@@ -110,7 +109,7 @@ class TestPDFiumEngine : public PDFiumEngine {
 
   DocumentMetadata metadata_;
 
-  base::flat_set<PDFEngine::DocumentPermission> permissions_;
+  base::flat_set<DocumentPermission> permissions_;
 };
 
 class TestPDFiumEngineWithDocInfo : public TestPDFiumEngine {
@@ -885,14 +884,14 @@ TEST_F(PdfViewPluginBaseWithEngineTest, GetContentRestrictions) {
             content_restrictions);
 
   // Test engine with only copy permission.
-  engine->SetPermissions({PDFEngine::PERMISSION_COPY});
+  engine->SetPermissions({DocumentPermission::kCopy});
 
   content_restrictions = fake_plugin_.GetContentRestrictions();
   EXPECT_EQ(kContentRestrictionCutPaste | kContentRestrictionPrint,
             content_restrictions);
 
   // Test engine with only print low quality permission.
-  engine->SetPermissions({PDFEngine::PERMISSION_PRINT_LOW_QUALITY});
+  engine->SetPermissions({DocumentPermission::kPrintLowQuality});
 
   content_restrictions = fake_plugin_.GetContentRestrictions();
   EXPECT_EQ(kContentRestrictionCutPaste | kContentRestrictionCopy,
@@ -900,23 +899,23 @@ TEST_F(PdfViewPluginBaseWithEngineTest, GetContentRestrictions) {
 
   // Test engine with both copy and print low quality permissions.
   engine->SetPermissions(
-      {PDFEngine::PERMISSION_COPY, PDFEngine::PERMISSION_PRINT_LOW_QUALITY});
+      {DocumentPermission::kCopy, DocumentPermission::kPrintLowQuality});
 
   content_restrictions = fake_plugin_.GetContentRestrictions();
   EXPECT_EQ(kContentRestrictionCutPaste, content_restrictions);
 
   // Test engine with print high and low quality permissions.
-  engine->SetPermissions({PDFEngine::PERMISSION_PRINT_HIGH_QUALITY,
-                          PDFEngine::PERMISSION_PRINT_LOW_QUALITY});
+  engine->SetPermissions({DocumentPermission::kPrintHighQuality,
+                          DocumentPermission::kPrintLowQuality});
 
   content_restrictions = fake_plugin_.GetContentRestrictions();
   EXPECT_EQ(kContentRestrictionCutPaste | kContentRestrictionCopy,
             content_restrictions);
 
   // Test engine with copy, print high and low quality permissions.
-  engine->SetPermissions({PDFEngine::PERMISSION_COPY,
-                          PDFEngine::PERMISSION_PRINT_HIGH_QUALITY,
-                          PDFEngine::PERMISSION_PRINT_LOW_QUALITY});
+  engine->SetPermissions({DocumentPermission::kCopy,
+                          DocumentPermission::kPrintHighQuality,
+                          DocumentPermission::kPrintLowQuality});
 
   content_restrictions = fake_plugin_.GetContentRestrictions();
   EXPECT_EQ(kContentRestrictionCutPaste, content_restrictions);
@@ -934,7 +933,7 @@ TEST_F(PdfViewPluginBaseWithEngineTest, GetAccessibilityDocInfo) {
   EXPECT_FALSE(doc_info.text_copyable);
 
   // Test engine with only copy permission.
-  engine->SetPermissions({PDFEngine::PERMISSION_COPY});
+  engine->SetPermissions({DocumentPermission::kCopy});
 
   doc_info = fake_plugin_.GetAccessibilityDocInfo();
   EXPECT_EQ(kPageNumber, doc_info.page_count);
@@ -942,7 +941,7 @@ TEST_F(PdfViewPluginBaseWithEngineTest, GetAccessibilityDocInfo) {
   EXPECT_TRUE(doc_info.text_copyable);
 
   // Test engine with only copy accessible permission.
-  engine->SetPermissions({PDFEngine::PERMISSION_COPY_ACCESSIBLE});
+  engine->SetPermissions({DocumentPermission::kCopyAccessible});
 
   doc_info = fake_plugin_.GetAccessibilityDocInfo();
   EXPECT_EQ(kPageNumber, doc_info.page_count);
@@ -951,7 +950,7 @@ TEST_F(PdfViewPluginBaseWithEngineTest, GetAccessibilityDocInfo) {
 
   // Test engine with both copy and copy accessible permission.
   engine->SetPermissions(
-      {PDFEngine::PERMISSION_COPY, PDFEngine::PERMISSION_COPY_ACCESSIBLE});
+      {DocumentPermission::kCopy, DocumentPermission::kCopyAccessible});
 
   doc_info = fake_plugin_.GetAccessibilityDocInfo();
   EXPECT_EQ(kPageNumber, doc_info.page_count);

pdf/pdfium/pdfium_engine.cc

@@ -986,7 +986,7 @@ std::vector<uint8_t> PDFiumEngine::PrintPages(
 std::vector<uint8_t> PDFiumEngine::PrintPagesAsRasterPdf(
     const std::vector<int>& page_numbers,
     const blink::WebPrintParams& print_params) {
-  DCHECK(HasPermission(PERMISSION_PRINT_LOW_QUALITY));
+  DCHECK(HasPermission(DocumentPermission::kPrintLowQuality));
 
   // If document is not downloaded yet, disable printing.
   if (doc() && !doc_loader_->IsDocumentComplete())
@@ -1002,7 +1002,7 @@ std::vector<uint8_t> PDFiumEngine::PrintPagesAsRasterPdf(
 std::vector<uint8_t> PDFiumEngine::PrintPagesAsPdf(
     const std::vector<int>& page_numbers,
     const blink::WebPrintParams& print_params) {
-  DCHECK(HasPermission(PERMISSION_PRINT_HIGH_QUALITY));
+  DCHECK(HasPermission(DocumentPermission::kPrintHighQuality));
   DCHECK(doc());
 
   KillFormFocus();
@@ -2158,7 +2158,7 @@ void PDFiumEngine::InvalidateAllPages() {
 }
 
 std::string PDFiumEngine::GetSelectedText() {
-  if (!HasPermission(PDFEngine::PERMISSION_COPY))
+  if (!HasPermission(DocumentPermission::kCopy))
     return std::string();
 
   std::u16string result;

pdf/pdfium/pdfium_permissions.cc

@@ -4,8 +4,6 @@
 
 #include "pdf/pdfium/pdfium_permissions.h"
 
-#include "base/notreached.h"
-
 namespace chrome_pdf {
 
 // static
@@ -24,8 +22,7 @@ PDFiumPermissions::PDFiumPermissions(int permissions_handler_revision,
     : permissions_handler_revision_(permissions_handler_revision),
       permission_bits_(permission_bits) {}
 
-bool PDFiumPermissions::HasPermission(
-    PDFEngine::DocumentPermission permission) const {
+bool PDFiumPermissions::HasPermission(DocumentPermission permission) const {
   // PDF 1.7 spec, section 3.5.2 says: "If the revision number is 2 or greater,
   // the operations to which user access can be controlled are as follows: ..."
   //
@@ -37,12 +34,12 @@ bool PDFiumPermissions::HasPermission(
   if (permissions_handler_revision_ == 2) {
     // Security handler revision 2 rules are simple.
     switch (permission) {
-      case PDFEngine::PERMISSION_COPY:
-      case PDFEngine::PERMISSION_COPY_ACCESSIBLE:
+      case DocumentPermission::kCopy:
+      case DocumentPermission::kCopyAccessible:
         // Check the same copy bit for all copying permissions.
         return (permission_bits_ & kPDFPermissionCopyMask) != 0;
-      case PDFEngine::PERMISSION_PRINT_LOW_QUALITY:
-      case PDFEngine::PERMISSION_PRINT_HIGH_QUALITY:
+      case DocumentPermission::kPrintLowQuality:
+      case DocumentPermission::kPrintHighQuality:
         // Check the same printing bit for all printing permissions.
         return (permission_bits_ & kPDFPermissionPrintMask) != 0;
     }
@@ -50,19 +47,17 @@ bool PDFiumPermissions::HasPermission(
     // Security handler revision 3+ have different rules for interpreting the
     // bits in `permission_bits_`.
     switch (permission) {
-      case PDFEngine::PERMISSION_COPY:
+      case DocumentPermission::kCopy:
         return (permission_bits_ & kPDFPermissionCopyMask) != 0;
-      case PDFEngine::PERMISSION_COPY_ACCESSIBLE:
+      case DocumentPermission::kCopyAccessible:
         return (permission_bits_ & kPDFPermissionCopyAccessibleMask) != 0;
-      case PDFEngine::PERMISSION_PRINT_LOW_QUALITY:
+      case DocumentPermission::kPrintLowQuality:
         return (permission_bits_ & kPDFPermissionPrintMask) != 0;
-      case PDFEngine::PERMISSION_PRINT_HIGH_QUALITY:
+      case DocumentPermission::kPrintHighQuality:
         return (permission_bits_ & kPDFPermissionPrintMask) != 0 &&
                (permission_bits_ & kPDFPermissionPrintHighQualityMask) != 0;
     }
   }
-  NOTREACHED() << "Unknown permission " << permission;
-  return true;
 }
 
 }  // namespace chrome_pdf

pdf/pdfium/pdfium_permissions.h

@@ -25,7 +25,7 @@ class PDFiumPermissions final {
 
   explicit PDFiumPermissions(FPDF_DOCUMENT doc);
 
-  bool HasPermission(PDFEngine::DocumentPermission permission) const;
+  bool HasPermission(DocumentPermission permission) const;
 
  private:
   // For unit tests.

pdf/pdfium/pdfium_permissions_unittest.cc

@@ -10,11 +10,6 @@ namespace chrome_pdf {
 
 namespace {
 
-constexpr auto kPermCopy = PDFEngine::PERMISSION_COPY;
-constexpr auto kPermCopya11y = PDFEngine::PERMISSION_COPY_ACCESSIBLE;
-constexpr auto kPermPrintHigh = PDFEngine::PERMISSION_PRINT_HIGH_QUALITY;
-constexpr auto kPermPrintLow = PDFEngine::PERMISSION_PRINT_LOW_QUALITY;
-
 constexpr uint32_t GeneratePermissions2(uint32_t permissions) {
   constexpr uint32_t kBasePermissions = 0xffffffc0;
   return kBasePermissions | permissions;
@@ -48,105 +43,134 @@ TEST(PDFiumPermissionTest, InvalidSecurityHandler) {
   constexpr uint32_t kNoPermissions = 0;
   auto unknown_perms = PDFiumPermissions::CreateForTesting(
       kPDFiumUnknownRevision, kNoPermissions);
-  EXPECT_TRUE(unknown_perms.HasPermission(kPermCopy));
-  EXPECT_TRUE(unknown_perms.HasPermission(kPermCopya11y));
-  EXPECT_TRUE(unknown_perms.HasPermission(kPermPrintLow));
-  EXPECT_TRUE(unknown_perms.HasPermission(kPermPrintHigh));
+  EXPECT_TRUE(unknown_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_TRUE(unknown_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_TRUE(
+      unknown_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_TRUE(
+      unknown_perms.HasPermission(DocumentPermission::kPrintHighQuality));
 
   constexpr int kInvalidRevision = 1;
   auto obsolete_perms =
       PDFiumPermissions::CreateForTesting(kInvalidRevision, kNoPermissions);
-  EXPECT_TRUE(obsolete_perms.HasPermission(kPermCopy));
-  EXPECT_TRUE(obsolete_perms.HasPermission(kPermCopya11y));
-  EXPECT_TRUE(obsolete_perms.HasPermission(kPermPrintLow));
-  EXPECT_TRUE(obsolete_perms.HasPermission(kPermPrintHigh));
+  EXPECT_TRUE(obsolete_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_TRUE(
+      obsolete_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_TRUE(
+      obsolete_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_TRUE(
+      obsolete_perms.HasPermission(DocumentPermission::kPrintHighQuality));
 }
 
 TEST(PDFiumPermissionTest, Revision2SecurityHandler) {
   uint32_t permissions = GeneratePermissions2(0);
   auto no_perms = PDFiumPermissions::CreateForTesting(2, permissions);
-  EXPECT_FALSE(no_perms.HasPermission(kPermCopy));
-  EXPECT_FALSE(no_perms.HasPermission(kPermCopya11y));
-  EXPECT_FALSE(no_perms.HasPermission(kPermPrintLow));
-  EXPECT_FALSE(no_perms.HasPermission(kPermPrintHigh));
+  EXPECT_FALSE(no_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_FALSE(no_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_FALSE(no_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_FALSE(no_perms.HasPermission(DocumentPermission::kPrintHighQuality));
 
   permissions =
       GeneratePermissions2(kPDFPermissionCopyMask | kPDFPermissionPrintMask);
   auto all_known_perms = PDFiumPermissions::CreateForTesting(2, permissions);
-  EXPECT_TRUE(all_known_perms.HasPermission(kPermCopy));
-  EXPECT_TRUE(all_known_perms.HasPermission(kPermCopya11y));
-  EXPECT_TRUE(all_known_perms.HasPermission(kPermPrintLow));
-  EXPECT_TRUE(all_known_perms.HasPermission(kPermPrintHigh));
+  EXPECT_TRUE(all_known_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_TRUE(
+      all_known_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_TRUE(
+      all_known_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_TRUE(
+      all_known_perms.HasPermission(DocumentPermission::kPrintHighQuality));
 
   permissions = GeneratePermissions2(kPDFPermissionCopyMask);
   auto no_print_perms = PDFiumPermissions::CreateForTesting(2, permissions);
-  EXPECT_TRUE(no_print_perms.HasPermission(kPermCopy));
-  EXPECT_TRUE(no_print_perms.HasPermission(kPermCopya11y));
-  EXPECT_FALSE(no_print_perms.HasPermission(kPermPrintLow));
-  EXPECT_FALSE(no_print_perms.HasPermission(kPermPrintHigh));
+  EXPECT_TRUE(no_print_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_TRUE(
+      no_print_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_FALSE(
+      no_print_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_FALSE(
+      no_print_perms.HasPermission(DocumentPermission::kPrintHighQuality));
 
   permissions = GeneratePermissions2(kPDFPermissionPrintMask);
   auto no_copy_perms = PDFiumPermissions::CreateForTesting(2, permissions);
-  EXPECT_FALSE(no_copy_perms.HasPermission(kPermCopy));
-  EXPECT_FALSE(no_copy_perms.HasPermission(kPermCopya11y));
-  EXPECT_TRUE(no_copy_perms.HasPermission(kPermPrintLow));
-  EXPECT_TRUE(no_copy_perms.HasPermission(kPermPrintHigh));
+  EXPECT_FALSE(no_copy_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_FALSE(
+      no_copy_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_TRUE(
+      no_copy_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_TRUE(
+      no_copy_perms.HasPermission(DocumentPermission::kPrintHighQuality));
 }
 
 TEST(PDFiumPermissionTest, Revision3SecurityHandler) {
   uint32_t permissions = GeneratePermissions3(0);
   auto no_perms = PDFiumPermissions::CreateForTesting(3, permissions);
-  EXPECT_FALSE(no_perms.HasPermission(kPermCopy));
-  EXPECT_FALSE(no_perms.HasPermission(kPermCopya11y));
-  EXPECT_FALSE(no_perms.HasPermission(kPermPrintLow));
-  EXPECT_FALSE(no_perms.HasPermission(kPermPrintHigh));
+  EXPECT_FALSE(no_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_FALSE(no_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_FALSE(no_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_FALSE(no_perms.HasPermission(DocumentPermission::kPrintHighQuality));
 
   permissions = GeneratePermissions3(
       kPDFPermissionCopyAccessibleMask | kPDFPermissionCopyMask |
       kPDFPermissionPrintHighQualityMask | kPDFPermissionPrintMask);
   auto all_known_perms = PDFiumPermissions::CreateForTesting(3, permissions);
-  EXPECT_TRUE(all_known_perms.HasPermission(kPermCopy));
-  EXPECT_TRUE(all_known_perms.HasPermission(kPermCopya11y));
-  EXPECT_TRUE(all_known_perms.HasPermission(kPermPrintLow));
-  EXPECT_TRUE(all_known_perms.HasPermission(kPermPrintHigh));
+  EXPECT_TRUE(all_known_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_TRUE(
+      all_known_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_TRUE(
+      all_known_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_TRUE(
+      all_known_perms.HasPermission(DocumentPermission::kPrintHighQuality));
 
   permissions = GeneratePermissions3(kPDFPermissionCopyAccessibleMask |
                                      kPDFPermissionCopyMask);
   auto copy_no_print_perms =
       PDFiumPermissions::CreateForTesting(3, permissions);
-  EXPECT_TRUE(copy_no_print_perms.HasPermission(kPermCopy));
-  EXPECT_TRUE(copy_no_print_perms.HasPermission(kPermCopya11y));
-  EXPECT_FALSE(copy_no_print_perms.HasPermission(kPermPrintLow));
-  EXPECT_FALSE(copy_no_print_perms.HasPermission(kPermPrintHigh));
+  EXPECT_TRUE(copy_no_print_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_TRUE(
+      copy_no_print_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_FALSE(
+      copy_no_print_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_FALSE(
+      copy_no_print_perms.HasPermission(DocumentPermission::kPrintHighQuality));
 
   permissions =
       GeneratePermissions3(kPDFPermissionCopyAccessibleMask |
                            kPDFPermissionCopyMask | kPDFPermissionPrintMask);
   auto copy_low_print_perms =
       PDFiumPermissions::CreateForTesting(3, permissions);
-  EXPECT_TRUE(copy_low_print_perms.HasPermission(kPermCopy));
-  EXPECT_TRUE(copy_low_print_perms.HasPermission(kPermCopya11y));
-  EXPECT_TRUE(copy_low_print_perms.HasPermission(kPermPrintLow));
-  EXPECT_FALSE(copy_low_print_perms.HasPermission(kPermPrintHigh));
+  EXPECT_TRUE(copy_low_print_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_TRUE(
+      copy_low_print_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_TRUE(
+      copy_low_print_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_FALSE(copy_low_print_perms.HasPermission(
+      DocumentPermission::kPrintHighQuality));
 
   permissions = GeneratePermissions3(kPDFPermissionPrintHighQualityMask |
                                      kPDFPermissionPrintMask);
   auto print_no_copy_perms =
       PDFiumPermissions::CreateForTesting(3, permissions);
-  EXPECT_FALSE(print_no_copy_perms.HasPermission(kPermCopy));
-  EXPECT_FALSE(print_no_copy_perms.HasPermission(kPermCopya11y));
-  EXPECT_TRUE(print_no_copy_perms.HasPermission(kPermPrintLow));
-  EXPECT_TRUE(print_no_copy_perms.HasPermission(kPermPrintHigh));
+  EXPECT_FALSE(print_no_copy_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_FALSE(
+      print_no_copy_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_TRUE(
+      print_no_copy_perms.HasPermission(DocumentPermission::kPrintLowQuality));
+  EXPECT_TRUE(
+      print_no_copy_perms.HasPermission(DocumentPermission::kPrintHighQuality));
 
   permissions = GeneratePermissions3(kPDFPermissionCopyAccessibleMask |
                                      kPDFPermissionPrintHighQualityMask |
                                      kPDFPermissionPrintMask);
   auto print_a11y_copy_perms =
       PDFiumPermissions::CreateForTesting(3, permissions);
-  EXPECT_FALSE(print_a11y_copy_perms.HasPermission(kPermCopy));
-  EXPECT_TRUE(print_a11y_copy_perms.HasPermission(kPermCopya11y));
-  EXPECT_TRUE(print_a11y_copy_perms.HasPermission(kPermPrintLow));
-  EXPECT_TRUE(print_a11y_copy_perms.HasPermission(kPermPrintHigh));
+  EXPECT_FALSE(print_a11y_copy_perms.HasPermission(DocumentPermission::kCopy));
+  EXPECT_TRUE(
+      print_a11y_copy_perms.HasPermission(DocumentPermission::kCopyAccessible));
+  EXPECT_TRUE(print_a11y_copy_perms.HasPermission(
+      DocumentPermission::kPrintLowQuality));
+  EXPECT_TRUE(print_a11y_copy_perms.HasPermission(
+      DocumentPermission::kPrintHighQuality));
 }
 
 }  // namespace