diff --git a/core/fpdfapi/edit/cpdf_pagecontentgenerator_unittest.cpp b/core/fpdfapi/edit/cpdf_pagecontentgenerator_unittest.cpp
index 786e08c..e809729 100644
--- a/core/fpdfapi/edit/cpdf_pagecontentgenerator_unittest.cpp
+++ b/core/fpdfapi/edit/cpdf_pagecontentgenerator_unittest.cpp
@@ -79,7 +79,8 @@
 
 TEST_F(CPDF_PageContentGeneratorTest, BUG_937) {
   static const std::vector<float> rgb = {0.000000000000000000001f, 0.7f, 0.35f};
-  RetainPtr<CPDF_ColorSpace> pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+  RetainPtr<CPDF_ColorSpace> pCS =
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB);
   {
     auto pPathObj = std::make_unique<CPDF_PathObject>();
     pPathObj->set_filltype(CFX_FillRenderOptions::FillType::kWinding);
@@ -181,7 +182,8 @@
   pPathObj->path().AppendPointAndClose(CFX_PointF(5, 6), FXPT_TYPE::LineTo);
 
   static const std::vector<float> rgb = {0.5f, 0.7f, 0.35f};
-  RetainPtr<CPDF_ColorSpace> pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+  RetainPtr<CPDF_ColorSpace> pCS =
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB);
   pPathObj->m_ColorState.SetFillColor(pCS, rgb);
 
   static const std::vector<float> rgb2 = {1, 0.9f, 0};
@@ -247,7 +249,8 @@
   pTextObj->m_TextState.SetFontSize(10.0f);
 
   static const std::vector<float> rgb = {0.5f, 0.7f, 0.35f};
-  RetainPtr<CPDF_ColorSpace> pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+  RetainPtr<CPDF_ColorSpace> pCS =
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB);
   pTextObj->m_ColorState.SetFillColor(pCS, rgb);
 
   static const std::vector<float> rgb2 = {1, 0.9f, 0};
diff --git a/core/fpdfapi/page/cpdf_color.cpp b/core/fpdfapi/page/cpdf_color.cpp
index 53f3214..221f860 100644
--- a/core/fpdfapi/page/cpdf_color.cpp
+++ b/core/fpdfapi/page/cpdf_color.cpp
@@ -23,7 +23,7 @@
 }
 
 bool CPDF_Color::IsPatternInternal() const {
-  return m_pCS->GetFamily() == PDFCS_PATTERN;
+  return m_pCS->GetFamily() == CPDF_ColorSpace::Family::kPattern;
 }
 
 void CPDF_Color::SetColorSpace(const RetainPtr<CPDF_ColorSpace>& pCS) {
@@ -48,9 +48,10 @@
   if (values.size() > kMaxPatternColorComps)
     return;
 
-  if (!IsPattern())
-    SetColorSpace(CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN));
-
+  if (!IsPattern()) {
+    SetColorSpace(
+        CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kPattern));
+  }
   m_pValue->SetPattern(pPattern);
   m_pValue->SetComps(values);
 }
@@ -71,7 +72,8 @@
 }
 
 bool CPDF_Color::IsColorSpaceRGB() const {
-  return m_pCS == CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+  return m_pCS ==
+         CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB);
 }
 
 bool CPDF_Color::GetRGB(int* R, int* G, int* B) const {
diff --git a/core/fpdfapi/page/cpdf_colorspace.cpp b/core/fpdfapi/page/cpdf_colorspace.cpp
index 13061b5..a9edf79 100644
--- a/core/fpdfapi/page/cpdf_colorspace.cpp
+++ b/core/fpdfapi/page/cpdf_colorspace.cpp
@@ -468,18 +468,18 @@
 RetainPtr<CPDF_ColorSpace> CPDF_ColorSpace::ColorspaceFromName(
     const ByteString& name) {
   if (name == "DeviceRGB" || name == "RGB")
-    return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+    return GetStockCS(Family::kDeviceRGB);
   if (name == "DeviceGray" || name == "G")
-    return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
+    return GetStockCS(Family::kDeviceGray);
   if (name == "DeviceCMYK" || name == "CMYK")
-    return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
+    return GetStockCS(Family::kDeviceCMYK);
   if (name == "Pattern")
-    return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
+    return GetStockCS(Family::kPattern);
   return nullptr;
 }
 
 // static
-RetainPtr<CPDF_ColorSpace> CPDF_ColorSpace::GetStockCS(int family) {
+RetainPtr<CPDF_ColorSpace> CPDF_ColorSpace::GetStockCS(Family family) {
   return CPDF_PageModule::GetInstance()->GetStockCS(family);
 }
 
@@ -575,13 +575,13 @@
 }
 
 // static
-uint32_t CPDF_ColorSpace::ComponentsForFamily(int family) {
+uint32_t CPDF_ColorSpace::ComponentsForFamily(Family family) {
   switch (family) {
-    case PDFCS_DEVICEGRAY:
+    case Family::kDeviceGray:
       return 1;
-    case PDFCS_DEVICERGB:
+    case Family::kDeviceRGB:
       return 3;
-    case PDFCS_DEVICECMYK:
+    case Family::kDeviceCMYK:
       return 4;
     default:
       NOTREACHED();
@@ -595,7 +595,7 @@
 }
 
 std::vector<float> CPDF_ColorSpace::CreateBufAndSetDefaultColor() const {
-  DCHECK(m_Family != PDFCS_PATTERN);
+  DCHECK(m_Family != Family::kPattern);
 
   float min;
   float max;
@@ -629,7 +629,7 @@
   float R;
   float G;
   float B;
-  const int divisor = m_Family != PDFCS_INDEXED ? 255 : 1;
+  const int divisor = m_Family != Family::kIndexed ? 255 : 1;
   for (int i = 0; i < pixels; i++) {
     for (uint32_t j = 0; j < m_nComponents; j++)
       src[j] = static_cast<float>(*src_buf++) / divisor;
@@ -648,9 +648,10 @@
 }
 
 bool CPDF_ColorSpace::IsNormal() const {
-  return GetFamily() == PDFCS_DEVICEGRAY || GetFamily() == PDFCS_DEVICERGB ||
-         GetFamily() == PDFCS_DEVICECMYK || GetFamily() == PDFCS_CALGRAY ||
-         GetFamily() == PDFCS_CALRGB;
+  return GetFamily() == Family::kDeviceGray ||
+         GetFamily() == Family::kDeviceRGB ||
+         GetFamily() == Family::kDeviceCMYK ||
+         GetFamily() == Family::kCalGray || GetFamily() == Family::kCalRGB;
 }
 
 CPDF_PatternCS* CPDF_ColorSpace::AsPatternCS() {
@@ -671,7 +672,7 @@
   return false;
 }
 
-CPDF_ColorSpace::CPDF_ColorSpace(CPDF_Document* pDoc, int family)
+CPDF_ColorSpace::CPDF_ColorSpace(CPDF_Document* pDoc, Family family)
     : m_pDocument(pDoc), m_Family(family) {}
 
 CPDF_ColorSpace::~CPDF_ColorSpace() = default;
@@ -682,7 +683,7 @@
 }
 
 CPDF_CalGray::CPDF_CalGray(CPDF_Document* pDoc)
-    : CPDF_ColorSpace(pDoc, PDFCS_CALGRAY) {}
+    : CPDF_ColorSpace(pDoc, Family::kCalGray) {}
 
 CPDF_CalGray::~CPDF_CalGray() = default;
 
@@ -728,7 +729,7 @@
 }
 
 CPDF_CalRGB::CPDF_CalRGB(CPDF_Document* pDoc)
-    : CPDF_ColorSpace(pDoc, PDFCS_CALRGB) {}
+    : CPDF_ColorSpace(pDoc, Family::kCalRGB) {}
 
 CPDF_CalRGB::~CPDF_CalRGB() = default;
 
@@ -817,7 +818,7 @@
 }
 
 CPDF_LabCS::CPDF_LabCS(CPDF_Document* pDoc)
-    : CPDF_ColorSpace(pDoc, PDFCS_LAB) {}
+    : CPDF_ColorSpace(pDoc, Family::kLab) {}
 
 CPDF_LabCS::~CPDF_LabCS() = default;
 
@@ -918,7 +919,7 @@
 }
 
 CPDF_ICCBasedCS::CPDF_ICCBasedCS(CPDF_Document* pDoc)
-    : CPDF_ColorSpace(pDoc, PDFCS_ICCBASED) {}
+    : CPDF_ColorSpace(pDoc, Family::kICCBased) {}
 
 CPDF_ICCBasedCS::~CPDF_ICCBasedCS() = default;
 
@@ -1092,7 +1093,7 @@
   if (!pAlterCS)
     return false;
 
-  if (pAlterCS->GetFamily() == PDFCS_PATTERN)
+  if (pAlterCS->GetFamily() == Family::kPattern)
     return false;
 
   if (pAlterCS->CountComponents() != nExpectedComponents)
@@ -1106,11 +1107,11 @@
 RetainPtr<CPDF_ColorSpace> CPDF_ICCBasedCS::GetStockAlternateProfile(
     uint32_t nComponents) {
   if (nComponents == 1)
-    return GetStockCS(PDFCS_DEVICEGRAY);
+    return GetStockCS(Family::kDeviceGray);
   if (nComponents == 3)
-    return GetStockCS(PDFCS_DEVICERGB);
+    return GetStockCS(Family::kDeviceRGB);
   if (nComponents == 4)
-    return GetStockCS(PDFCS_DEVICECMYK);
+    return GetStockCS(Family::kDeviceCMYK);
   NOTREACHED();
   return nullptr;
 }
@@ -1135,7 +1136,7 @@
 }
 
 CPDF_IndexedCS::CPDF_IndexedCS(CPDF_Document* pDoc)
-    : CPDF_ColorSpace(pDoc, PDFCS_INDEXED) {}
+    : CPDF_ColorSpace(pDoc, Family::kIndexed) {}
 
 CPDF_IndexedCS::~CPDF_IndexedCS() = default;
 
@@ -1156,8 +1157,8 @@
 
   // The base color space cannot be a Pattern or Indexed space, according to the
   // PDF 1.7 spec, page 263.
-  int family = m_pBaseCS->GetFamily();
-  if (family == PDFCS_INDEXED || family == PDFCS_PATTERN)
+  Family family = m_pBaseCS->GetFamily();
+  if (family == Family::kIndexed || family == Family::kPattern)
     return 0;
 
   m_nBaseComponents = m_pBaseCS->CountComponents();
@@ -1221,7 +1222,7 @@
 }
 
 CPDF_SeparationCS::CPDF_SeparationCS(CPDF_Document* pDoc)
-    : CPDF_ColorSpace(pDoc, PDFCS_SEPARATION) {}
+    : CPDF_ColorSpace(pDoc, Family::kSeparation) {}
 
 CPDF_SeparationCS::~CPDF_SeparationCS() = default;
 
@@ -1305,7 +1306,7 @@
 }
 
 CPDF_DeviceNCS::CPDF_DeviceNCS(CPDF_Document* pDoc)
-    : CPDF_ColorSpace(pDoc, PDFCS_DEVICEN) {}
+    : CPDF_ColorSpace(pDoc, Family::kDeviceN) {}
 
 CPDF_DeviceNCS::~CPDF_DeviceNCS() = default;
 
diff --git a/core/fpdfapi/page/cpdf_colorspace.h b/core/fpdfapi/page/cpdf_colorspace.h
index 22745f0..543ca2e 100644
--- a/core/fpdfapi/page/cpdf_colorspace.h
+++ b/core/fpdfapi/page/cpdf_colorspace.h
@@ -20,18 +20,6 @@
 #include "core/fxcrt/unowned_ptr.h"
 #include "third_party/base/span.h"
 
-#define PDFCS_DEVICEGRAY 1
-#define PDFCS_DEVICERGB 2
-#define PDFCS_DEVICECMYK 3
-#define PDFCS_CALGRAY 4
-#define PDFCS_CALRGB 5
-#define PDFCS_LAB 6
-#define PDFCS_ICCBASED 7
-#define PDFCS_SEPARATION 8
-#define PDFCS_DEVICEN 9
-#define PDFCS_INDEXED 10
-#define PDFCS_PATTERN 11
-
 class CPDF_Array;
 class CPDF_Document;
 class CPDF_Object;
@@ -63,7 +51,22 @@
 
 class CPDF_ColorSpace : public Retainable, public Observable {
  public:
-  static RetainPtr<CPDF_ColorSpace> GetStockCS(int Family);
+  enum class Family {
+    kUnknown = 0,
+    kDeviceGray = 1,
+    kDeviceRGB = 2,
+    kDeviceCMYK = 3,
+    kCalGray = 4,
+    kCalRGB = 5,
+    kLab = 6,
+    kICCBased = 7,
+    kSeparation = 8,
+    kDeviceN = 9,
+    kIndexed = 10,
+    kPattern = 11,
+  };
+
+  static RetainPtr<CPDF_ColorSpace> GetStockCS(Family family);
   static RetainPtr<CPDF_ColorSpace> ColorspaceFromName(const ByteString& name);
   static RetainPtr<CPDF_ColorSpace> Load(CPDF_Document* pDoc,
                                          CPDF_Object* pObj);
@@ -71,7 +74,8 @@
       CPDF_Document* pDoc,
       const CPDF_Object* pObj,
       std::set<const CPDF_Object*>* pVisited);
-  static uint32_t ComponentsForFamily(int family);
+
+  static uint32_t ComponentsForFamily(Family family);
   static bool IsValidIccComponents(int components);
 
   const CPDF_Array* GetArray() const { return m_pArray.Get(); }
@@ -81,10 +85,11 @@
   std::vector<float> CreateBufAndSetDefaultColor() const;
 
   uint32_t CountComponents() const;
-  int GetFamily() const { return m_Family; }
+  Family GetFamily() const { return m_Family; }
   bool IsSpecial() const {
-    return GetFamily() == PDFCS_SEPARATION || GetFamily() == PDFCS_DEVICEN ||
-           GetFamily() == PDFCS_INDEXED || GetFamily() == PDFCS_PATTERN;
+    return GetFamily() == Family::kSeparation ||
+           GetFamily() == Family::kDeviceN || GetFamily() == Family::kIndexed ||
+           GetFamily() == Family::kPattern;
   }
 
   virtual bool GetRGB(pdfium::span<const float> pBuf,
@@ -116,7 +121,7 @@
                              float* B) const;
 
  protected:
-  CPDF_ColorSpace(CPDF_Document* pDoc, int family);
+  CPDF_ColorSpace(CPDF_Document* pDoc, Family family);
   ~CPDF_ColorSpace() override;
 
   // Returns the number of components, or 0 on failure.
@@ -130,7 +135,7 @@
 
   UnownedPtr<const CPDF_Document> const m_pDocument;
   RetainPtr<const CPDF_Array> m_pArray;
-  const int m_Family;
+  const Family m_Family;
   uint32_t m_dwStdConversion = 0;
 
  private:
diff --git a/core/fpdfapi/page/cpdf_colorstate.cpp b/core/fpdfapi/page/cpdf_colorstate.cpp
index 8137653..64824df 100644
--- a/core/fpdfapi/page/cpdf_colorstate.cpp
+++ b/core/fpdfapi/page/cpdf_colorstate.cpp
@@ -102,11 +102,12 @@
   DCHECK(color);
   DCHECK(colorref);
 
-  if (pCS)
+  if (pCS) {
     color->SetColorSpace(pCS);
-  else if (color->IsNull())
-    color->SetColorSpace(CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY));
-
+  } else if (color->IsNull()) {
+    color->SetColorSpace(
+        CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceGray));
+  }
   if (color->CountComponents() > values.size())
     return;
 
@@ -152,8 +153,10 @@
 void CPDF_ColorState::ColorData::SetDefault() {
   m_FillColorRef = 0;
   m_StrokeColorRef = 0;
-  m_FillColor.SetColorSpace(CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY));
-  m_StrokeColor.SetColorSpace(CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY));
+  m_FillColor.SetColorSpace(
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceGray));
+  m_StrokeColor.SetColorSpace(
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceGray));
 }
 
 RetainPtr<CPDF_ColorState::ColorData> CPDF_ColorState::ColorData::Clone()
diff --git a/core/fpdfapi/page/cpdf_devicecs.cpp b/core/fpdfapi/page/cpdf_devicecs.cpp
index 36a6c7a..25fefe0 100644
--- a/core/fpdfapi/page/cpdf_devicecs.cpp
+++ b/core/fpdfapi/page/cpdf_devicecs.cpp
@@ -27,9 +27,9 @@
 
 }  // namespace
 
-CPDF_DeviceCS::CPDF_DeviceCS(int family) : CPDF_ColorSpace(nullptr, family) {
-  DCHECK(family == PDFCS_DEVICEGRAY || family == PDFCS_DEVICERGB ||
-         family == PDFCS_DEVICECMYK);
+CPDF_DeviceCS::CPDF_DeviceCS(Family family) : CPDF_ColorSpace(nullptr, family) {
+  DCHECK(family == Family::kDeviceGray || family == Family::kDeviceRGB ||
+         family == Family::kDeviceCMYK);
   SetComponentsForStockCS(ComponentsForFamily(GetFamily()));
 }
 
@@ -49,17 +49,17 @@
                            float* G,
                            float* B) const {
   switch (m_Family) {
-    case PDFCS_DEVICEGRAY:
+    case Family::kDeviceGray:
       *R = NormalizeChannel(pBuf[0]);
       *G = *R;
       *B = *R;
       return true;
-    case PDFCS_DEVICERGB:
+    case Family::kDeviceRGB:
       *R = NormalizeChannel(pBuf[0]);
       *G = NormalizeChannel(pBuf[1]);
       *B = NormalizeChannel(pBuf[2]);
       return true;
-    case PDFCS_DEVICECMYK:
+    case Family::kDeviceCMYK:
       if (m_dwStdConversion) {
         float k = pBuf[3];
         *R = 1.0f - std::min(1.0f, pBuf[0] + k);
@@ -84,17 +84,17 @@
                                        int image_height,
                                        bool bTransMask) const {
   switch (m_Family) {
-    case PDFCS_DEVICEGRAY:
+    case Family::kDeviceGray:
       for (int i = 0; i < pixels; i++) {
         *pDestBuf++ = pSrcBuf[i];
         *pDestBuf++ = pSrcBuf[i];
         *pDestBuf++ = pSrcBuf[i];
       }
       break;
-    case PDFCS_DEVICERGB:
+    case Family::kDeviceRGB:
       fxcodec::ReverseRGB(pDestBuf, pSrcBuf, pixels);
       break;
-    case PDFCS_DEVICECMYK:
+    case Family::kDeviceCMYK:
       if (bTransMask) {
         for (int i = 0; i < pixels; i++) {
           int k = 255 - pSrcBuf[3];
diff --git a/core/fpdfapi/page/cpdf_devicecs.h b/core/fpdfapi/page/cpdf_devicecs.h
index 2815974..9848052 100644
--- a/core/fpdfapi/page/cpdf_devicecs.h
+++ b/core/fpdfapi/page/cpdf_devicecs.h
@@ -33,7 +33,7 @@
                   std::set<const CPDF_Object*>* pVisited) override;
 
  private:
-  explicit CPDF_DeviceCS(int family);
+  explicit CPDF_DeviceCS(Family family);
 };
 
 #endif  // CORE_FPDFAPI_PAGE_CPDF_DEVICECS_H_
diff --git a/core/fpdfapi/page/cpdf_devicecs_unittest.cpp b/core/fpdfapi/page/cpdf_devicecs_unittest.cpp
index fbf2558..5022778 100644
--- a/core/fpdfapi/page/cpdf_devicecs_unittest.cpp
+++ b/core/fpdfapi/page/cpdf_devicecs_unittest.cpp
@@ -13,7 +13,8 @@
   float R;
   float G;
   float B;
-  auto device_gray = pdfium::MakeRetain<CPDF_DeviceCS>(PDFCS_DEVICEGRAY);
+  auto device_gray =
+      pdfium::MakeRetain<CPDF_DeviceCS>(CPDF_ColorSpace::Family::kDeviceGray);
 
   // Test normal values. For gray, only first value from buf should be used.
   float buf[3] = {0.43f, 0.11f, 0.34f};
@@ -56,7 +57,8 @@
   float R;
   float G;
   float B;
-  auto device_rgb = pdfium::MakeRetain<CPDF_DeviceCS>(PDFCS_DEVICERGB);
+  auto device_rgb =
+      pdfium::MakeRetain<CPDF_DeviceCS>(CPDF_ColorSpace::Family::kDeviceRGB);
 
   // Test normal values
   float buf[3] = {0.13f, 1.0f, 0.652f};
@@ -85,7 +87,8 @@
   float R;
   float G;
   float B;
-  auto device_cmyk = pdfium::MakeRetain<CPDF_DeviceCS>(PDFCS_DEVICECMYK);
+  auto device_cmyk =
+      pdfium::MakeRetain<CPDF_DeviceCS>(CPDF_ColorSpace::Family::kDeviceCMYK);
 
   // Test normal values
   float buf[4] = {0.6f, 0.5f, 0.3f, 0.9f};
diff --git a/core/fpdfapi/page/cpdf_dib.cpp b/core/fpdfapi/page/cpdf_dib.cpp
index 1c2f9ae..60f2079 100644
--- a/core/fpdfapi/page/cpdf_dib.cpp
+++ b/core/fpdfapi/page/cpdf_dib.cpp
@@ -98,7 +98,7 @@
     CPDF_ColorSpace* pCS) {
   if (!pCS)
     return CJPX_Decoder::kNoColorSpace;
-  if (pCS->GetFamily() == PDFCS_INDEXED)
+  if (pCS->GetFamily() == CPDF_ColorSpace::Family::kIndexed)
     return CJPX_Decoder::kIndexedColorSpace;
   return CJPX_Decoder::kNormalColorSpace;
 }
@@ -127,9 +127,10 @@
       return JpxDecodeAction::kFail;
     }
 
-    if (pdf_colorspace == CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB))
+    if (pdf_colorspace ==
+        CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB)) {
       return JpxDecodeAction::kUseRgb;
-
+    }
     return JpxDecodeAction::kDoNothing;
   }
 
@@ -172,7 +173,7 @@
   if (!IsValidDimension(m_Width) || !IsValidDimension(m_Height))
     return false;
 
-  m_GroupFamily = 0;
+  m_GroupFamily = CPDF_ColorSpace::Family::kUnknown;
   m_bLoadMask = false;
   if (!LoadColorInfo(nullptr, nullptr))
     return false;
@@ -255,7 +256,7 @@
     const CPDF_Dictionary* pFormResources,
     const CPDF_Dictionary* pPageResources,
     bool bStdCS,
-    uint32_t GroupFamily,
+    CPDF_ColorSpace::Family GroupFamily,
     bool bLoadMask) {
   if (!pStream)
     return LoadState::kFail;
@@ -426,7 +427,7 @@
   // decoded.
   m_nComponents = m_pColorSpace->CountComponents();
   m_Family = m_pColorSpace->GetFamily();
-  if (m_Family == PDFCS_ICCBASED && pCSObj->IsName()) {
+  if (m_Family == CPDF_ColorSpace::Family::kICCBased && pCSObj->IsName()) {
     ByteString cs = pCSObj->GetString();
     if (cs == "DeviceGray")
       m_nComponents = 1;
@@ -460,7 +461,7 @@
       float def_min;
       float def_max;
       m_pColorSpace->GetDefaultValue(i, &def_value, &def_min, &def_max);
-      if (m_Family == PDFCS_INDEXED)
+      if (m_Family == CPDF_ColorSpace::Family::kIndexed)
         def_max = max_data;
       if (def_min != m_CompData[i].m_DecodeMin || def_max != max)
         *bDefaultDecode = false;
@@ -470,7 +471,7 @@
       float def_value;
       m_pColorSpace->GetDefaultValue(i, &def_value, &m_CompData[i].m_DecodeMin,
                                      &m_CompData[i].m_DecodeStep);
-      if (m_Family == PDFCS_INDEXED)
+      if (m_Family == CPDF_ColorSpace::Family::kIndexed)
         m_CompData[i].m_DecodeStep = max_data;
       m_CompData[i].m_DecodeStep =
           (m_CompData[i].m_DecodeStep - m_CompData[i].m_DecodeMin) / max_data;
@@ -585,20 +586,20 @@
   if (m_pColorSpace) {
     uint32_t colorspace_comps = m_pColorSpace->CountComponents();
     switch (m_Family) {
-      case PDFCS_DEVICEGRAY:
-      case PDFCS_DEVICERGB:
-      case PDFCS_DEVICECMYK: {
+      case CPDF_ColorSpace::Family::kDeviceGray:
+      case CPDF_ColorSpace::Family::kDeviceRGB:
+      case CPDF_ColorSpace::Family::kDeviceCMYK: {
         uint32_t dwMinComps = CPDF_ColorSpace::ComponentsForFamily(m_Family);
         if (colorspace_comps < dwMinComps || m_nComponents < dwMinComps)
           return false;
         break;
       }
-      case PDFCS_LAB: {
+      case CPDF_ColorSpace::Family::kLab: {
         if (m_nComponents != 3 || colorspace_comps < 3)
           return false;
         break;
       }
-      case PDFCS_ICCBASED: {
+      case CPDF_ColorSpace::Family::kICCBased: {
         if (!CPDF_ColorSpace::IsValidIccComponents(colorspace_comps) ||
             !CPDF_ColorSpace::IsValidIccComponents(m_nComponents) ||
             colorspace_comps < m_nComponents) {
@@ -613,7 +614,7 @@
       }
     }
   } else {
-    if (m_Family == PDFCS_LAB && m_nComponents != 3)
+    if (m_Family == CPDF_ColorSpace::Family::kLab && m_nComponents != 3)
       return false;
   }
   if (!GetDecodeAndMaskArray(&m_bDefaultDecode, &m_bColorKey))
@@ -658,7 +659,8 @@
       break;
 
     case JpxDecodeAction::kUseCmyk:
-      m_pColorSpace = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
+      m_pColorSpace =
+          CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceCMYK);
       break;
 
     case JpxDecodeAction::kConvertArgbToRgb:
@@ -742,7 +744,8 @@
       }
     }
     result_bitmap = std::move(rgb_bitmap);
-  } else if (m_pColorSpace && m_pColorSpace->GetFamily() == PDFCS_INDEXED &&
+  } else if (m_pColorSpace &&
+             m_pColorSpace->GetFamily() == CPDF_ColorSpace::Family::kIndexed &&
              m_bpc < 8) {
     int scale = 8 - m_bpc;
     for (uint32_t row = 0; row < image_info.height; ++row) {
@@ -781,7 +784,8 @@
   }
 
   const CPDF_Array* pMatte = mask->GetDict()->GetArrayFor("Matte");
-  if (pMatte && m_pColorSpace && m_Family != PDFCS_PATTERN &&
+  if (pMatte && m_pColorSpace &&
+      m_Family != CPDF_ColorSpace::Family::kPattern &&
       pMatte->size() == m_nComponents &&
       m_pColorSpace->CountComponents() <= m_nComponents) {
     std::vector<float> colors =
@@ -827,7 +831,8 @@
     RetainPtr<const CPDF_Stream> mask) {
   m_pMask = pdfium::MakeRetain<CPDF_DIB>();
   LoadState ret = m_pMask->StartLoadDIBBase(
-      m_pDocument.Get(), mask.Get(), false, nullptr, nullptr, true, 0, false);
+      m_pDocument.Get(), mask.Get(), false, nullptr, nullptr, true,
+      CPDF_ColorSpace::Family::kUnknown, false);
   if (ret == LoadState::kContinue) {
     if (m_Status == LoadState::kFail)
       m_Status = LoadState::kContinue;
@@ -839,7 +844,7 @@
 }
 
 void CPDF_DIB::LoadPalette() {
-  if (!m_pColorSpace || m_Family == PDFCS_PATTERN)
+  if (!m_pColorSpace || m_Family == CPDF_ColorSpace::Family::kPattern)
     return;
 
   if (m_bpc == 0)
@@ -854,8 +859,8 @@
     return;
 
   if (bits == 1) {
-    if (m_bDefaultDecode &&
-        (m_Family == PDFCS_DEVICEGRAY || m_Family == PDFCS_DEVICERGB)) {
+    if (m_bDefaultDecode && (m_Family == CPDF_ColorSpace::Family::kDeviceGray ||
+                             m_Family == CPDF_ColorSpace::Family::kDeviceRGB)) {
       return;
     }
     if (m_pColorSpace->CountComponents() > 3) {
@@ -885,7 +890,8 @@
     return;
   }
   if (m_bpc == 8 && m_bDefaultDecode &&
-      m_pColorSpace == CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY)) {
+      m_pColorSpace ==
+          CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceGray)) {
     return;
   }
 
@@ -903,7 +909,7 @@
     float R = 0;
     float G = 0;
     float B = 0;
-    if (m_nComponents == 1 && m_Family == PDFCS_ICCBASED &&
+    if (m_nComponents == 1 && m_Family == CPDF_ColorSpace::Family::kICCBased &&
         m_pColorSpace->CountComponents() > 1) {
       int nComponents = m_pColorSpace->CountComponents();
       std::vector<float> temp_buf(nComponents);
@@ -976,7 +982,7 @@
       R = (1.0f - color_values[0]) * k;
       G = (1.0f - color_values[1]) * k;
       B = (1.0f - color_values[2]) * k;
-    } else if (m_Family != PDFCS_PATTERN) {
+    } else if (m_Family != CPDF_ColorSpace::Family::kPattern) {
       m_pColorSpace->GetRGB(color_values, &R, &G, &B);
     }
     R = pdfium::clamp(R, 0.0f, 1.0f);
@@ -995,7 +1001,8 @@
   if (!m_bDefaultDecode)
     return false;
 
-  if (m_Family != PDFCS_DEVICERGB && m_Family != PDFCS_CALRGB) {
+  if (m_Family != CPDF_ColorSpace::Family::kDeviceRGB &&
+      m_Family != CPDF_ColorSpace::Family::kCalRGB) {
     if (m_bpc != 8)
       return false;
 
@@ -1454,8 +1461,8 @@
 }
 
 bool CPDF_DIB::TransMask() const {
-  return m_bLoadMask && m_GroupFamily == PDFCS_DEVICECMYK &&
-         m_Family == PDFCS_DEVICECMYK;
+  return m_bLoadMask && m_GroupFamily == CPDF_ColorSpace::Family::kDeviceCMYK &&
+         m_Family == CPDF_ColorSpace::Family::kDeviceCMYK;
 }
 
 void CPDF_DIB::SetMaskProperties() {
diff --git a/core/fpdfapi/page/cpdf_dib.h b/core/fpdfapi/page/cpdf_dib.h
index 4d9f91d..286bd31 100644
--- a/core/fpdfapi/page/cpdf_dib.h
+++ b/core/fpdfapi/page/cpdf_dib.h
@@ -65,7 +65,7 @@
                              const CPDF_Dictionary* pFormResources,
                              const CPDF_Dictionary* pPageResources,
                              bool bStdCS,
-                             uint32_t GroupFamily,
+                             CPDF_ColorSpace::Family GroupFamily,
                              bool bLoadMask);
   LoadState ContinueLoadDIBBase(PauseIndicatorIface* pPause);
   RetainPtr<CPDF_DIB> DetachMask();
@@ -140,11 +140,11 @@
   RetainPtr<const CPDF_Dictionary> m_pDict;
   RetainPtr<CPDF_StreamAcc> m_pStreamAcc;
   RetainPtr<CPDF_ColorSpace> m_pColorSpace;
-  uint32_t m_Family = 0;
   uint32_t m_bpc = 0;
   uint32_t m_bpc_orig = 0;
   uint32_t m_nComponents = 0;
-  uint32_t m_GroupFamily = 0;
+  CPDF_ColorSpace::Family m_Family = CPDF_ColorSpace::Family::kUnknown;
+  CPDF_ColorSpace::Family m_GroupFamily = CPDF_ColorSpace::Family::kUnknown;
   uint32_t m_MatteColor = 0;
   LoadState m_Status = LoadState::kFail;
   bool m_bLoadMask = false;
diff --git a/core/fpdfapi/page/cpdf_docpagedata.cpp b/core/fpdfapi/page/cpdf_docpagedata.cpp
index 921a3c8..56b9880 100644
--- a/core/fpdfapi/page/cpdf_docpagedata.cpp
+++ b/core/fpdfapi/page/cpdf_docpagedata.cpp
@@ -284,15 +284,17 @@
 
     const CPDF_Object* pDefaultCS = nullptr;
     switch (pCS->GetFamily()) {
-      case PDFCS_DEVICERGB:
+      case CPDF_ColorSpace::Family::kDeviceRGB:
         pDefaultCS = pColorSpaces->GetDirectObjectFor("DefaultRGB");
         break;
-      case PDFCS_DEVICEGRAY:
+      case CPDF_ColorSpace::Family::kDeviceGray:
         pDefaultCS = pColorSpaces->GetDirectObjectFor("DefaultGray");
         break;
-      case PDFCS_DEVICECMYK:
+      case CPDF_ColorSpace::Family::kDeviceCMYK:
         pDefaultCS = pColorSpaces->GetDirectObjectFor("DefaultCMYK");
         break;
+      default:
+        break;
     }
     if (!pDefaultCS)
       return pCS;
diff --git a/core/fpdfapi/page/cpdf_image.cpp b/core/fpdfapi/page/cpdf_image.cpp
index f389d5c..a7a9360 100644
--- a/core/fpdfapi/page/cpdf_image.cpp
+++ b/core/fpdfapi/page/cpdf_image.cpp
@@ -353,7 +353,7 @@
 bool CPDF_Image::StartLoadDIBBase(const CPDF_Dictionary* pFormResource,
                                   const CPDF_Dictionary* pPageResource,
                                   bool bStdCS,
-                                  uint32_t GroupFamily,
+                                  CPDF_ColorSpace::Family GroupFamily,
                                   bool bLoadMask) {
   auto source = pdfium::MakeRetain<CPDF_DIB>();
   CPDF_DIB::LoadState ret = source->StartLoadDIBBase(
diff --git a/core/fpdfapi/page/cpdf_image.h b/core/fpdfapi/page/cpdf_image.h
index 2503a81..d725f5f 100644
--- a/core/fpdfapi/page/cpdf_image.h
+++ b/core/fpdfapi/page/cpdf_image.h
@@ -7,6 +7,7 @@
 #ifndef CORE_FPDFAPI_PAGE_CPDF_IMAGE_H_
 #define CORE_FPDFAPI_PAGE_CPDF_IMAGE_H_
 
+#include "core/fpdfapi/page/cpdf_colorspace.h"
 #include "core/fxcrt/fx_system.h"
 #include "core/fxcrt/retain_ptr.h"
 #include "core/fxcrt/unowned_ptr.h"
@@ -54,7 +55,7 @@
   bool StartLoadDIBBase(const CPDF_Dictionary* pFormResource,
                         const CPDF_Dictionary* pPageResource,
                         bool bStdCS,
-                        uint32_t GroupFamily,
+                        CPDF_ColorSpace::Family GroupFamily,
                         bool bLoadMask);
 
   // Returns whether to Continue() or not.
diff --git a/core/fpdfapi/page/cpdf_pagemodule.cpp b/core/fpdfapi/page/cpdf_pagemodule.cpp
index 4d81297..bdea737 100644
--- a/core/fpdfapi/page/cpdf_pagemodule.cpp
+++ b/core/fpdfapi/page/cpdf_pagemodule.cpp
@@ -38,9 +38,12 @@
 }
 
 CPDF_PageModule::CPDF_PageModule()
-    : m_StockGrayCS(pdfium::MakeRetain<CPDF_DeviceCS>(PDFCS_DEVICEGRAY)),
-      m_StockRGBCS(pdfium::MakeRetain<CPDF_DeviceCS>(PDFCS_DEVICERGB)),
-      m_StockCMYKCS(pdfium::MakeRetain<CPDF_DeviceCS>(PDFCS_DEVICECMYK)),
+    : m_StockGrayCS(pdfium::MakeRetain<CPDF_DeviceCS>(
+          CPDF_ColorSpace::Family::kDeviceGray)),
+      m_StockRGBCS(pdfium::MakeRetain<CPDF_DeviceCS>(
+          CPDF_ColorSpace::Family::kDeviceRGB)),
+      m_StockCMYKCS(pdfium::MakeRetain<CPDF_DeviceCS>(
+          CPDF_ColorSpace::Family::kDeviceCMYK)),
       m_StockPatternCS(pdfium::MakeRetain<CPDF_PatternCS>(nullptr)) {
   m_StockPatternCS->InitializeStockPattern();
   CPDF_FontGlobals::Create();
@@ -51,14 +54,15 @@
   CPDF_FontGlobals::Destroy();
 }
 
-RetainPtr<CPDF_ColorSpace> CPDF_PageModule::GetStockCS(int family) {
-  if (family == PDFCS_DEVICEGRAY)
+RetainPtr<CPDF_ColorSpace> CPDF_PageModule::GetStockCS(
+    CPDF_ColorSpace::Family family) {
+  if (family == CPDF_ColorSpace::Family::kDeviceGray)
     return m_StockGrayCS;
-  if (family == PDFCS_DEVICERGB)
+  if (family == CPDF_ColorSpace::Family::kDeviceRGB)
     return m_StockRGBCS;
-  if (family == PDFCS_DEVICECMYK)
+  if (family == CPDF_ColorSpace::Family::kDeviceCMYK)
     return m_StockCMYKCS;
-  if (family == PDFCS_PATTERN)
+  if (family == CPDF_ColorSpace::Family::kPattern)
     return m_StockPatternCS;
   return nullptr;
 }
diff --git a/core/fpdfapi/page/cpdf_pagemodule.h b/core/fpdfapi/page/cpdf_pagemodule.h
index e7234b9..fd027f1 100644
--- a/core/fpdfapi/page/cpdf_pagemodule.h
+++ b/core/fpdfapi/page/cpdf_pagemodule.h
@@ -7,10 +7,10 @@
 #ifndef CORE_FPDFAPI_PAGE_CPDF_PAGEMODULE_H_
 #define CORE_FPDFAPI_PAGE_CPDF_PAGEMODULE_H_
 
+#include "core/fpdfapi/page/cpdf_colorspace.h"
 #include "core/fxcrt/retain_ptr.h"
 
 class CPDF_Document;
-class CPDF_ColorSpace;
 class CPDF_DeviceCS;
 class CPDF_PatternCS;
 
@@ -21,7 +21,7 @@
   static void Destroy();
   static CPDF_PageModule* GetInstance();
 
-  RetainPtr<CPDF_ColorSpace> GetStockCS(int family);
+  RetainPtr<CPDF_ColorSpace> GetStockCS(CPDF_ColorSpace::Family family);
   void ClearStockFont(CPDF_Document* pDoc);
 
  private:
diff --git a/core/fpdfapi/page/cpdf_patterncs.cpp b/core/fpdfapi/page/cpdf_patterncs.cpp
index 598f5da..2c32d9c 100644
--- a/core/fpdfapi/page/cpdf_patterncs.cpp
+++ b/core/fpdfapi/page/cpdf_patterncs.cpp
@@ -12,7 +12,7 @@
 #include "third_party/base/notreached.h"
 
 CPDF_PatternCS::CPDF_PatternCS(CPDF_Document* pDoc)
-    : CPDF_ColorSpace(pDoc, PDFCS_PATTERN) {}
+    : CPDF_ColorSpace(pDoc, Family::kPattern) {}
 
 CPDF_PatternCS::~CPDF_PatternCS() = default;
 
@@ -32,7 +32,7 @@
   if (!m_pBaseCS)
     return 1;
 
-  if (m_pBaseCS->GetFamily() == PDFCS_PATTERN)
+  if (m_pBaseCS->GetFamily() == Family::kPattern)
     return 0;
 
   if (m_pBaseCS->CountComponents() > kMaxPatternColorComps)
diff --git a/core/fpdfapi/page/cpdf_shadingpattern.cpp b/core/fpdfapi/page/cpdf_shadingpattern.cpp
index a10aaf0..849f4e1 100644
--- a/core/fpdfapi/page/cpdf_shadingpattern.cpp
+++ b/core/fpdfapi/page/cpdf_shadingpattern.cpp
@@ -75,7 +75,7 @@
 
   // The color space is required and cannot be a Pattern space, according to the
   // PDF 1.7 spec, page 305.
-  if (!m_pCS || m_pCS->GetFamily() == PDFCS_PATTERN)
+  if (!m_pCS || m_pCS->GetFamily() == CPDF_ColorSpace::Family::kPattern)
     return false;
 
   m_ShadingType = ToShadingType(pShadingDict->GetIntegerFor("ShadingType"));
@@ -100,7 +100,7 @@
     case kFunctionBasedShading:
     case kAxialShading:
     case kRadialShading: {
-      if (m_pCS->GetFamily() == PDFCS_INDEXED)
+      if (m_pCS->GetFamily() == CPDF_ColorSpace::Family::kIndexed)
         return false;
       break;
     }
@@ -108,8 +108,10 @@
     case kLatticeFormGouraudTriangleMeshShading:
     case kCoonsPatchMeshShading:
     case kTensorProductPatchMeshShading: {
-      if (!m_pFunctions.empty() && m_pCS->GetFamily() == PDFCS_INDEXED)
+      if (!m_pFunctions.empty() &&
+          m_pCS->GetFamily() == CPDF_ColorSpace::Family::kIndexed) {
         return false;
+      }
       break;
     }
     default: {
diff --git a/core/fpdfapi/page/cpdf_streamcontentparser.cpp b/core/fpdfapi/page/cpdf_streamcontentparser.cpp
index e9422a0..b96b179 100644
--- a/core/fpdfapi/page/cpdf_streamcontentparser.cpp
+++ b/core/fpdfapi/page/cpdf_streamcontentparser.cpp
@@ -870,13 +870,13 @@
 
 void CPDF_StreamContentParser::Handle_SetGray_Fill() {
   RetainPtr<CPDF_ColorSpace> pCS =
-      CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceGray);
   m_pCurStates->m_ColorState.SetFillColor(pCS, GetNumbers(1));
 }
 
 void CPDF_StreamContentParser::Handle_SetGray_Stroke() {
   RetainPtr<CPDF_ColorSpace> pCS =
-      CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceGray);
   m_pCurStates->m_ColorState.SetStrokeColor(pCS, GetNumbers(1));
 }
 
@@ -921,7 +921,7 @@
     return;
 
   RetainPtr<CPDF_ColorSpace> pCS =
-      CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceCMYK);
   m_pCurStates->m_ColorState.SetFillColor(pCS, GetNumbers(4));
 }
 
@@ -930,7 +930,7 @@
     return;
 
   RetainPtr<CPDF_ColorSpace> pCS =
-      CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceCMYK);
   m_pCurStates->m_ColorState.SetStrokeColor(pCS, GetNumbers(4));
 }
 
@@ -991,7 +991,8 @@
   if (m_ParamCount != 3)
     return;
 
-  RetainPtr<CPDF_ColorSpace> pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+  RetainPtr<CPDF_ColorSpace> pCS =
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB);
   m_pCurStates->m_ColorState.SetFillColor(pCS, GetNumbers(3));
 }
 
@@ -999,7 +1000,8 @@
   if (m_ParamCount != 3)
     return;
 
-  RetainPtr<CPDF_ColorSpace> pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+  RetainPtr<CPDF_ColorSpace> pCS =
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB);
   m_pCurStates->m_ColorState.SetStrokeColor(pCS, GetNumbers(3));
 }
 
@@ -1150,20 +1152,21 @@
 RetainPtr<CPDF_ColorSpace> CPDF_StreamContentParser::FindColorSpace(
     const ByteString& name) {
   if (name == "Pattern")
-    return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
+    return CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kPattern);
 
   if (name == "DeviceGray" || name == "DeviceCMYK" || name == "DeviceRGB") {
     ByteString defname = "Default";
     defname += name.Last(name.GetLength() - 7);
     const CPDF_Object* pDefObj = FindResourceObj("ColorSpace", defname);
     if (!pDefObj) {
-      if (name == "DeviceGray")
-        return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
-
+      if (name == "DeviceGray") {
+        return CPDF_ColorSpace::GetStockCS(
+            CPDF_ColorSpace::Family::kDeviceGray);
+      }
       if (name == "DeviceRGB")
-        return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+        return CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB);
 
-      return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
+      return CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceCMYK);
     }
     return CPDF_DocPageData::FromDocument(m_pDocument.Get())
         ->GetColorSpace(pDefObj, nullptr);
diff --git a/core/fpdfapi/render/cpdf_imagerenderer.cpp b/core/fpdfapi/render/cpdf_imagerenderer.cpp
index 3d1c947..56389b5 100644
--- a/core/fpdfapi/render/cpdf_imagerenderer.cpp
+++ b/core/fpdfapi/render/cpdf_imagerenderer.cpp
@@ -149,9 +149,10 @@
   RetainPtr<CPDF_ColorSpace> pColorSpace =
       pData->GetColorSpace(pCSObj, pPageResources);
   if (pColorSpace) {
-    int format = pColorSpace->GetFamily();
-    if (format == PDFCS_DEVICECMYK || format == PDFCS_SEPARATION ||
-        format == PDFCS_DEVICEN) {
+    CPDF_ColorSpace::Family format = pColorSpace->GetFamily();
+    if (format == CPDF_ColorSpace::Family::kDeviceCMYK ||
+        format == CPDF_ColorSpace::Family::kSeparation ||
+        format == CPDF_ColorSpace::Family::kDeviceN) {
       m_BlendType = BlendMode::kDarken;
     }
   }
diff --git a/core/fpdfapi/render/cpdf_renderstatus.cpp b/core/fpdfapi/render/cpdf_renderstatus.cpp
index 979a70d..0dba6a3 100644
--- a/core/fpdfapi/render/cpdf_renderstatus.cpp
+++ b/core/fpdfapi/render/cpdf_renderstatus.cpp
@@ -1412,7 +1412,7 @@
     return nullptr;
 
   RetainPtr<CFX_DIBitmap> bitmap = bitmap_device.GetBitmap();
-  int nCSFamily = 0;
+  CPDF_ColorSpace::Family nCSFamily = CPDF_ColorSpace::Family::kUnknown;
   if (bLuminosity) {
     FX_ARGB back_color =
         GetBackColor(pSMaskDict, pGroup->GetDict(), &nCSFamily);
@@ -1480,7 +1480,7 @@
 
 FX_ARGB CPDF_RenderStatus::GetBackColor(const CPDF_Dictionary* pSMaskDict,
                                         const CPDF_Dictionary* pGroupDict,
-                                        int* pCSFamily) {
+                                        CPDF_ColorSpace::Family* pCSFamily) {
   static constexpr FX_ARGB kDefaultColor = ArgbEncode(255, 0, 0, 0);
   const CPDF_Array* pBC = pSMaskDict->GetArrayFor(pdfium::transparency::kBC);
   if (!pBC)
@@ -1497,9 +1497,9 @@
   if (!pCS)
     return kDefaultColor;
 
-  int family = pCS->GetFamily();
-  if (family == PDFCS_LAB || pCS->IsSpecial() ||
-      (family == PDFCS_ICCBASED && !pCS->IsNormal())) {
+  CPDF_ColorSpace::Family family = pCS->GetFamily();
+  if (family == CPDF_ColorSpace::Family::kLab || pCS->IsSpecial() ||
+      (family == CPDF_ColorSpace::Family::kICCBased && !pCS->IsNormal())) {
     return kDefaultColor;
   }
 
diff --git a/core/fpdfapi/render/cpdf_renderstatus.h b/core/fpdfapi/render/cpdf_renderstatus.h
index 337acff..50c85a6 100644
--- a/core/fpdfapi/render/cpdf_renderstatus.h
+++ b/core/fpdfapi/render/cpdf_renderstatus.h
@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "core/fpdfapi/page/cpdf_clippath.h"
+#include "core/fpdfapi/page/cpdf_colorspace.h"
 #include "core/fpdfapi/page/cpdf_graphicstates.h"
 #include "core/fpdfapi/page/cpdf_transparency.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
@@ -59,7 +60,9 @@
   void SetDropObjects(bool bDropObjects) { m_bDropObjects = bDropObjects; }
   void SetLoadMask(bool bLoadMask) { m_bLoadMask = bLoadMask; }
   void SetStdCS(bool bStdCS) { m_bStdCS = bStdCS; }
-  void SetGroupFamily(uint32_t family) { m_GroupFamily = family; }
+  void SetGroupFamily(CPDF_ColorSpace::Family family) {
+    m_GroupFamily = family;
+  }
   void SetTransparency(const CPDF_Transparency& transparency) {
     m_Transparency = transparency;
   }
@@ -77,7 +80,7 @@
   void ProcessClipPath(const CPDF_ClipPath& ClipPath,
                        const CFX_Matrix& mtObj2Device);
 
-  uint32_t GetGroupFamily() const { return m_GroupFamily; }
+  CPDF_ColorSpace::Family GetGroupFamily() const { return m_GroupFamily; }
   bool GetLoadMask() const { return m_bLoadMask; }
   bool GetDropObjects() const { return m_bDropObjects; }
   bool IsPrint() const { return m_bPrint; }
@@ -179,7 +182,7 @@
   // Optionally write the colorspace family value into |pCSFamily|.
   FX_ARGB GetBackColor(const CPDF_Dictionary* pSMaskDict,
                        const CPDF_Dictionary* pGroupDict,
-                       int* pCSFamily);
+                       CPDF_ColorSpace::Family* pCSFamily);
   FX_ARGB GetStrokeArgb(CPDF_PageObject* pObj) const;
   FX_RECT GetObjectClippedRect(const CPDF_PageObject* pObj,
                                const CFX_Matrix& mtObj2Device) const;
@@ -203,7 +206,7 @@
   bool m_bDropObjects = false;
   bool m_bStdCS = false;
   bool m_bLoadMask = false;
-  uint32_t m_GroupFamily = 0;
+  CPDF_ColorSpace::Family m_GroupFamily = CPDF_ColorSpace::Family::kUnknown;
   FX_ARGB m_T3FillColor = 0;
   BlendMode m_curBlend = BlendMode::kNormal;
 };
diff --git a/core/fxge/skia/fx_skia_device.cpp b/core/fxge/skia/fx_skia_device.cpp
index 15763fa..d57008c 100644
--- a/core/fxge/skia/fx_skia_device.cpp
+++ b/core/fxge/skia/fx_skia_device.cpp
@@ -2170,9 +2170,11 @@
     // TODO(caryclark) more types
     return false;
   }
-  int csFamily = pPattern->GetCS()->GetFamily();
-  if (PDFCS_DEVICERGB != csFamily && PDFCS_DEVICEGRAY != csFamily)
+  CPDF_ColorSpace::Family csFamily = pPattern->GetCS()->GetFamily();
+  if (CPDF_ColorSpace::Family::kDeviceRGB != csFamily &&
+      CPDF_ColorSpace::Family::kDeviceGray != csFamily) {
     return false;
+  }
   const std::vector<std::unique_ptr<CPDF_Function>>& pFuncs =
       pPattern->GetFuncs();
   int nFuncs = pFuncs.size();
diff --git a/fpdfsdk/fpdf_editimg.cpp b/fpdfsdk/fpdf_editimg.cpp
index 9f86f30..8419352 100644
--- a/fpdfsdk/fpdf_editimg.cpp
+++ b/fpdfsdk/fpdf_editimg.cpp
@@ -29,27 +29,39 @@
 
 // These checks ensure the consistency of colorspace values across core/ and
 // public/.
-static_assert(PDFCS_DEVICEGRAY == FPDF_COLORSPACE_DEVICEGRAY,
-              "PDFCS_DEVICEGRAY value mismatch");
-static_assert(PDFCS_DEVICERGB == FPDF_COLORSPACE_DEVICERGB,
-              "PDFCS_DEVICERGB value mismatch");
-static_assert(PDFCS_DEVICECMYK == FPDF_COLORSPACE_DEVICECMYK,
-              "PDFCS_DEVICECMYK value mismatch");
-static_assert(PDFCS_CALGRAY == FPDF_COLORSPACE_CALGRAY,
-              "PDFCS_CALGRAY value mismatch");
-static_assert(PDFCS_CALRGB == FPDF_COLORSPACE_CALRGB,
-              "PDFCS_CALRGB value mismatch");
-static_assert(PDFCS_LAB == FPDF_COLORSPACE_LAB, "PDFCS_LAB value mismatch");
-static_assert(PDFCS_ICCBASED == FPDF_COLORSPACE_ICCBASED,
-              "PDFCS_ICCBASED value mismatch");
-static_assert(PDFCS_SEPARATION == FPDF_COLORSPACE_SEPARATION,
-              "PDFCS_SEPARATION value mismatch");
-static_assert(PDFCS_DEVICEN == FPDF_COLORSPACE_DEVICEN,
-              "PDFCS_DEVICEN value mismatch");
-static_assert(PDFCS_INDEXED == FPDF_COLORSPACE_INDEXED,
-              "PDFCS_INDEXED value mismatch");
-static_assert(PDFCS_PATTERN == FPDF_COLORSPACE_PATTERN,
-              "PDFCS_PATTERN value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kDeviceGray) ==
+                  FPDF_COLORSPACE_DEVICEGRAY,
+              "kDeviceGray value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kDeviceRGB) ==
+                  FPDF_COLORSPACE_DEVICERGB,
+              "kDeviceRGB value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kDeviceCMYK) ==
+                  FPDF_COLORSPACE_DEVICECMYK,
+              "kDeviceCMYK value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kCalGray) ==
+                  FPDF_COLORSPACE_CALGRAY,
+              "kCalGray value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kCalRGB) ==
+                  FPDF_COLORSPACE_CALRGB,
+              "kCalRGB value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kLab) ==
+                  FPDF_COLORSPACE_LAB,
+              "kLab value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kICCBased) ==
+                  FPDF_COLORSPACE_ICCBASED,
+              "kICCBased value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kSeparation) ==
+                  FPDF_COLORSPACE_SEPARATION,
+              "kSeparation value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kDeviceN) ==
+                  FPDF_COLORSPACE_DEVICEN,
+              "kDeviceN value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kIndexed) ==
+                  FPDF_COLORSPACE_INDEXED,
+              "kIndexed value mismatch");
+static_assert(static_cast<int>(CPDF_ColorSpace::Family::kPattern) ==
+                  FPDF_COLORSPACE_PATTERN,
+              "kPattern value mismatch");
 
 RetainPtr<IFX_SeekableReadStream> MakeSeekableReadStream(
     FPDF_FILEACCESS* pFileAccess) {
@@ -388,15 +400,17 @@
     return true;
 
   auto pSource = pdfium::MakeRetain<CPDF_DIB>();
-  CPDF_DIB::LoadState ret = pSource->StartLoadDIBBase(
-      pPage->GetDocument(), pImg->GetStream(), false, nullptr,
-      pPage->GetPageResources(), false, 0, false);
+  CPDF_DIB::LoadState ret =
+      pSource->StartLoadDIBBase(pPage->GetDocument(), pImg->GetStream(), false,
+                                nullptr, pPage->GetPageResources(), false,
+                                CPDF_ColorSpace::Family::kUnknown, false);
   if (ret == CPDF_DIB::LoadState::kFail)
     return true;
 
   metadata->bits_per_pixel = pSource->GetBPP();
-  if (pSource->GetColorSpace())
-    metadata->colorspace = pSource->GetColorSpace()->GetFamily();
-
+  if (pSource->GetColorSpace()) {
+    metadata->colorspace =
+        static_cast<int>(pSource->GetColorSpace()->GetFamily());
+  }
   return true;
 }
diff --git a/fpdfsdk/fpdf_editpage.cpp b/fpdfsdk/fpdf_editpage.cpp
index 5c5774e..b21ebfc 100644
--- a/fpdfsdk/fpdf_editpage.cpp
+++ b/fpdfsdk/fpdf_editpage.cpp
@@ -684,7 +684,7 @@
   std::vector<float> rgb = {R / 255.f, G / 255.f, B / 255.f};
   pPageObj->m_GeneralState.SetFillAlpha(A / 255.f);
   pPageObj->m_ColorState.SetFillColor(
-      CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB), rgb);
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB), rgb);
   pPageObj->SetDirty(true);
   return true;
 }
@@ -741,7 +741,7 @@
   std::vector<float> rgb = {R / 255.f, G / 255.f, B / 255.f};
   pPageObj->m_GeneralState.SetStrokeAlpha(A / 255.f);
   pPageObj->m_ColorState.SetStrokeColor(
-      CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB), rgb);
+      CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB), rgb);
   pPageObj->SetDirty(true);
   return true;
 }
diff --git a/fpdfsdk/fpdf_thumbnail.cpp b/fpdfsdk/fpdf_thumbnail.cpp
index ce16b11..10ca410 100644
--- a/fpdfsdk/fpdf_thumbnail.cpp
+++ b/fpdfsdk/fpdf_thumbnail.cpp
@@ -60,9 +60,10 @@
   const CPDF_Page* p_page = CPDFPageFromFPDFPage(page);
 
   auto p_source = pdfium::MakeRetain<CPDF_DIB>();
-  const CPDF_DIB::LoadState start_status = p_source->StartLoadDIBBase(
-      p_page->GetDocument(), thumb_stream, false, nullptr,
-      p_page->GetPageResources(), false, 0, false);
+  const CPDF_DIB::LoadState start_status =
+      p_source->StartLoadDIBBase(p_page->GetDocument(), thumb_stream, false,
+                                 nullptr, p_page->GetPageResources(), false,
+                                 CPDF_ColorSpace::Family::kUnknown, false);
   if (start_status == CPDF_DIB::LoadState::kFail)
     return nullptr;