Fix name style for CPDF_DataAvail enums.

Consistently use kFoo everywhere.

Bug: pdfium:547
Change-Id: I7eac9599273d3b92c6d4ef98d5a3daa110302858
Reviewed-on: https://pdfium-review.googlesource.com/c/pdfium/+/80351
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>
diff --git a/core/fpdfapi/parser/cpdf_cross_ref_avail.cpp b/core/fpdfapi/parser/cpdf_cross_ref_avail.cpp
index d3b8b79..cfff7dd 100644
--- a/core/fpdfapi/parser/cpdf_cross_ref_avail.cpp
+++ b/core/fpdfapi/parser/cpdf_cross_ref_avail.cpp
@@ -36,8 +36,8 @@
 CPDF_CrossRefAvail::~CPDF_CrossRefAvail() = default;
 
 CPDF_DataAvail::DocAvailStatus CPDF_CrossRefAvail::CheckAvail() {
-  if (status_ == CPDF_DataAvail::DataAvailable)
-    return CPDF_DataAvail::DataAvailable;
+  if (status_ == CPDF_DataAvail::kDataAvailable)
+    return CPDF_DataAvail::kDataAvailable;
 
   CPDF_ReadValidator::ScopedSession read_session(GetValidator());
   while (true) {
@@ -55,7 +55,7 @@
       case State::kDone:
         break;
       default: {
-        status_ = CPDF_DataAvail::DataError;
+        status_ = CPDF_DataAvail::kDataError;
         NOTREACHED();
         break;
       }
@@ -70,7 +70,7 @@
 
 bool CPDF_CrossRefAvail::CheckReadProblems() {
   if (GetValidator()->read_error()) {
-    status_ = CPDF_DataAvail::DataError;
+    status_ = CPDF_DataAvail::kDataError;
     return true;
   }
   return GetValidator()->has_unavailable_data();
@@ -80,7 +80,7 @@
   if (cross_refs_for_check_.empty()) {
     // All cross refs were checked.
     state_ = State::kDone;
-    status_ = CPDF_DataAvail::DataAvailable;
+    status_ = CPDF_DataAvail::kDataAvailable;
     return true;
   }
   parser_->SetPos(cross_refs_for_check_.front());
@@ -104,7 +104,7 @@
     return false;
 
   if (keyword != kCrossRefKeyword) {
-    status_ = CPDF_DataAvail::DataError;
+    status_ = CPDF_DataAvail::kDataError;
     return false;
   }
 
@@ -120,7 +120,7 @@
     return false;
 
   if (keyword.IsEmpty()) {
-    status_ = CPDF_DataAvail::DataError;
+    status_ = CPDF_DataAvail::kDataError;
     return false;
   }
 
@@ -141,12 +141,12 @@
     return false;
 
   if (!trailer) {
-    status_ = CPDF_DataAvail::DataError;
+    status_ = CPDF_DataAvail::kDataError;
     return false;
   }
 
   if (ToReference(trailer->GetObjectFor(kEncryptKey))) {
-    status_ = CPDF_DataAvail::DataError;
+    status_ = CPDF_DataAvail::kDataError;
     return false;
   }
 
@@ -177,12 +177,12 @@
   const CPDF_Dictionary* trailer =
       cross_ref && cross_ref->IsStream() ? cross_ref->GetDict() : nullptr;
   if (!trailer) {
-    status_ = CPDF_DataAvail::DataError;
+    status_ = CPDF_DataAvail::kDataError;
     return false;
   }
 
   if (ToReference(trailer->GetObjectFor(kEncryptKey))) {
-    status_ = CPDF_DataAvail::DataError;
+    status_ = CPDF_DataAvail::kDataError;
     return false;
   }
 
diff --git a/core/fpdfapi/parser/cpdf_cross_ref_avail.h b/core/fpdfapi/parser/cpdf_cross_ref_avail.h
index 7c9ba4a..5cc56ec 100644
--- a/core/fpdfapi/parser/cpdf_cross_ref_avail.h
+++ b/core/fpdfapi/parser/cpdf_cross_ref_avail.h
@@ -45,7 +45,7 @@
 
   UnownedPtr<CPDF_SyntaxParser> const parser_;
   const FX_FILESIZE last_crossref_offset_;
-  CPDF_DataAvail::DocAvailStatus status_ = CPDF_DataAvail::DataNotAvailable;
+  CPDF_DataAvail::DocAvailStatus status_ = CPDF_DataAvail::kDataNotAvailable;
   State state_ = State::kCrossRefCheck;
   FX_FILESIZE offset_ = 0;
   std::queue<FX_FILESIZE> cross_refs_for_check_;
diff --git a/core/fpdfapi/parser/cpdf_cross_ref_avail_unittest.cpp b/core/fpdfapi/parser/cpdf_cross_ref_avail_unittest.cpp
index 644d1cb..f39db78 100644
--- a/core/fpdfapi/parser/cpdf_cross_ref_avail_unittest.cpp
+++ b/core/fpdfapi/parser/cpdf_cross_ref_avail_unittest.cpp
@@ -41,7 +41,7 @@
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
 
-  EXPECT_EQ(CPDF_DataAvail::DataAvailable, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, CheckCrossRefStream) {
@@ -58,7 +58,7 @@
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
 
-  EXPECT_EQ(CPDF_DataAvail::DataAvailable, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, IncorrectStartOffset) {
@@ -76,7 +76,7 @@
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
 
-  EXPECT_EQ(CPDF_DataAvail::DataError, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataError, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, IncorrectPrevOffset) {
@@ -92,7 +92,7 @@
   auto parser = MakeParserForBuffer(xref_stream);
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
-  EXPECT_EQ(CPDF_DataAvail::DataError, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataError, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, IncorrectPrevStreamOffset) {
@@ -114,7 +114,7 @@
   auto parser = MakeParserForBuffer(xref_table);
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
-  EXPECT_EQ(CPDF_DataAvail::DataError, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataError, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, IncorrectData) {
@@ -126,7 +126,7 @@
   auto parser = MakeParserForBuffer(incorrect_data);
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
-  EXPECT_EQ(CPDF_DataAvail::DataError, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataError, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, ThreeCrossRefV4) {
@@ -174,7 +174,7 @@
   auto parser = MakeParserForBuffer(pdfium::as_bytes(pdfium::make_span(table)));
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
-  EXPECT_EQ(CPDF_DataAvail::DataAvailable, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, ThreeCrossRefV5) {
@@ -218,7 +218,7 @@
   auto parser = MakeParserForBuffer(pdfium::as_bytes(pdfium::make_span(table)));
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
-  EXPECT_EQ(CPDF_DataAvail::DataAvailable, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, Mixed) {
@@ -267,7 +267,7 @@
   auto parser = MakeParserForBuffer(pdfium::as_bytes(pdfium::make_span(table)));
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
-  EXPECT_EQ(CPDF_DataAvail::DataAvailable, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, CrossRefV5IsNotStream) {
@@ -281,7 +281,7 @@
   auto parser = MakeParserForBuffer(invalid_xref_stream);
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
-  EXPECT_EQ(CPDF_DataAvail::DataError, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataError, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, CrossRefV4WithEncryptRef) {
@@ -304,7 +304,7 @@
   auto parser = MakeParserForBuffer(xref_table);
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
-  EXPECT_EQ(CPDF_DataAvail::DataError, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataError, cross_ref_avail->CheckAvail());
 }
 
 TEST(CPDF_CrossRefAvailTest, CrossRefStreamWithEncryptRef) {
@@ -320,5 +320,5 @@
   auto parser = MakeParserForBuffer(xref_stream);
   auto cross_ref_avail =
       std::make_unique<CPDF_CrossRefAvail>(parser.get(), last_crossref_offset);
-  EXPECT_EQ(CPDF_DataAvail::DataError, cross_ref_avail->CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataError, cross_ref_avail->CheckAvail());
 }
diff --git a/core/fpdfapi/parser/cpdf_data_avail.cpp b/core/fpdfapi/parser/cpdf_data_avail.cpp
index 01b7205..855584f 100644
--- a/core/fpdfapi/parser/cpdf_data_avail.cpp
+++ b/core/fpdfapi/parser/cpdf_data_avail.cpp
@@ -103,17 +103,17 @@
 CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::IsDocAvail(
     DownloadHints* pHints) {
   if (!m_dwFileLen)
-    return DataError;
+    return kDataError;
 
   DCHECK(m_SeenPageObjList.empty());
   AutoRestorer<std::set<uint32_t>> seen_objects_restorer(&m_SeenPageObjList);
   const HintsScope hints_scope(GetValidator(), pHints);
   while (!m_bDocAvail) {
     if (!CheckDocStatus())
-      return DataNotAvailable;
+      return kDataNotAvailable;
   }
 
-  return DataAvailable;
+  return kDataAvailable;
 }
 
 bool CPDF_DataAvail::CheckDocStatus() {
@@ -192,11 +192,11 @@
   }
 
   switch (m_pCrossRefAvail->CheckAvail()) {
-    case DocAvailStatus::DataAvailable:
+    case kDataAvailable:
       break;
-    case DocAvailStatus::DataNotAvailable:
+    case kDataNotAvailable:
       return false;
-    case DocAvailStatus::DataError:
+    case kDataError:
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return false;
     default:
@@ -405,13 +405,13 @@
 
 bool CPDF_DataAvail::CheckHeader() {
   switch (CheckHeaderAndLinearized()) {
-    case DocAvailStatus::DataAvailable:
+    case kDataAvailable:
       m_docStatus = m_pLinearized ? PDF_DATAAVAIL_FIRSTPAGE
                                   : PDF_DATAAVAIL_LOADALLCROSSREF;
       return true;
-    case DocAvailStatus::DataNotAvailable:
+    case kDataNotAvailable:
       return false;
-    case DocAvailStatus::DataError:
+    case kDataError:
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return true;
     default:
@@ -476,39 +476,38 @@
 
 CPDF_DataAvail::DocLinearizationStatus CPDF_DataAvail::IsLinearizedPDF() {
   switch (CheckHeaderAndLinearized()) {
-    case DocAvailStatus::DataAvailable:
-      return m_pLinearized ? DocLinearizationStatus::Linearized
-                           : DocLinearizationStatus::NotLinearized;
-    case DocAvailStatus::DataNotAvailable:
-      return DocLinearizationStatus::LinearizationUnknown;
-    case DocAvailStatus::DataError:
-      return DocLinearizationStatus::NotLinearized;
+    case kDataAvailable:
+      return m_pLinearized ? kLinearized : kNotLinearized;
+    case kDataNotAvailable:
+      return kLinearizationUnknown;
+    case kDataError:
+      return kNotLinearized;
     default:
       NOTREACHED();
-      return DocLinearizationStatus::LinearizationUnknown;
+      return kLinearizationUnknown;
   }
 }
 
 CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::CheckHeaderAndLinearized() {
   if (m_bHeaderAvail)
-    return DocAvailStatus::DataAvailable;
+    return kDataAvailable;
 
   CPDF_ReadValidator::ScopedSession read_session(GetValidator());
   const Optional<FX_FILESIZE> header_offset = GetHeaderOffset(GetValidator());
   if (GetValidator()->has_read_problems())
-    return DocAvailStatus::DataNotAvailable;
+    return kDataNotAvailable;
 
   if (!header_offset)
-    return DocAvailStatus::DataError;
+    return kDataError;
 
   m_parser.m_pSyntax =
       std::make_unique<CPDF_SyntaxParser>(GetValidator(), *header_offset);
   m_pLinearized = m_parser.ParseLinearizedHeader();
   if (GetValidator()->has_read_problems())
-    return DocAvailStatus::DataNotAvailable;
+    return kDataNotAvailable;
 
   m_bHeaderAvail = true;
-  return DocAvailStatus::DataAvailable;
+  return kDataAvailable;
 }
 
 bool CPDF_DataAvail::CheckPage(uint32_t dwPage) {
@@ -749,11 +748,11 @@
 
 CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::CheckLinearizedData() {
   if (m_bLinearedDataOK)
-    return DataAvailable;
+    return kDataAvailable;
   DCHECK(m_pLinearized);
   if (!m_pLinearized->GetMainXRefTableFirstEntryOffset() || !m_pDocument ||
       !m_pDocument->GetParser() || !m_pDocument->GetParser()->GetTrailer()) {
-    return DataError;
+    return kDataError;
   }
 
   if (!m_bMainXRefLoadTried) {
@@ -761,46 +760,46 @@
         m_pDocument->GetParser()->GetTrailer()->GetIntegerFor("Prev");
     const FX_FILESIZE main_xref_offset = prev.ValueOrDefault(-1);
     if (main_xref_offset < 0)
-      return DataError;
+      return kDataError;
 
     if (main_xref_offset == 0)
-      return DataAvailable;
+      return kDataAvailable;
 
     FX_SAFE_SIZE_T data_size = m_dwFileLen;
     data_size -= main_xref_offset;
     if (!data_size.IsValid())
-      return DataError;
+      return kDataError;
 
     if (!GetValidator()->CheckDataRangeAndRequestIfUnavailable(
             main_xref_offset, data_size.ValueOrDie()))
-      return DataNotAvailable;
+      return kDataNotAvailable;
 
     CPDF_Parser::Error eRet =
         m_pDocument->GetParser()->LoadLinearizedMainXRefTable();
     m_bMainXRefLoadTried = true;
     if (eRet != CPDF_Parser::SUCCESS)
-      return DataError;
+      return kDataError;
 
     if (!PreparePageItem())
-      return DataNotAvailable;
+      return kDataNotAvailable;
 
     m_bMainXRefLoadedOK = true;
     m_bLinearedDataOK = true;
   }
 
-  return m_bLinearedDataOK ? DataAvailable : DataNotAvailable;
+  return m_bLinearedDataOK ? kDataAvailable : kDataNotAvailable;
 }
 
 CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::IsPageAvail(
     uint32_t dwPage,
     DownloadHints* pHints) {
   if (!m_pDocument)
-    return DataError;
+    return kDataError;
 
   const int iPage = pdfium::base::checked_cast<int>(dwPage);
   if (iPage >= m_pDocument->GetPageCount()) {
     // This is XFA page.
-    return DataAvailable;
+    return kDataAvailable;
   }
 
   if (IsFirstCheck(dwPage)) {
@@ -808,14 +807,14 @@
   }
 
   if (pdfium::Contains(m_pagesLoadState, dwPage))
-    return DataAvailable;
+    return kDataAvailable;
 
   const HintsScope hints_scope(GetValidator(), pHints);
   if (m_pLinearized) {
     if (dwPage == m_pLinearized->GetFirstPageNo()) {
       auto* pPageDict = m_pDocument->GetPageDictionary(iPage);
       if (!pPageDict)
-        return DataError;
+        return kDataError;
 
       auto page_num_obj = std::make_pair(
           dwPage, std::make_unique<CPDF_PageObjectAvail>(
@@ -828,45 +827,45 @@
     }
 
     DocAvailStatus nResult = CheckLinearizedData();
-    if (nResult != DataAvailable)
+    if (nResult != kDataAvailable)
       return nResult;
 
     if (m_pHintTables) {
       nResult = m_pHintTables->CheckPage(dwPage);
-      if (nResult != DataAvailable)
+      if (nResult != kDataAvailable)
         return nResult;
       if (GetPageDictionary(dwPage)) {
         m_pagesLoadState.insert(dwPage);
-        return DataAvailable;
+        return kDataAvailable;
       }
     }
 
     if (!m_bMainXRefLoadedOK) {
       if (!LoadAllFile())
-        return DataNotAvailable;
+        return kDataNotAvailable;
       m_pDocument->GetParser()->RebuildCrossRef();
       ResetFirstCheck(dwPage);
-      return DataAvailable;
+      return kDataAvailable;
     }
     if (m_bTotalLoadPageTree) {
       if (!LoadPages())
-        return DataNotAvailable;
+        return kDataNotAvailable;
     } else {
       if (!m_bCurPageDictLoadOK && !CheckPage(dwPage))
-        return DataNotAvailable;
+        return kDataNotAvailable;
     }
   } else {
     if (!m_bTotalLoadPageTree && !m_bCurPageDictLoadOK && !CheckPage(dwPage)) {
-      return DataNotAvailable;
+      return kDataNotAvailable;
     }
   }
 
-  if (CheckAcroForm() == DocFormStatus::FormNotAvailable)
-    return DataNotAvailable;
+  if (CheckAcroForm() == kFormNotAvailable)
+    return kDataNotAvailable;
 
   auto* pPageDict = m_pDocument->GetPageDictionary(iPage);
   if (!pPageDict)
-    return DataError;
+    return kDataError;
 
   {
     auto page_num_obj = std::make_pair(
@@ -875,18 +874,18 @@
     CPDF_PageObjectAvail* page_obj_avail =
         m_PagesObjAvail.insert(std::move(page_num_obj)).first->second.get();
     const DocAvailStatus status = page_obj_avail->CheckAvail();
-    if (status != DocAvailStatus::DataAvailable)
+    if (status != kDataAvailable)
       return status;
   }
 
   const DocAvailStatus resources_status = CheckResources(pPageDict);
-  if (resources_status != DocAvailStatus::DataAvailable)
+  if (resources_status != kDataAvailable)
     return resources_status;
 
   m_bCurPageDictLoadOK = false;
   ResetFirstCheck(dwPage);
   m_pagesLoadState.insert(dwPage);
-  return DataAvailable;
+  return kDataAvailable;
 }
 
 CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::CheckResources(
@@ -895,10 +894,10 @@
   CPDF_ReadValidator::ScopedSession read_session(GetValidator());
   CPDF_Object* resources = GetResourceObject(page);
   if (GetValidator()->has_read_problems())
-    return DocAvailStatus::DataNotAvailable;
+    return kDataNotAvailable;
 
   if (!resources)
-    return DocAvailStatus::DataAvailable;
+    return kDataAvailable;
 
   CPDF_PageObjectAvail* resource_avail =
       m_PagesResourcesAvail
@@ -963,39 +962,39 @@
 
 CPDF_DataAvail::DocFormStatus CPDF_DataAvail::CheckAcroForm() {
   if (!m_pDocument)
-    return FormAvailable;
+    return kFormAvailable;
 
   if (m_pLinearized) {
     DocAvailStatus nDocStatus = CheckLinearizedData();
-    if (nDocStatus == DataError)
-      return FormError;
-    if (nDocStatus == DataNotAvailable)
-      return FormNotAvailable;
+    if (nDocStatus == kDataError)
+      return kFormError;
+    if (nDocStatus == kDataNotAvailable)
+      return kFormNotAvailable;
   }
 
   if (!m_pFormAvail) {
     CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
     if (!pRoot)
-      return FormAvailable;
+      return kFormAvailable;
 
     CPDF_Object* pAcroForm = pRoot->GetObjectFor("AcroForm");
     if (!pAcroForm)
-      return FormNotExist;
+      return kFormNotExist;
 
     m_pFormAvail = std::make_unique<CPDF_PageObjectAvail>(
         GetValidator(), m_pDocument.Get(), pAcroForm);
   }
   switch (m_pFormAvail->CheckAvail()) {
-    case DocAvailStatus::DataError:
-      return DocFormStatus::FormError;
-    case DocAvailStatus::DataNotAvailable:
-      return DocFormStatus::FormNotAvailable;
-    case DocAvailStatus::DataAvailable:
-      return DocFormStatus::FormAvailable;
+    case kDataError:
+      return kFormError;
+    case kDataNotAvailable:
+      return kFormNotAvailable;
+    case kDataAvailable:
+      return kFormAvailable;
     default:
       NOTREACHED();
   }
-  return DocFormStatus::FormError;
+  return kFormError;
 }
 
 bool CPDF_DataAvail::ValidatePage(uint32_t dwPage) const {
@@ -1004,7 +1003,7 @@
   if (!pPageDict)
     return false;
   CPDF_PageObjectAvail obj_avail(GetValidator(), m_pDocument.Get(), pPageDict);
-  return obj_avail.CheckAvail() == DocAvailStatus::DataAvailable;
+  return obj_avail.CheckAvail() == kDataAvailable;
 }
 
 std::pair<CPDF_Parser::Error, std::unique_ptr<CPDF_Document>>
diff --git a/core/fpdfapi/parser/cpdf_data_avail.h b/core/fpdfapi/parser/cpdf_data_avail.h
index 8dc0394..b8a993f 100644
--- a/core/fpdfapi/parser/cpdf_data_avail.h
+++ b/core/fpdfapi/parser/cpdf_data_avail.h
@@ -56,28 +56,28 @@
   // #include that header. fpdfsdk/fpdf_dataavail.cpp has static_asserts
   // to make sure the two sets of values match.
   enum DocAvailStatus {
-    DataError = -1,        // PDF_DATA_ERROR
-    DataNotAvailable = 0,  // PDF_DATA_NOTAVAIL
-    DataAvailable = 1,     // PDF_DATA_AVAIL
+    kDataError = -1,        // PDF_DATA_ERROR
+    kDataNotAvailable = 0,  // PDF_DATA_NOTAVAIL
+    kDataAvailable = 1,     // PDF_DATA_AVAIL
   };
 
   // Must match PDF_*LINEAR* definitions in public/fpdf_dataavail.h, but cannot
   // #include that header. fpdfsdk/fpdf_dataavail.cpp has static_asserts
   // to make sure the two sets of values match.
   enum DocLinearizationStatus {
-    LinearizationUnknown = -1,  // PDF_LINEARIZATION_UNKNOWN
-    NotLinearized = 0,          // PDF_NOT_LINEARIZED
-    Linearized = 1,             // PDF_LINEARIZED
+    kLinearizationUnknown = -1,  // PDF_LINEARIZATION_UNKNOWN
+    kNotLinearized = 0,          // PDF_NOT_LINEARIZED
+    kLinearized = 1,             // PDF_LINEARIZED
   };
 
   // Must match PDF_FORM_* definitions in public/fpdf_dataavail.h, but cannot
   // #include that header. fpdfsdk/fpdf_dataavail.cpp has static_asserts
   // to make sure the two sets of values match.
   enum DocFormStatus {
-    FormError = -1,        // PDF_FORM_ERROR
-    FormNotAvailable = 0,  // PDF_FORM_NOTAVAIL
-    FormAvailable = 1,     // PDF_FORM_AVAIL
-    FormNotExist = 2,      // PDF_FORM_NOTEXIST
+    kFormError = -1,        // PDF_FORM_ERROR
+    kFormNotAvailable = 0,  // PDF_FORM_NOTAVAIL
+    kFormAvailable = 1,     // PDF_FORM_AVAIL
+    kFormNotExist = 2,      // PDF_FORM_NOTEXIST
   };
 
   class FileAvail {
diff --git a/core/fpdfapi/parser/cpdf_hint_tables.cpp b/core/fpdfapi/parser/cpdf_hint_tables.cpp
index f256bab..4d8fea2 100644
--- a/core/fpdfapi/parser/cpdf_hint_tables.cpp
+++ b/core/fpdfapi/parser/cpdf_hint_tables.cpp
@@ -404,18 +404,18 @@
 
 CPDF_DataAvail::DocAvailStatus CPDF_HintTables::CheckPage(uint32_t index) {
   if (index == m_pLinearized->GetFirstPageNo())
-    return CPDF_DataAvail::DataAvailable;
+    return CPDF_DataAvail::kDataAvailable;
 
   if (index >= m_pLinearized->GetPageCount())
-    return CPDF_DataAvail::DataError;
+    return CPDF_DataAvail::kDataError;
 
   const uint32_t dwLength = m_PageInfos[index].page_length();
   if (!dwLength)
-    return CPDF_DataAvail::DataError;
+    return CPDF_DataAvail::kDataError;
 
   if (!m_pValidator->CheckDataRangeAndRequestIfUnavailable(
           m_PageInfos[index].page_offset(), dwLength)) {
-    return CPDF_DataAvail::DataNotAvailable;
+    return CPDF_DataAvail::kDataNotAvailable;
   }
 
   // Download data of shared objects in the page.
@@ -426,14 +426,14 @@
         m_SharedObjGroupInfos[dwIndex];
 
     if (!shared_group_info.m_szOffset || !shared_group_info.m_dwLength)
-      return CPDF_DataAvail::DataError;
+      return CPDF_DataAvail::kDataError;
 
     if (!m_pValidator->CheckDataRangeAndRequestIfUnavailable(
             shared_group_info.m_szOffset, shared_group_info.m_dwLength)) {
-      return CPDF_DataAvail::DataNotAvailable;
+      return CPDF_DataAvail::kDataNotAvailable;
     }
   }
-  return CPDF_DataAvail::DataAvailable;
+  return CPDF_DataAvail::kDataAvailable;
 }
 
 bool CPDF_HintTables::LoadHintStream(CPDF_Stream* pHintStream) {
diff --git a/core/fpdfapi/parser/cpdf_hint_tables_unittest.cpp b/core/fpdfapi/parser/cpdf_hint_tables_unittest.cpp
index b895775..0b04610 100644
--- a/core/fpdfapi/parser/cpdf_hint_tables_unittest.cpp
+++ b/core/fpdfapi/parser/cpdf_hint_tables_unittest.cpp
@@ -71,8 +71,7 @@
 
 TEST_F(CPDF_HintTablesTest, Load) {
   auto data_avail = MakeDataAvailFromFile("feature_linearized_loading.pdf");
-  ASSERT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable,
-            data_avail->IsDocAvail(nullptr));
+  ASSERT_EQ(CPDF_DataAvail::kDataAvailable, data_avail->IsDocAvail(nullptr));
 
   ASSERT_TRUE(data_avail->GetHintTables());
 
@@ -99,8 +98,7 @@
 
 TEST_F(CPDF_HintTablesTest, PageAndGroupInfos) {
   auto data_avail = MakeDataAvailFromFile("feature_linearized_loading.pdf");
-  ASSERT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable,
-            data_avail->IsDocAvail(nullptr));
+  ASSERT_EQ(CPDF_DataAvail::kDataAvailable, data_avail->IsDocAvail(nullptr));
 
   const CPDF_HintTables* hint_tables = data_avail->GetHintTables();
   ASSERT_TRUE(hint_tables);
diff --git a/core/fpdfapi/parser/cpdf_object_avail.cpp b/core/fpdfapi/parser/cpdf_object_avail.cpp
index 6a2ec20..05c55ab 100644
--- a/core/fpdfapi/parser/cpdf_object_avail.cpp
+++ b/core/fpdfapi/parser/cpdf_object_avail.cpp
@@ -41,13 +41,13 @@
 
 CPDF_DataAvail::DocAvailStatus CPDF_ObjectAvail::CheckAvail() {
   if (!LoadRootObject())
-    return CPDF_DataAvail::DocAvailStatus::DataNotAvailable;
+    return CPDF_DataAvail::kDataNotAvailable;
 
   if (CheckObjects()) {
     CleanMemory();
-    return CPDF_DataAvail::DocAvailStatus::DataAvailable;
+    return CPDF_DataAvail::kDataAvailable;
   }
-  return CPDF_DataAvail::DocAvailStatus::DataNotAvailable;
+  return CPDF_DataAvail::kDataNotAvailable;
 }
 
 bool CPDF_ObjectAvail::LoadRootObject() {
diff --git a/core/fpdfapi/parser/cpdf_object_avail_unittest.cpp b/core/fpdfapi/parser/cpdf_object_avail_unittest.cpp
index e6e3b20..20f0033 100644
--- a/core/fpdfapi/parser/cpdf_object_avail_unittest.cpp
+++ b/core/fpdfapi/parser/cpdf_object_avail_unittest.cpp
@@ -133,10 +133,9 @@
   holder.AddObject(1, pdfium::MakeRetain<CPDF_String>(nullptr, "string", false),
                    TestHolder::ObjectState::Unavailable);
   CPDF_ObjectAvail avail(holder.GetValidator(), &holder, 1);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataNotAvailable,
-            avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataNotAvailable, avail.CheckAvail());
   holder.SetObjectState(1, TestHolder::ObjectState::Available);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
 
 TEST(CPDF_ObjectAvailTest, OneReferencedObject) {
@@ -146,15 +145,13 @@
   holder.AddObject(2, pdfium::MakeRetain<CPDF_String>(nullptr, "string", false),
                    TestHolder::ObjectState::Unavailable);
   CPDF_ObjectAvail avail(holder.GetValidator(), &holder, 1);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataNotAvailable,
-            avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataNotAvailable, avail.CheckAvail());
 
   holder.SetObjectState(1, TestHolder::ObjectState::Available);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataNotAvailable,
-            avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataNotAvailable, avail.CheckAvail());
 
   holder.SetObjectState(2, TestHolder::ObjectState::Available);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
 
 TEST(CPDF_ObjectAvailTest, CycledReferences) {
@@ -167,19 +164,16 @@
                    TestHolder::ObjectState::Unavailable);
 
   CPDF_ObjectAvail avail(holder.GetValidator(), &holder, 1);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataNotAvailable,
-            avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataNotAvailable, avail.CheckAvail());
 
   holder.SetObjectState(1, TestHolder::ObjectState::Available);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataNotAvailable,
-            avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataNotAvailable, avail.CheckAvail());
 
   holder.SetObjectState(2, TestHolder::ObjectState::Available);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataNotAvailable,
-            avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataNotAvailable, avail.CheckAvail());
 
   holder.SetObjectState(3, TestHolder::ObjectState::Available);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
 
 TEST(CPDF_ObjectAvailTest, DoNotCheckParent) {
@@ -193,12 +187,11 @@
                                                                 &holder, 1);
 
   CPDF_ObjectAvail avail(holder.GetValidator(), &holder, 2);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataNotAvailable,
-            avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataNotAvailable, avail.CheckAvail());
 
   holder.SetObjectState(2, TestHolder::ObjectState::Available);
   //  Object should be available in case when "Parent" object is unavailable.
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
 
 TEST(CPDF_ObjectAvailTest, Generic) {
@@ -217,11 +210,10 @@
 
   CPDF_ObjectAvail avail(holder.GetValidator(), &holder, 1);
   for (uint32_t i = 1; i <= kDepth; ++i) {
-    EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataNotAvailable,
-              avail.CheckAvail());
+    EXPECT_EQ(CPDF_DataAvail::kDataNotAvailable, avail.CheckAvail());
     holder.SetObjectState(i, TestHolder::ObjectState::Available);
   }
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
 
 TEST(CPDF_ObjectAvailTest, NotExcludeRoot) {
@@ -229,7 +221,7 @@
   holder.AddObject(1, pdfium::MakeRetain<CPDF_Dictionary>(),
                    TestHolder::ObjectState::Available);
   CPDF_ObjectAvailFailOnExclude avail(holder.GetValidator(), &holder, 1);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
 
 TEST(CPDF_ObjectAvailTest, NotExcludeReferedRoot) {
@@ -239,7 +231,7 @@
   holder.AddObject(2, pdfium::MakeRetain<CPDF_Dictionary>(),
                    TestHolder::ObjectState::Available);
   CPDF_ObjectAvailFailOnExclude avail(holder.GetValidator(), &holder, 1);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
 
 TEST(CPDF_ObjectAvailTest, Exclude) {
@@ -258,7 +250,7 @@
       pdfium::MakeRetain<CPDF_String>(nullptr, "Not available string", false),
       TestHolder::ObjectState::Unavailable);
   CPDF_ObjectAvailExcludeArray avail(holder.GetValidator(), &holder, 1);
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
 
 TEST(CPDF_ObjectAvailTest, ReadErrorOnExclude) {
@@ -288,15 +280,14 @@
 
   CPDF_ObjectAvailExcludeTypeKey avail(holder.GetValidator(), &holder, 1);
 
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataNotAvailable,
-            avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataNotAvailable, avail.CheckAvail());
 
   // Make "Type" value object available.
   holder.SetObjectState(3, TestHolder::ObjectState::Available);
 
   // Now object should be available, although the object '4' is not available,
   // because it is in skipped dictionary.
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
 
 TEST(CPDF_ObjectAvailTest, IgnoreNotExistsObject) {
@@ -308,7 +299,7 @@
   CPDF_ObjectAvail avail(holder.GetValidator(), &holder, 1);
   // Now object should be available, although the object '2' is not exists. But
   // all exists in file related data are checked.
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
 
 TEST(CPDF_ObjectAvailTest, CheckTwice) {
@@ -340,10 +331,9 @@
 
   CPDF_ObjectAvail avail(holder.GetValidator(), &holder, root);
 
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataNotAvailable,
-            avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataNotAvailable, avail.CheckAvail());
 
   holder.SetObjectState(2, TestHolder::ObjectState::Available);
 
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
diff --git a/core/fpdfapi/parser/cpdf_page_object_avail_unittest.cpp b/core/fpdfapi/parser/cpdf_page_object_avail_unittest.cpp
index 64b01e5..0d74d58 100644
--- a/core/fpdfapi/parser/cpdf_page_object_avail_unittest.cpp
+++ b/core/fpdfapi/parser/cpdf_page_object_avail_unittest.cpp
@@ -119,5 +119,5 @@
   CPDF_PageObjectAvail avail(holder.GetValidator(), &holder, 1);
   // Now object should be available, although the object '4' is not available,
   // because it is in skipped other page.
-  EXPECT_EQ(CPDF_DataAvail::DocAvailStatus::DataAvailable, avail.CheckAvail());
+  EXPECT_EQ(CPDF_DataAvail::kDataAvailable, avail.CheckAvail());
 }
diff --git a/fpdfsdk/fpdf_dataavail.cpp b/fpdfsdk/fpdf_dataavail.cpp
index 96e2f6c..669cc53 100644
--- a/fpdfsdk/fpdf_dataavail.cpp
+++ b/fpdfsdk/fpdf_dataavail.cpp
@@ -25,28 +25,29 @@
 #endif  // PDF_ENABLE_XFA
 
 // These checks are here because core/ and public/ cannot depend on each other.
-static_assert(CPDF_DataAvail::DataError == PDF_DATA_ERROR,
-              "CPDF_DataAvail::DataError value mismatch");
-static_assert(CPDF_DataAvail::DataNotAvailable == PDF_DATA_NOTAVAIL,
-              "CPDF_DataAvail::DataNotAvailable value mismatch");
-static_assert(CPDF_DataAvail::DataAvailable == PDF_DATA_AVAIL,
-              "CPDF_DataAvail::DataAvailable value mismatch");
+static_assert(CPDF_DataAvail::kDataError == PDF_DATA_ERROR,
+              "CPDF_DataAvail::kDataError value mismatch");
+static_assert(CPDF_DataAvail::kDataNotAvailable == PDF_DATA_NOTAVAIL,
+              "CPDF_DataAvail::kDataNotAvailable value mismatch");
+static_assert(CPDF_DataAvail::kDataAvailable == PDF_DATA_AVAIL,
+              "CPDF_DataAvail::kDataAvailable value mismatch");
 
-static_assert(CPDF_DataAvail::LinearizationUnknown == PDF_LINEARIZATION_UNKNOWN,
-              "CPDF_DataAvail::LinearizationUnknown value mismatch");
-static_assert(CPDF_DataAvail::NotLinearized == PDF_NOT_LINEARIZED,
-              "CPDF_DataAvail::NotLinearized value mismatch");
-static_assert(CPDF_DataAvail::Linearized == PDF_LINEARIZED,
-              "CPDF_DataAvail::Linearized value mismatch");
+static_assert(CPDF_DataAvail::kLinearizationUnknown ==
+                  PDF_LINEARIZATION_UNKNOWN,
+              "CPDF_DataAvail::kLinearizationUnknown value mismatch");
+static_assert(CPDF_DataAvail::kNotLinearized == PDF_NOT_LINEARIZED,
+              "CPDF_DataAvail::kNotLinearized value mismatch");
+static_assert(CPDF_DataAvail::kLinearized == PDF_LINEARIZED,
+              "CPDF_DataAvail::kLinearized value mismatch");
 
-static_assert(CPDF_DataAvail::FormError == PDF_FORM_ERROR,
-              "CPDF_DataAvail::FormError value mismatch");
-static_assert(CPDF_DataAvail::FormNotAvailable == PDF_FORM_NOTAVAIL,
-              "CPDF_DataAvail::FormNotAvailable value mismatch");
-static_assert(CPDF_DataAvail::FormAvailable == PDF_FORM_AVAIL,
-              "CPDF_DataAvail::FormAvailable value mismatch");
-static_assert(CPDF_DataAvail::FormNotExist == PDF_FORM_NOTEXIST,
-              "CPDF_DataAvail::FormNotExist value mismatch");
+static_assert(CPDF_DataAvail::kFormError == PDF_FORM_ERROR,
+              "CPDF_DataAvail::kFormError value mismatch");
+static_assert(CPDF_DataAvail::kFormNotAvailable == PDF_FORM_NOTAVAIL,
+              "CPDF_DataAvail::kFormNotAvailable value mismatch");
+static_assert(CPDF_DataAvail::kFormAvailable == PDF_FORM_AVAIL,
+              "CPDF_DataAvail::kFormAvailable value mismatch");
+static_assert(CPDF_DataAvail::kFormNotExist == PDF_FORM_NOTEXIST,
+              "CPDF_DataAvail::kFormNotExist value mismatch");
 
 namespace {