diff --git a/fxbarcode/BC_TwoDimWriter.cpp b/fxbarcode/BC_TwoDimWriter.cpp
index 27e2a09..c249a89 100644
--- a/fxbarcode/BC_TwoDimWriter.cpp
+++ b/fxbarcode/BC_TwoDimWriter.cpp
@@ -17,8 +17,7 @@
 #include "fxbarcode/BC_Writer.h"
 #include "fxbarcode/common/BC_CommonBitMatrix.h"
 
-CBC_TwoDimWriter::CBC_TwoDimWriter(bool bFixedSize)
-    : m_bFixedSize(bFixedSize) {}
+CBC_TwoDimWriter::CBC_TwoDimWriter(bool bFixedSize) : fixed_size_(bFixedSize) {}
 
 CBC_TwoDimWriter::~CBC_TwoDimWriter() = default;
 
@@ -28,53 +27,54 @@
   if (code.empty())
     return false;
 
-  m_inputWidth = codeWidth;
-  m_inputHeight = codeHeight;
-  int32_t tempWidth = m_inputWidth + 2;
-  int32_t tempHeight = m_inputHeight + 2;
+  input_width_ = codeWidth;
+  input_height_ = codeHeight;
+  int32_t tempWidth = input_width_ + 2;
+  int32_t tempHeight = input_height_ + 2;
   const float module_size =
-      std::clamp<float>(std::min(m_ModuleWidth, m_ModuleHeight), 1.0f, 8.0f);
+      std::clamp<float>(std::min(module_width_, module_height_), 1.0f, 8.0f);
   FX_SAFE_INT32 scaledWidth = tempWidth;
   FX_SAFE_INT32 scaledHeight = tempHeight;
   scaledWidth *= module_size;
   scaledHeight *= module_size;
-  m_outputWidth = scaledWidth.ValueOrDie();
-  m_outputHeight = scaledHeight.ValueOrDie();
+  output_width_ = scaledWidth.ValueOrDie();
+  output_height_ = scaledHeight.ValueOrDie();
 
-  if (m_bFixedSize) {
-    if (m_Width < m_outputWidth || m_Height < m_outputHeight) {
+  if (fixed_size_) {
+    if (width_ < output_width_ || height_ < output_height_) {
       return false;
     }
   } else {
-    if (m_Width > m_outputWidth || m_Height > m_outputHeight) {
+    if (width_ > output_width_ || height_ > output_height_) {
       int32_t width_factor = static_cast<int32_t>(
-          floor(static_cast<float>(m_Width) / m_outputWidth));
+          floor(static_cast<float>(width_) / output_width_));
       int32_t height_factor = static_cast<int32_t>(
-          floor(static_cast<float>(m_Height) / m_outputHeight));
+          floor(static_cast<float>(height_) / output_height_));
       width_factor = std::max(width_factor, 1);
       height_factor = std::max(height_factor, 1);
 
-      m_outputWidth *= width_factor;
-      m_outputHeight *= height_factor;
+      output_width_ *= width_factor;
+      output_height_ *= height_factor;
     }
   }
-  m_multiX =
-      static_cast<int32_t>(ceil(static_cast<float>(m_outputWidth) / tempWidth));
-  m_multiY = static_cast<int32_t>(
-      ceil(static_cast<float>(m_outputHeight) / tempHeight));
-  if (m_bFixedSize) {
-    m_multiX = std::min(m_multiX, m_multiY);
-    m_multiY = m_multiX;
+  multi_x_ =
+      static_cast<int32_t>(ceil(static_cast<float>(output_width_) / tempWidth));
+  multi_y_ = static_cast<int32_t>(
+      ceil(static_cast<float>(output_height_) / tempHeight));
+  if (fixed_size_) {
+    multi_x_ = std::min(multi_x_, multi_y_);
+    multi_y_ = multi_x_;
   }
 
-  m_leftPadding = std::max((m_Width - m_outputWidth) / 2, 0);
-  m_topPadding = std::max((m_Height - m_outputHeight) / 2, 0);
+  left_padding_ = std::max((width_ - output_width_) / 2, 0);
+  top_padding_ = std::max((height_ - output_height_) / 2, 0);
 
-  m_output = std::make_unique<CBC_CommonBitMatrix>(m_inputWidth, m_inputHeight);
-  for (int32_t y = 0; y < m_inputHeight; ++y) {
-    for (int32_t x = 0; x < m_inputWidth; ++x) {
-      if (code[x + y * m_inputWidth] == 1)
-        m_output->Set(x, y);
+  output_ = std::make_unique<CBC_CommonBitMatrix>(input_width_, input_height_);
+  for (int32_t y = 0; y < input_height_; ++y) {
+    for (int32_t x = 0; x < input_width_; ++x) {
+      if (code[x + y * input_width_] == 1) {
+        output_->Set(x, y);
+      }
     }
   }
   return true;
@@ -82,29 +82,29 @@
 
 void CBC_TwoDimWriter::RenderDeviceResult(CFX_RenderDevice* device,
                                           const CFX_Matrix& matrix) {
-  DCHECK(m_output);
+  DCHECK(output_);
 
   CFX_GraphStateData stateData;
   CFX_Path path;
-  path.AppendRect(0, 0, m_Width, m_Height);
+  path.AppendRect(0, 0, width_, height_);
   device->DrawPath(path, &matrix, &stateData, kBackgroundColor,
                    kBackgroundColor, CFX_FillRenderOptions::EvenOddOptions());
-  int32_t leftPos = m_leftPadding;
-  int32_t topPos = m_topPadding;
+  int32_t leftPos = left_padding_;
+  int32_t topPos = top_padding_;
 
   CFX_Matrix matri = matrix;
-  if (m_Width < m_outputWidth && m_Height < m_outputHeight) {
-    CFX_Matrix matriScale(static_cast<float>(m_Width) / m_outputWidth, 0.0, 0.0,
-                          static_cast<float>(m_Height) / m_outputHeight, 0.0,
+  if (width_ < output_width_ && height_ < output_height_) {
+    CFX_Matrix matriScale(static_cast<float>(width_) / output_width_, 0.0, 0.0,
+                          static_cast<float>(height_) / output_height_, 0.0,
                           0.0);
     matriScale.Concat(matrix);
     matri = matriScale;
   }
 
   CFX_GraphStateData data;
-  for (int32_t x = 0; x < m_inputWidth; x++) {
-    for (int32_t y = 0; y < m_inputHeight; y++) {
-      if (m_output->Get(x, y)) {
+  for (int32_t x = 0; x < input_width_; x++) {
+    for (int32_t y = 0; y < input_height_; y++) {
+      if (output_->Get(x, y)) {
         // In the output, each module is shifted by 1 due to the one module
         // padding added to create quiet areas.
         int start_x_output = x + 1;
@@ -113,10 +113,10 @@
         int end_y_output = y + 2;
 
         CFX_Path rect;
-        rect.AppendRect(leftPos + start_x_output * m_multiX,
-                        topPos + start_y_output * m_multiY,
-                        leftPos + end_x_output * m_multiX,
-                        topPos + end_y_output * m_multiY);
+        rect.AppendRect(leftPos + start_x_output * multi_x_,
+                        topPos + start_y_output * multi_y_,
+                        leftPos + end_x_output * multi_x_,
+                        topPos + end_y_output * multi_y_);
         device->DrawPath(rect, &matri, &data, kBarColor, 0,
                          CFX_FillRenderOptions::WindingOptions());
       }
diff --git a/fxbarcode/BC_TwoDimWriter.h b/fxbarcode/BC_TwoDimWriter.h
index ee479e5..ebf31d5 100644
--- a/fxbarcode/BC_TwoDimWriter.h
+++ b/fxbarcode/BC_TwoDimWriter.h
@@ -26,23 +26,23 @@
                     int32_t codeHeight);
   void RenderDeviceResult(CFX_RenderDevice* device, const CFX_Matrix& matrix);
 
-  int32_t error_correction_level() const { return m_iCorrectionLevel; }
+  int32_t error_correction_level() const { return correction_level_; }
 
  protected:
-  void set_error_correction_level(int32_t level) { m_iCorrectionLevel = level; }
+  void set_error_correction_level(int32_t level) { correction_level_ = level; }
 
  private:
-  std::unique_ptr<CBC_CommonBitMatrix> m_output;
-  int32_t m_multiX;
-  int32_t m_multiY;
-  int32_t m_leftPadding;
-  int32_t m_topPadding;
-  int32_t m_inputWidth;
-  int32_t m_inputHeight;
-  int32_t m_outputWidth;
-  int32_t m_outputHeight;
-  int32_t m_iCorrectionLevel = 1;
-  const bool m_bFixedSize;
+  std::unique_ptr<CBC_CommonBitMatrix> output_;
+  int32_t multi_x_;
+  int32_t multi_y_;
+  int32_t left_padding_;
+  int32_t top_padding_;
+  int32_t input_width_;
+  int32_t input_height_;
+  int32_t output_width_;
+  int32_t output_height_;
+  int32_t correction_level_ = 1;
+  const bool fixed_size_;
 };
 
 #endif  // FXBARCODE_BC_TWODIMWRITER_H_
diff --git a/fxbarcode/BC_Writer.cpp b/fxbarcode/BC_Writer.cpp
index ed53989..3198da6 100644
--- a/fxbarcode/BC_Writer.cpp
+++ b/fxbarcode/BC_Writer.cpp
@@ -14,7 +14,7 @@
   if (moduleHeight > 10 || moduleHeight < 1)
     return false;
 
-  m_ModuleHeight = moduleHeight;
+  module_height_ = moduleHeight;
   return true;
 }
 
@@ -22,16 +22,16 @@
   if (moduleWidth > 10 || moduleWidth < 1)
     return false;
 
-  m_ModuleWidth = moduleWidth;
+  module_width_ = moduleWidth;
   return true;
 }
 
 void CBC_Writer::SetHeight(int32_t height) {
-  m_Height = height;
+  height_ = height;
 }
 
 void CBC_Writer::SetWidth(int32_t width) {
-  m_Width = width;
+  width_ = width;
 }
 
 void CBC_Writer::SetTextLocation(BC_TEXT_LOC location) {}
diff --git a/fxbarcode/BC_Writer.h b/fxbarcode/BC_Writer.h
index a951dbb..d5c5746 100644
--- a/fxbarcode/BC_Writer.h
+++ b/fxbarcode/BC_Writer.h
@@ -30,10 +30,10 @@
   static const FX_ARGB kBarColor = 0xff000000;
   static const FX_ARGB kBackgroundColor = 0xffffffff;
 
-  int32_t m_ModuleHeight = 1;
-  int32_t m_ModuleWidth = 1;
-  int32_t m_Height = 320;
-  int32_t m_Width = 640;
+  int32_t module_height_ = 1;
+  int32_t module_width_ = 1;
+  int32_t height_ = 320;
+  int32_t width_ = 640;
 };
 
 #endif  // FXBARCODE_BC_WRITER_H_
diff --git a/fxbarcode/cbc_codabar.cpp b/fxbarcode/cbc_codabar.cpp
index cb4b875..214a233 100644
--- a/fxbarcode/cbc_codabar.cpp
+++ b/fxbarcode/cbc_codabar.cpp
@@ -36,9 +36,9 @@
   if (!pWriter->CheckContentValidity(contents))
     return false;
 
-  m_renderContents = pWriter->FilterContents(contents);
-  ByteString byteString = m_renderContents.ToUTF8();
-  return pWriter->RenderResult(m_renderContents.AsStringView(),
+  render_contents_ = pWriter->FilterContents(contents);
+  ByteString byteString = render_contents_.ToUTF8();
+  return pWriter->RenderResult(render_contents_.AsStringView(),
                                pWriter->Encode(byteString));
 }
 
@@ -46,7 +46,7 @@
                                const CFX_Matrix& matrix) {
   auto* pWriter = GetOnedCodaBarWriter();
   WideString renderCon =
-      pWriter->encodedContents(m_renderContents.AsStringView());
+      pWriter->encodedContents(render_contents_.AsStringView());
   return pWriter->RenderDeviceResult(device, matrix, renderCon.AsStringView());
 }
 
@@ -55,5 +55,5 @@
 }
 
 CBC_OnedCodaBarWriter* CBC_Codabar::GetOnedCodaBarWriter() {
-  return static_cast<CBC_OnedCodaBarWriter*>(m_pBCWriter.get());
+  return static_cast<CBC_OnedCodaBarWriter*>(bc_writer_.get());
 }
diff --git a/fxbarcode/cbc_codabar.h b/fxbarcode/cbc_codabar.h
index 7b74486..60d200c 100644
--- a/fxbarcode/cbc_codabar.h
+++ b/fxbarcode/cbc_codabar.h
@@ -28,7 +28,7 @@
  private:
   CBC_OnedCodaBarWriter* GetOnedCodaBarWriter();
 
-  WideString m_renderContents;
+  WideString render_contents_;
 };
 
 #endif  // FXBARCODE_CBC_CODABAR_H_
diff --git a/fxbarcode/cbc_code128.cpp b/fxbarcode/cbc_code128.cpp
index 8b2b65d..240b644 100644
--- a/fxbarcode/cbc_code128.cpp
+++ b/fxbarcode/cbc_code128.cpp
@@ -40,16 +40,16 @@
   if (contents.GetLength() % 2 && pWriter->GetType() == BC_TYPE::kCode128C)
     content += '0';
 
-  m_renderContents = pWriter->FilterContents(content.AsStringView());
-  ByteString byteString = m_renderContents.ToUTF8();
-  return pWriter->RenderResult(m_renderContents.AsStringView(),
+  render_contents_ = pWriter->FilterContents(content.AsStringView());
+  ByteString byteString = render_contents_.ToUTF8();
+  return pWriter->RenderResult(render_contents_.AsStringView(),
                                pWriter->Encode(byteString));
 }
 
 bool CBC_Code128::RenderDevice(CFX_RenderDevice* device,
                                const CFX_Matrix& matrix) {
   return GetOnedCode128Writer()->RenderDeviceResult(
-      device, matrix, m_renderContents.AsStringView());
+      device, matrix, render_contents_.AsStringView());
 }
 
 BC_TYPE CBC_Code128::GetType() {
@@ -57,5 +57,5 @@
 }
 
 CBC_OnedCode128Writer* CBC_Code128::GetOnedCode128Writer() {
-  return static_cast<CBC_OnedCode128Writer*>(m_pBCWriter.get());
+  return static_cast<CBC_OnedCode128Writer*>(bc_writer_.get());
 }
diff --git a/fxbarcode/cbc_code128.h b/fxbarcode/cbc_code128.h
index 81710c8..a11e829 100644
--- a/fxbarcode/cbc_code128.h
+++ b/fxbarcode/cbc_code128.h
@@ -28,7 +28,7 @@
  private:
   CBC_OnedCode128Writer* GetOnedCode128Writer();
 
-  WideString m_renderContents;
+  WideString render_contents_;
 };
 
 #endif  // FXBARCODE_CBC_CODE128_H_
diff --git a/fxbarcode/cbc_code39.cpp b/fxbarcode/cbc_code39.cpp
index 229048e..28e3903 100644
--- a/fxbarcode/cbc_code39.cpp
+++ b/fxbarcode/cbc_code39.cpp
@@ -37,9 +37,9 @@
     return false;
 
   WideString filtercontents = pWriter->FilterContents(contents);
-  m_renderContents = pWriter->RenderTextContents(contents);
+  render_contents_ = pWriter->RenderTextContents(contents);
   ByteString byteString = filtercontents.ToUTF8();
-  return pWriter->RenderResult(m_renderContents.AsStringView(),
+  return pWriter->RenderResult(render_contents_.AsStringView(),
                                pWriter->Encode(byteString));
 }
 
@@ -47,8 +47,9 @@
                               const CFX_Matrix& matrix) {
   auto* pWriter = GetOnedCode39Writer();
   WideString renderCon;
-  if (!pWriter->encodedContents(m_renderContents.AsStringView(), &renderCon))
+  if (!pWriter->encodedContents(render_contents_.AsStringView(), &renderCon)) {
     return false;
+  }
   return pWriter->RenderDeviceResult(device, matrix, renderCon.AsStringView());
 }
 
@@ -57,5 +58,5 @@
 }
 
 CBC_OnedCode39Writer* CBC_Code39::GetOnedCode39Writer() {
-  return static_cast<CBC_OnedCode39Writer*>(m_pBCWriter.get());
+  return static_cast<CBC_OnedCode39Writer*>(bc_writer_.get());
 }
diff --git a/fxbarcode/cbc_code39.h b/fxbarcode/cbc_code39.h
index 0767bd7..39433bf 100644
--- a/fxbarcode/cbc_code39.h
+++ b/fxbarcode/cbc_code39.h
@@ -29,7 +29,7 @@
  private:
   CBC_OnedCode39Writer* GetOnedCode39Writer();
 
-  WideString m_renderContents;
+  WideString render_contents_;
 };
 
 #endif  // FXBARCODE_CBC_CODE39_H_
diff --git a/fxbarcode/cbc_codebase.cpp b/fxbarcode/cbc_codebase.cpp
index 865531d..de1b44a 100644
--- a/fxbarcode/cbc_codebase.cpp
+++ b/fxbarcode/cbc_codebase.cpp
@@ -26,42 +26,42 @@
 #include "fxbarcode/BC_Writer.h"
 
 CBC_CodeBase::CBC_CodeBase(std::unique_ptr<CBC_Writer> pWriter)
-    : m_pBCWriter(std::move(pWriter)) {}
+    : bc_writer_(std::move(pWriter)) {}
 
 CBC_CodeBase::~CBC_CodeBase() = default;
 
 void CBC_CodeBase::SetTextLocation(BC_TEXT_LOC location) {
-  m_pBCWriter->SetTextLocation(location);
+  bc_writer_->SetTextLocation(location);
 }
 
 bool CBC_CodeBase::SetWideNarrowRatio(int8_t ratio) {
-  return m_pBCWriter->SetWideNarrowRatio(ratio);
+  return bc_writer_->SetWideNarrowRatio(ratio);
 }
 
 bool CBC_CodeBase::SetStartChar(char start) {
-  return m_pBCWriter->SetStartChar(start);
+  return bc_writer_->SetStartChar(start);
 }
 
 bool CBC_CodeBase::SetEndChar(char end) {
-  return m_pBCWriter->SetEndChar(end);
+  return bc_writer_->SetEndChar(end);
 }
 
 bool CBC_CodeBase::SetErrorCorrectionLevel(int32_t level) {
-  return m_pBCWriter->SetErrorCorrectionLevel(level);
+  return bc_writer_->SetErrorCorrectionLevel(level);
 }
 
 bool CBC_CodeBase::SetModuleHeight(int32_t moduleHeight) {
-  return m_pBCWriter->SetModuleHeight(moduleHeight);
+  return bc_writer_->SetModuleHeight(moduleHeight);
 }
 
 bool CBC_CodeBase::SetModuleWidth(int32_t moduleWidth) {
-  return m_pBCWriter->SetModuleWidth(moduleWidth);
+  return bc_writer_->SetModuleWidth(moduleWidth);
 }
 
 void CBC_CodeBase::SetHeight(int32_t height) {
-  return m_pBCWriter->SetHeight(height);
+  return bc_writer_->SetHeight(height);
 }
 
 void CBC_CodeBase::SetWidth(int32_t width) {
-  return m_pBCWriter->SetWidth(width);
+  return bc_writer_->SetWidth(width);
 }
diff --git a/fxbarcode/cbc_codebase.h b/fxbarcode/cbc_codebase.h
index 363cdf8..76f4c22 100644
--- a/fxbarcode/cbc_codebase.h
+++ b/fxbarcode/cbc_codebase.h
@@ -40,7 +40,7 @@
   void SetWidth(int32_t width);
 
  protected:
-  std::unique_ptr<CBC_Writer> m_pBCWriter;
+  std::unique_ptr<CBC_Writer> bc_writer_;
 };
 
 #endif  // FXBARCODE_CBC_CODEBASE_H_
diff --git a/fxbarcode/cbc_datamatrix.cpp b/fxbarcode/cbc_datamatrix.cpp
index e9a747b..1fee0de 100644
--- a/fxbarcode/cbc_datamatrix.cpp
+++ b/fxbarcode/cbc_datamatrix.cpp
@@ -54,5 +54,5 @@
 }
 
 CBC_DataMatrixWriter* CBC_DataMatrix::GetDataMatrixWriter() {
-  return static_cast<CBC_DataMatrixWriter*>(m_pBCWriter.get());
+  return static_cast<CBC_DataMatrixWriter*>(bc_writer_.get());
 }
diff --git a/fxbarcode/cbc_eancode.cpp b/fxbarcode/cbc_eancode.cpp
index 261b753..f2261b1 100644
--- a/fxbarcode/cbc_eancode.cpp
+++ b/fxbarcode/cbc_eancode.cpp
@@ -17,7 +17,7 @@
 CBC_EANCode::~CBC_EANCode() = default;
 
 CBC_OneDimEANWriter* CBC_EANCode::GetOneDimEANWriter() {
-  return static_cast<CBC_OneDimEANWriter*>(m_pBCWriter.get());
+  return static_cast<CBC_OneDimEANWriter*>(bc_writer_.get());
 }
 
 bool CBC_EANCode::Encode(WideStringView contents) {
@@ -25,17 +25,17 @@
   if (!pWriter->CheckContentValidity(contents))
     return false;
 
-  m_renderContents = Preprocess(contents);
-  ByteString str = m_renderContents.ToUTF8();
+  render_contents_ = Preprocess(contents);
+  ByteString str = render_contents_.ToUTF8();
   pWriter->InitEANWriter();
-  return pWriter->RenderResult(m_renderContents.AsStringView(),
+  return pWriter->RenderResult(render_contents_.AsStringView(),
                                pWriter->Encode(str));
 }
 
 bool CBC_EANCode::RenderDevice(CFX_RenderDevice* device,
                                const CFX_Matrix& matrix) {
   return GetOneDimEANWriter()->RenderDeviceResult(
-      device, matrix, m_renderContents.AsStringView());
+      device, matrix, render_contents_.AsStringView());
 }
 
 WideString CBC_EANCode::Preprocess(WideStringView contents) {
diff --git a/fxbarcode/cbc_eancode.h b/fxbarcode/cbc_eancode.h
index 1a29546..fe30445 100644
--- a/fxbarcode/cbc_eancode.h
+++ b/fxbarcode/cbc_eancode.h
@@ -30,7 +30,7 @@
   CBC_OneDimEANWriter* GetOneDimEANWriter();
   WideString Preprocess(WideStringView contents);
 
-  WideString m_renderContents;
+  WideString render_contents_;
 };
 
 #endif  // FXBARCODE_CBC_EANCODE_H_
diff --git a/fxbarcode/cbc_onecode.cpp b/fxbarcode/cbc_onecode.cpp
index 220e36c..f5e5ef0 100644
--- a/fxbarcode/cbc_onecode.cpp
+++ b/fxbarcode/cbc_onecode.cpp
@@ -59,5 +59,5 @@
 }
 
 CBC_OneDimWriter* CBC_OneCode::GetOneDimWriter() {
-  return static_cast<CBC_OneDimWriter*>(m_pBCWriter.get());
+  return static_cast<CBC_OneDimWriter*>(bc_writer_.get());
 }
diff --git a/fxbarcode/cbc_pdf417i.cpp b/fxbarcode/cbc_pdf417i.cpp
index 54a7f42..fc5a586 100644
--- a/fxbarcode/cbc_pdf417i.cpp
+++ b/fxbarcode/cbc_pdf417i.cpp
@@ -61,5 +61,5 @@
 }
 
 CBC_PDF417Writer* CBC_PDF417I::GetPDF417Writer() {
-  return static_cast<CBC_PDF417Writer*>(m_pBCWriter.get());
+  return static_cast<CBC_PDF417Writer*>(bc_writer_.get());
 }
diff --git a/fxbarcode/cbc_qrcode.cpp b/fxbarcode/cbc_qrcode.cpp
index 841cf9e..a3cc64b 100644
--- a/fxbarcode/cbc_qrcode.cpp
+++ b/fxbarcode/cbc_qrcode.cpp
@@ -52,5 +52,5 @@
 }
 
 CBC_QRCodeWriter* CBC_QRCode::GetQRCodeWriter() {
-  return static_cast<CBC_QRCodeWriter*>(m_pBCWriter.get());
+  return static_cast<CBC_QRCodeWriter*>(bc_writer_.get());
 }
diff --git a/fxbarcode/cfx_barcode.cpp b/fxbarcode/cfx_barcode.cpp
index bf40685..2a1a350 100644
--- a/fxbarcode/cfx_barcode.cpp
+++ b/fxbarcode/cfx_barcode.cpp
@@ -61,35 +61,38 @@
 
 std::unique_ptr<CFX_Barcode> CFX_Barcode::Create(BC_TYPE type) {
   auto barcode = pdfium::WrapUnique(new CFX_Barcode());  // Private ctor.
-  barcode->m_pBCEngine = CreateBarCodeEngineObject(type);
+  barcode->bc_engine_ = CreateBarCodeEngineObject(type);
   return barcode;
 }
 
 BC_TYPE CFX_Barcode::GetType() {
-  return m_pBCEngine ? m_pBCEngine->GetType() : BC_TYPE::kUnknown;
+  return bc_engine_ ? bc_engine_->GetType() : BC_TYPE::kUnknown;
 }
 
 bool CFX_Barcode::SetModuleHeight(int32_t moduleHeight) {
-  return m_pBCEngine && m_pBCEngine->SetModuleHeight(moduleHeight);
+  return bc_engine_ && bc_engine_->SetModuleHeight(moduleHeight);
 }
 
 bool CFX_Barcode::SetModuleWidth(int32_t moduleWidth) {
-  return m_pBCEngine && m_pBCEngine->SetModuleWidth(moduleWidth);
+  return bc_engine_ && bc_engine_->SetModuleWidth(moduleWidth);
 }
 
 void CFX_Barcode::SetHeight(int32_t height) {
-  if (m_pBCEngine)
-    m_pBCEngine->SetHeight(height);
+  if (bc_engine_) {
+    bc_engine_->SetHeight(height);
+  }
 }
 
 void CFX_Barcode::SetWidth(int32_t width) {
-  if (m_pBCEngine)
-    m_pBCEngine->SetWidth(width);
+  if (bc_engine_) {
+    bc_engine_->SetWidth(width);
+  }
 }
 
 bool CFX_Barcode::SetPrintChecksum(bool checksum) {
-  if (!m_pBCEngine)
+  if (!bc_engine_) {
     return false;
+  }
 
   switch (GetType()) {
     case BC_TYPE::kCode39:
@@ -100,7 +103,7 @@
     case BC_TYPE::kEAN8:
     case BC_TYPE::kEAN13:
     case BC_TYPE::kUPCA:
-      static_cast<CBC_OneCode*>(m_pBCEngine.get())->SetPrintChecksum(checksum);
+      static_cast<CBC_OneCode*>(bc_engine_.get())->SetPrintChecksum(checksum);
       return true;
     default:
       return false;
@@ -108,8 +111,9 @@
 }
 
 bool CFX_Barcode::SetDataLength(int32_t length) {
-  if (!m_pBCEngine)
+  if (!bc_engine_) {
     return false;
+  }
 
   switch (GetType()) {
     case BC_TYPE::kCode39:
@@ -120,7 +124,7 @@
     case BC_TYPE::kEAN8:
     case BC_TYPE::kEAN13:
     case BC_TYPE::kUPCA:
-      static_cast<CBC_OneCode*>(m_pBCEngine.get())->SetDataLength(length);
+      static_cast<CBC_OneCode*>(bc_engine_.get())->SetDataLength(length);
       return true;
     default:
       return false;
@@ -128,8 +132,9 @@
 }
 
 bool CFX_Barcode::SetCalChecksum(bool state) {
-  if (!m_pBCEngine)
+  if (!bc_engine_) {
     return false;
+  }
 
   switch (GetType()) {
     case BC_TYPE::kCode39:
@@ -140,7 +145,7 @@
     case BC_TYPE::kEAN8:
     case BC_TYPE::kEAN13:
     case BC_TYPE::kUPCA:
-      static_cast<CBC_OneCode*>(m_pBCEngine.get())->SetCalChecksum(state);
+      static_cast<CBC_OneCode*>(bc_engine_.get())->SetCalChecksum(state);
       return true;
     default:
       return false;
@@ -148,8 +153,9 @@
 }
 
 bool CFX_Barcode::SetFont(CFX_Font* pFont) {
-  if (!m_pBCEngine)
+  if (!bc_engine_) {
     return false;
+  }
 
   switch (GetType()) {
     case BC_TYPE::kCode39:
@@ -160,15 +166,16 @@
     case BC_TYPE::kEAN8:
     case BC_TYPE::kEAN13:
     case BC_TYPE::kUPCA:
-      return static_cast<CBC_OneCode*>(m_pBCEngine.get())->SetFont(pFont);
+      return static_cast<CBC_OneCode*>(bc_engine_.get())->SetFont(pFont);
     default:
       return false;
   }
 }
 
 bool CFX_Barcode::SetFontSize(float size) {
-  if (!m_pBCEngine)
+  if (!bc_engine_) {
     return false;
+  }
 
   switch (GetType()) {
     case BC_TYPE::kCode39:
@@ -179,7 +186,7 @@
     case BC_TYPE::kEAN8:
     case BC_TYPE::kEAN13:
     case BC_TYPE::kUPCA:
-      static_cast<CBC_OneCode*>(m_pBCEngine.get())->SetFontSize(size);
+      static_cast<CBC_OneCode*>(bc_engine_.get())->SetFontSize(size);
       return true;
     default:
       return false;
@@ -187,8 +194,9 @@
 }
 
 bool CFX_Barcode::SetFontColor(FX_ARGB color) {
-  if (!m_pBCEngine)
+  if (!bc_engine_) {
     return false;
+  }
 
   switch (GetType()) {
     case BC_TYPE::kCode39:
@@ -199,7 +207,7 @@
     case BC_TYPE::kEAN8:
     case BC_TYPE::kEAN13:
     case BC_TYPE::kUPCA:
-      static_cast<CBC_OneCode*>(m_pBCEngine.get())->SetFontColor(color);
+      static_cast<CBC_OneCode*>(bc_engine_.get())->SetFontColor(color);
       return true;
     default:
       return false;
@@ -207,31 +215,32 @@
 }
 
 void CFX_Barcode::SetTextLocation(BC_TEXT_LOC location) {
-  if (m_pBCEngine)
-    m_pBCEngine->SetTextLocation(location);
+  if (bc_engine_) {
+    bc_engine_->SetTextLocation(location);
+  }
 }
 
 bool CFX_Barcode::SetWideNarrowRatio(int8_t ratio) {
-  return m_pBCEngine && m_pBCEngine->SetWideNarrowRatio(ratio);
+  return bc_engine_ && bc_engine_->SetWideNarrowRatio(ratio);
 }
 
 bool CFX_Barcode::SetStartChar(char start) {
-  return m_pBCEngine && m_pBCEngine->SetStartChar(start);
+  return bc_engine_ && bc_engine_->SetStartChar(start);
 }
 
 bool CFX_Barcode::SetEndChar(char end) {
-  return m_pBCEngine && m_pBCEngine->SetEndChar(end);
+  return bc_engine_ && bc_engine_->SetEndChar(end);
 }
 
 bool CFX_Barcode::SetErrorCorrectionLevel(int32_t level) {
-  return m_pBCEngine && m_pBCEngine->SetErrorCorrectionLevel(level);
+  return bc_engine_ && bc_engine_->SetErrorCorrectionLevel(level);
 }
 
 bool CFX_Barcode::Encode(WideStringView contents) {
-  return m_pBCEngine && m_pBCEngine->Encode(contents);
+  return bc_engine_ && bc_engine_->Encode(contents);
 }
 
 bool CFX_Barcode::RenderDevice(CFX_RenderDevice* device,
                                const CFX_Matrix& matrix) {
-  return m_pBCEngine && m_pBCEngine->RenderDevice(device, matrix);
+  return bc_engine_ && bc_engine_->RenderDevice(device, matrix);
 }
diff --git a/fxbarcode/cfx_barcode.h b/fxbarcode/cfx_barcode.h
index 7f2cbae..3163cc6 100644
--- a/fxbarcode/cfx_barcode.h
+++ b/fxbarcode/cfx_barcode.h
@@ -52,7 +52,7 @@
  private:
   CFX_Barcode();
 
-  std::unique_ptr<CBC_CodeBase> m_pBCEngine;
+  std::unique_ptr<CBC_CodeBase> bc_engine_;
 };
 
 #endif  // FXBARCODE_CFX_BARCODE_H_
diff --git a/fxbarcode/common/BC_CommonBitMatrix.cpp b/fxbarcode/common/BC_CommonBitMatrix.cpp
index fab5055..c4c9013 100644
--- a/fxbarcode/common/BC_CommonBitMatrix.cpp
+++ b/fxbarcode/common/BC_CommonBitMatrix.cpp
@@ -26,20 +26,20 @@
 #include "core/fxcrt/fixed_size_data_vector.h"
 
 CBC_CommonBitMatrix::CBC_CommonBitMatrix(size_t width, size_t height)
-    : m_height(height), m_rowSize((width + 31) >> 5) {
+    : height_(height), row_size_((width + 31) >> 5) {
   static constexpr int32_t kMaxBits = 1024 * 1024 * 1024;  // 1 Gb.
-  CHECK_LT(m_rowSize, kMaxBits / m_height);
-  m_bits = FixedSizeDataVector<uint32_t>::Zeroed(m_rowSize * m_height);
+  CHECK_LT(row_size_, kMaxBits / height_);
+  bits_ = FixedSizeDataVector<uint32_t>::Zeroed(row_size_ * height_);
 }
 
 CBC_CommonBitMatrix::~CBC_CommonBitMatrix() = default;
 
 bool CBC_CommonBitMatrix::Get(size_t x, size_t y) const {
-  size_t offset = y * m_rowSize + (x >> 5);
-  return ((m_bits.span()[offset] >> (x & 0x1f)) & 1) != 0;
+  size_t offset = y * row_size_ + (x >> 5);
+  return ((bits_.span()[offset] >> (x & 0x1f)) & 1) != 0;
 }
 
 void CBC_CommonBitMatrix::Set(size_t x, size_t y) {
-  size_t offset = y * m_rowSize + (x >> 5);
-  m_bits.span()[offset] |= 1u << (x & 0x1f);
+  size_t offset = y * row_size_ + (x >> 5);
+  bits_.span()[offset] |= 1u << (x & 0x1f);
 }
diff --git a/fxbarcode/common/BC_CommonBitMatrix.h b/fxbarcode/common/BC_CommonBitMatrix.h
index 8ce7380..9569370 100644
--- a/fxbarcode/common/BC_CommonBitMatrix.h
+++ b/fxbarcode/common/BC_CommonBitMatrix.h
@@ -21,9 +21,9 @@
   void Set(size_t x, size_t y);
 
  private:
-  const size_t m_height;
-  const size_t m_rowSize;
-  FixedSizeDataVector<uint32_t> m_bits;
+  const size_t height_;
+  const size_t row_size_;
+  FixedSizeDataVector<uint32_t> bits_;
 };
 
 #endif  // FXBARCODE_COMMON_BC_COMMONBITMATRIX_H_
diff --git a/fxbarcode/common/BC_CommonByteMatrix.cpp b/fxbarcode/common/BC_CommonByteMatrix.cpp
index e94f8bf..972ca2b 100644
--- a/fxbarcode/common/BC_CommonByteMatrix.cpp
+++ b/fxbarcode/common/BC_CommonByteMatrix.cpp
@@ -29,31 +29,31 @@
 #include "core/fxcrt/data_vector.h"
 
 CBC_CommonByteMatrix::CBC_CommonByteMatrix(size_t width, size_t height)
-    : m_width(width), m_height(height) {
+    : width_(width), height_(height) {
   static constexpr size_t kMaxBytes = 256 * 1024 * 1024;  // 256 MB.
   static constexpr uint8_t kDefaultFill = 0xff;
-  CHECK_LT(m_width, kMaxBytes / m_height);
-  m_bytes.resize(m_width * m_height, kDefaultFill);
+  CHECK_LT(width_, kMaxBytes / height_);
+  bytes_.resize(width_ * height_, kDefaultFill);
 }
 
 CBC_CommonByteMatrix::~CBC_CommonByteMatrix() = default;
 
 DataVector<uint8_t> CBC_CommonByteMatrix::TakeArray() {
-  return std::move(m_bytes);
+  return std::move(bytes_);
 }
 
 uint8_t CBC_CommonByteMatrix::Get(size_t x, size_t y) const {
-  const size_t offset = y * m_width + x;
-  CHECK_LT(offset, m_bytes.size());
-  return m_bytes[offset];
+  const size_t offset = y * width_ + x;
+  CHECK_LT(offset, bytes_.size());
+  return bytes_[offset];
 }
 
 void CBC_CommonByteMatrix::Set(size_t x, size_t y, uint8_t value) {
-  const size_t offset = y * m_width + x;
-  CHECK_LT(offset, m_bytes.size());
-  m_bytes[offset] = value;
+  const size_t offset = y * width_ + x;
+  CHECK_LT(offset, bytes_.size());
+  bytes_[offset] = value;
 }
 
 void CBC_CommonByteMatrix::Fill(uint8_t value) {
-  std::fill(std::begin(m_bytes), std::end(m_bytes), value);
+  std::fill(std::begin(bytes_), std::end(bytes_), value);
 }
diff --git a/fxbarcode/common/BC_CommonByteMatrix.h b/fxbarcode/common/BC_CommonByteMatrix.h
index 54fb251..b9af42c 100644
--- a/fxbarcode/common/BC_CommonByteMatrix.h
+++ b/fxbarcode/common/BC_CommonByteMatrix.h
@@ -17,9 +17,9 @@
   CBC_CommonByteMatrix(size_t width, size_t height);
   ~CBC_CommonByteMatrix();
 
-  size_t GetWidth() const { return m_width; }
-  size_t GetHeight() const { return m_height; }
-  pdfium::span<const uint8_t> GetArray() const { return m_bytes; }
+  size_t GetWidth() const { return width_; }
+  size_t GetHeight() const { return height_; }
+  pdfium::span<const uint8_t> GetArray() const { return bytes_; }
   DataVector<uint8_t> TakeArray();
 
   uint8_t Get(size_t x, size_t y) const;
@@ -27,9 +27,9 @@
   void Fill(uint8_t value);
 
  private:
-  const size_t m_width;
-  const size_t m_height;
-  DataVector<uint8_t> m_bytes;
+  const size_t width_;
+  const size_t height_;
+  DataVector<uint8_t> bytes_;
 };
 
 #endif  // FXBARCODE_COMMON_BC_COMMONBYTEMATRIX_H_
diff --git a/fxbarcode/common/reedsolomon/BC_ReedSolomon.cpp b/fxbarcode/common/reedsolomon/BC_ReedSolomon.cpp
index c1785f2..401e454 100644
--- a/fxbarcode/common/reedsolomon/BC_ReedSolomon.cpp
+++ b/fxbarcode/common/reedsolomon/BC_ReedSolomon.cpp
@@ -29,28 +29,28 @@
 #include "fxbarcode/common/reedsolomon/BC_ReedSolomonGF256Poly.h"
 
 CBC_ReedSolomonEncoder::CBC_ReedSolomonEncoder(CBC_ReedSolomonGF256* field)
-    : m_field(field) {
-  m_cachedGenerators.push_back(std::make_unique<CBC_ReedSolomonGF256Poly>(
-      m_field, std::vector<int32_t>{1}));
+    : field_(field) {
+  cached_generators_.push_back(std::make_unique<CBC_ReedSolomonGF256Poly>(
+      field_, std::vector<int32_t>{1}));
 }
 
 CBC_ReedSolomonEncoder::~CBC_ReedSolomonEncoder() = default;
 
 CBC_ReedSolomonGF256Poly* CBC_ReedSolomonEncoder::BuildGenerator(
     size_t degree) {
-  if (degree >= m_cachedGenerators.size()) {
-    CBC_ReedSolomonGF256Poly* lastGenerator = m_cachedGenerators.back().get();
-    for (size_t d = m_cachedGenerators.size(); d <= degree; ++d) {
-      CBC_ReedSolomonGF256Poly temp_poly(m_field, {1, m_field->Exp(d - 1)});
+  if (degree >= cached_generators_.size()) {
+    CBC_ReedSolomonGF256Poly* lastGenerator = cached_generators_.back().get();
+    for (size_t d = cached_generators_.size(); d <= degree; ++d) {
+      CBC_ReedSolomonGF256Poly temp_poly(field_, {1, field_->Exp(d - 1)});
       auto nextGenerator = lastGenerator->Multiply(&temp_poly);
       if (!nextGenerator)
         return nullptr;
 
       lastGenerator = nextGenerator.get();
-      m_cachedGenerators.push_back(std::move(nextGenerator));
+      cached_generators_.push_back(std::move(nextGenerator));
     }
   }
-  return m_cachedGenerators[degree].get();
+  return cached_generators_[degree].get();
 }
 
 bool CBC_ReedSolomonEncoder::Encode(std::vector<int32_t>* toEncode,
@@ -70,7 +70,7 @@
   for (size_t x = 0; x < dataBytes; x++)
     infoCoefficients[x] = (*toEncode)[x];
 
-  CBC_ReedSolomonGF256Poly info(m_field, infoCoefficients);
+  CBC_ReedSolomonGF256Poly info(field_, infoCoefficients);
   auto infoTemp = info.MultiplyByMonomial(ecBytes, 1);
   if (!infoTemp)
     return false;
diff --git a/fxbarcode/common/reedsolomon/BC_ReedSolomon.h b/fxbarcode/common/reedsolomon/BC_ReedSolomon.h
index fd8954a..dab5224 100644
--- a/fxbarcode/common/reedsolomon/BC_ReedSolomon.h
+++ b/fxbarcode/common/reedsolomon/BC_ReedSolomon.h
@@ -25,8 +25,8 @@
  private:
   CBC_ReedSolomonGF256Poly* BuildGenerator(size_t degree);
 
-  UnownedPtr<CBC_ReedSolomonGF256> const m_field;
-  std::vector<std::unique_ptr<CBC_ReedSolomonGF256Poly>> m_cachedGenerators;
+  UnownedPtr<CBC_ReedSolomonGF256> const field_;
+  std::vector<std::unique_ptr<CBC_ReedSolomonGF256Poly>> cached_generators_;
 };
 
 #endif  // FXBARCODE_COMMON_REEDSOLOMON_BC_REEDSOLOMON_H_
diff --git a/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256.cpp b/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256.cpp
index 75898fe..311a026 100644
--- a/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256.cpp
+++ b/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256.cpp
@@ -29,22 +29,22 @@
 CBC_ReedSolomonGF256::CBC_ReedSolomonGF256(int32_t primitive) {
   int32_t x = 1;
   for (int32_t j = 0; j < 256; j++) {
-    m_expTable[j] = x;
+    exp_table_[j] = x;
     x <<= 1;
     if (x >= 0x100) {
       x ^= primitive;
     }
   }
   for (int32_t i = 0; i < 255; i++) {
-    m_logTable[m_expTable[i]] = i;
+    log_table_[exp_table_[i]] = i;
   }
-  m_logTable[0] = 0;
+  log_table_[0] = 0;
 }
 
 void CBC_ReedSolomonGF256::Init() {
-  m_zero =
+  zero_ =
       std::make_unique<CBC_ReedSolomonGF256Poly>(this, std::vector<int32_t>{0});
-  m_one =
+  one_ =
       std::make_unique<CBC_ReedSolomonGF256Poly>(this, std::vector<int32_t>{1});
 }
 
@@ -57,7 +57,7 @@
     return nullptr;
 
   if (coefficient == 0)
-    return m_zero->Clone();
+    return zero_->Clone();
 
   std::vector<int32_t> coefficients(degree + 1);
   coefficients[0] = coefficient;
@@ -70,13 +70,13 @@
 }
 
 int32_t CBC_ReedSolomonGF256::Exp(int32_t a) {
-  return m_expTable[a];
+  return exp_table_[a];
 }
 
 std::optional<int32_t> CBC_ReedSolomonGF256::Inverse(int32_t a) {
   if (a == 0)
     return std::nullopt;
-  return m_expTable[255 - m_logTable[a]];
+  return exp_table_[255 - log_table_[a]];
 }
 
 int32_t CBC_ReedSolomonGF256::Multiply(int32_t a, int32_t b) {
@@ -89,5 +89,5 @@
   if (b == 1) {
     return a;
   }
-  return m_expTable[(m_logTable[a] + m_logTable[b]) % 255];
+  return exp_table_[(log_table_[a] + log_table_[b]) % 255];
 }
diff --git a/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256.h b/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256.h
index 6327227..0721d3b 100644
--- a/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256.h
+++ b/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256.h
@@ -20,8 +20,8 @@
   explicit CBC_ReedSolomonGF256(int32_t primitive);
   ~CBC_ReedSolomonGF256();
 
-  CBC_ReedSolomonGF256Poly* GetZero() const { return m_zero.get(); }
-  CBC_ReedSolomonGF256Poly* GetOne() const { return m_one.get(); }
+  CBC_ReedSolomonGF256Poly* GetZero() const { return zero_.get(); }
+  CBC_ReedSolomonGF256Poly* GetOne() const { return one_.get(); }
 
   std::unique_ptr<CBC_ReedSolomonGF256Poly> BuildMonomial(int32_t degree,
                                                           int32_t coefficient);
@@ -32,10 +32,10 @@
   void Init();
 
  private:
-  std::unique_ptr<CBC_ReedSolomonGF256Poly> m_zero;
-  std::unique_ptr<CBC_ReedSolomonGF256Poly> m_one;
-  std::array<int32_t, 256> m_expTable;
-  std::array<int32_t, 256> m_logTable;
+  std::unique_ptr<CBC_ReedSolomonGF256Poly> zero_;
+  std::unique_ptr<CBC_ReedSolomonGF256Poly> one_;
+  std::array<int32_t, 256> exp_table_;
+  std::array<int32_t, 256> log_table_;
 };
 
 #endif  // FXBARCODE_COMMON_REEDSOLOMON_BC_REEDSOLOMONGF256_H_
diff --git a/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256Poly.cpp b/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256Poly.cpp
index e2ae556..082cbfe 100644
--- a/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256Poly.cpp
+++ b/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256Poly.cpp
@@ -33,11 +33,11 @@
 CBC_ReedSolomonGF256Poly::CBC_ReedSolomonGF256Poly(
     CBC_ReedSolomonGF256* field,
     const std::vector<int32_t>& coefficients)
-    : m_field(field) {
-  DCHECK(m_field);
+    : field_(field) {
+  DCHECK(field_);
   DCHECK(!coefficients.empty());
   if (coefficients.size() == 1 || coefficients.front() != 0) {
-    m_coefficients = coefficients;
+    coefficients_ = coefficients;
     return;
   }
 
@@ -47,35 +47,35 @@
     firstNonZero++;
   }
   if (firstNonZero == coefficients.size()) {
-    m_coefficients = m_field->GetZero()->GetCoefficients();
+    coefficients_ = field_->GetZero()->GetCoefficients();
   } else {
-    m_coefficients.resize(coefficients.size() - firstNonZero);
+    coefficients_.resize(coefficients.size() - firstNonZero);
     for (size_t i = firstNonZero, j = 0; i < coefficients.size(); i++, j++)
-      m_coefficients[j] = coefficients[i];
+      coefficients_[j] = coefficients[i];
   }
 }
 
 CBC_ReedSolomonGF256Poly::~CBC_ReedSolomonGF256Poly() = default;
 
 const std::vector<int32_t>& CBC_ReedSolomonGF256Poly::GetCoefficients() const {
-  return m_coefficients;
+  return coefficients_;
 }
 
 int32_t CBC_ReedSolomonGF256Poly::GetDegree() const {
-  return fxcrt::CollectionSize<int32_t>(m_coefficients) - 1;
+  return fxcrt::CollectionSize<int32_t>(coefficients_) - 1;
 }
 
 bool CBC_ReedSolomonGF256Poly::IsZero() const {
-  return m_coefficients.front() == 0;
+  return coefficients_.front() == 0;
 }
 
 int32_t CBC_ReedSolomonGF256Poly::GetCoefficients(int32_t degree) const {
-  return m_coefficients[m_coefficients.size() - 1 - degree];
+  return coefficients_[coefficients_.size() - 1 - degree];
 }
 
 std::unique_ptr<CBC_ReedSolomonGF256Poly> CBC_ReedSolomonGF256Poly::Clone()
     const {
-  return std::make_unique<CBC_ReedSolomonGF256Poly>(m_field, m_coefficients);
+  return std::make_unique<CBC_ReedSolomonGF256Poly>(field_, coefficients_);
 }
 
 std::unique_ptr<CBC_ReedSolomonGF256Poly>
@@ -85,7 +85,7 @@
   if (other->IsZero())
     return Clone();
 
-  std::vector<int32_t> smallerCoefficients = m_coefficients;
+  std::vector<int32_t> smallerCoefficients = coefficients_;
   std::vector<int32_t> largerCoefficients = other->GetCoefficients();
   if (smallerCoefficients.size() > largerCoefficients.size())
     std::swap(smallerCoefficients, largerCoefficients);
@@ -99,15 +99,15 @@
     sumDiff[i] = CBC_ReedSolomonGF256::AddOrSubtract(
         smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
   }
-  return std::make_unique<CBC_ReedSolomonGF256Poly>(m_field, sumDiff);
+  return std::make_unique<CBC_ReedSolomonGF256Poly>(field_, sumDiff);
 }
 
 std::unique_ptr<CBC_ReedSolomonGF256Poly> CBC_ReedSolomonGF256Poly::Multiply(
     const CBC_ReedSolomonGF256Poly* other) {
   if (IsZero() || other->IsZero())
-    return m_field->GetZero()->Clone();
+    return field_->GetZero()->Clone();
 
-  const std::vector<int32_t>& aCoefficients = m_coefficients;
+  const std::vector<int32_t>& aCoefficients = coefficients_;
   const std::vector<int32_t>& bCoefficients = other->GetCoefficients();
   size_t aLength = aCoefficients.size();
   size_t bLength = bCoefficients.size();
@@ -116,10 +116,10 @@
     int32_t aCoeff = aCoefficients[i];
     for (size_t j = 0; j < bLength; j++) {
       product[i + j] = CBC_ReedSolomonGF256::AddOrSubtract(
-          product[i + j], m_field->Multiply(aCoeff, bCoefficients[j]));
+          product[i + j], field_->Multiply(aCoeff, bCoefficients[j]));
     }
   }
-  return std::make_unique<CBC_ReedSolomonGF256Poly>(m_field, product);
+  return std::make_unique<CBC_ReedSolomonGF256Poly>(field_, product);
 }
 
 std::unique_ptr<CBC_ReedSolomonGF256Poly>
@@ -128,14 +128,14 @@
   if (degree < 0)
     return nullptr;
   if (coefficient == 0)
-    return m_field->GetZero()->Clone();
+    return field_->GetZero()->Clone();
 
-  size_t size = m_coefficients.size();
+  size_t size = coefficients_.size();
   std::vector<int32_t> product(size + degree);
   for (size_t i = 0; i < size; i++)
-    product[i] = m_field->Multiply(m_coefficients[i], coefficient);
+    product[i] = field_->Multiply(coefficients_[i], coefficient);
 
-  return std::make_unique<CBC_ReedSolomonGF256Poly>(m_field, product);
+  return std::make_unique<CBC_ReedSolomonGF256Poly>(field_, product);
 }
 
 std::unique_ptr<CBC_ReedSolomonGF256Poly> CBC_ReedSolomonGF256Poly::Divide(
@@ -143,7 +143,7 @@
   if (other->IsZero())
     return nullptr;
 
-  auto quotient = m_field->GetZero()->Clone();
+  auto quotient = field_->GetZero()->Clone();
   if (!quotient)
     return nullptr;
   auto remainder = Clone();
@@ -152,19 +152,19 @@
 
   int32_t denominatorLeadingTerm = other->GetCoefficients(other->GetDegree());
   std::optional<int32_t> inverseDenominatorLeadingTeam =
-      m_field->Inverse(denominatorLeadingTerm);
+      field_->Inverse(denominatorLeadingTerm);
   if (!inverseDenominatorLeadingTeam.has_value())
     return nullptr;
 
   while (remainder->GetDegree() >= other->GetDegree() && !remainder->IsZero()) {
     int32_t degreeDifference = remainder->GetDegree() - other->GetDegree();
     int32_t scale =
-        m_field->Multiply(remainder->GetCoefficients((remainder->GetDegree())),
-                          inverseDenominatorLeadingTeam.value());
+        field_->Multiply(remainder->GetCoefficients((remainder->GetDegree())),
+                         inverseDenominatorLeadingTeam.value());
     auto term = other->MultiplyByMonomial(degreeDifference, scale);
     if (!term)
       return nullptr;
-    auto iteratorQuotient = m_field->BuildMonomial(degreeDifference, scale);
+    auto iteratorQuotient = field_->BuildMonomial(degreeDifference, scale);
     if (!iteratorQuotient)
       return nullptr;
     quotient = quotient->AddOrSubtract(iteratorQuotient.get());
diff --git a/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256Poly.h b/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256Poly.h
index e274c76..f94ecb8 100644
--- a/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256Poly.h
+++ b/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256Poly.h
@@ -36,8 +36,8 @@
   std::unique_ptr<CBC_ReedSolomonGF256Poly> Clone() const;
 
  private:
-  UnownedPtr<CBC_ReedSolomonGF256> const m_field;
-  std::vector<int32_t> m_coefficients;
+  UnownedPtr<CBC_ReedSolomonGF256> const field_;
+  std::vector<int32_t> coefficients_;
 };
 
 #endif  // FXBARCODE_COMMON_REEDSOLOMON_BC_REEDSOLOMONGF256POLY_H_
diff --git a/fxbarcode/datamatrix/BC_ASCIIEncoder.cpp b/fxbarcode/datamatrix/BC_ASCIIEncoder.cpp
index 1720f2e..d221430 100644
--- a/fxbarcode/datamatrix/BC_ASCIIEncoder.cpp
+++ b/fxbarcode/datamatrix/BC_ASCIIEncoder.cpp
@@ -73,21 +73,21 @@
 }
 
 bool CBC_ASCIIEncoder::Encode(CBC_EncoderContext* context) {
-  size_t n = DetermineConsecutiveDigitCount(context->m_msg, context->m_pos);
+  size_t n = DetermineConsecutiveDigitCount(context->msg_, context->pos_);
   if (n >= 2) {
     std::optional<wchar_t> code = EncodeASCIIDigits(
-        context->m_msg[context->m_pos], context->m_msg[context->m_pos + 1]);
+        context->msg_[context->pos_], context->msg_[context->pos_ + 1]);
     if (!code.has_value())
       return false;
 
     context->writeCodeword(code.value());
-    context->m_pos += 2;
+    context->pos_ += 2;
     return true;
   }
 
   wchar_t c = context->getCurrentChar();
   CBC_HighLevelEncoder::Encoding newMode = CBC_HighLevelEncoder::LookAheadTest(
-      context->m_msg, context->m_pos, GetEncodingMode());
+      context->msg_, context->pos_, GetEncodingMode());
   if (newMode != GetEncodingMode()) {
     switch (newMode) {
       case CBC_HighLevelEncoder::Encoding::BASE256:
@@ -118,6 +118,6 @@
   } else {
     context->writeCodeword(static_cast<wchar_t>(c + 1));
   }
-  context->m_pos++;
+  context->pos_++;
   return true;
 }
diff --git a/fxbarcode/datamatrix/BC_Base256Encoder.cpp b/fxbarcode/datamatrix/BC_Base256Encoder.cpp
index 53eacf3..ad7fb5f 100644
--- a/fxbarcode/datamatrix/BC_Base256Encoder.cpp
+++ b/fxbarcode/datamatrix/BC_Base256Encoder.cpp
@@ -54,9 +54,9 @@
   while (context->hasMoreCharacters()) {
     wchar_t c = context->getCurrentChar();
     buffer += c;
-    context->m_pos++;
+    context->pos_++;
     CBC_HighLevelEncoder::Encoding newMode =
-        CBC_HighLevelEncoder::LookAheadTest(context->m_msg, context->m_pos,
+        CBC_HighLevelEncoder::LookAheadTest(context->msg_, context->pos_,
                                             GetEncodingMode());
     if (newMode != GetEncodingMode()) {
       context->SignalEncoderChange(newMode);
@@ -73,7 +73,7 @@
   if (!context->UpdateSymbolInfo(currentSize))
     return false;
 
-  bool mustPad = (context->m_symbolInfo->data_capacity() - currentSize) > 0;
+  bool mustPad = (context->symbol_info_->data_capacity() - currentSize) > 0;
   if (context->hasMoreCharacters() || mustPad) {
     if (dataCount <= 249) {
       buffer.SetAt(0, static_cast<wchar_t>(dataCount));
diff --git a/fxbarcode/datamatrix/BC_C40Encoder.cpp b/fxbarcode/datamatrix/BC_C40Encoder.cpp
index 510012f..70b6c80 100644
--- a/fxbarcode/datamatrix/BC_C40Encoder.cpp
+++ b/fxbarcode/datamatrix/BC_C40Encoder.cpp
@@ -59,7 +59,7 @@
   WideString buffer;
   while (context->hasMoreCharacters()) {
     wchar_t c = context->getCurrentChar();
-    context->m_pos++;
+    context->pos_++;
     int32_t lastCharSize = EncodeChar(c, &buffer);
     if (lastCharSize <= 0)
       return false;
@@ -70,7 +70,7 @@
       return false;
 
     int32_t available =
-        context->m_symbolInfo->data_capacity() - curCodewordCount;
+        context->symbol_info_->data_capacity() - curCodewordCount;
     if (!context->hasMoreCharacters()) {
       if ((buffer.GetLength() % 3) == 2) {
         if (available < 2 || available > 2) {
@@ -90,7 +90,7 @@
     size_t count = buffer.GetLength();
     if ((count % 3) == 0) {
       CBC_HighLevelEncoder::Encoding newMode =
-          CBC_HighLevelEncoder::LookAheadTest(context->m_msg, context->m_pos,
+          CBC_HighLevelEncoder::LookAheadTest(context->msg_, context->pos_,
                                               GetEncodingMode());
       if (newMode != GetEncodingMode()) {
         context->SignalEncoderChange(newMode);
@@ -115,7 +115,7 @@
   if (!context->UpdateSymbolInfo(curCodewordCount))
     return false;
 
-  int32_t available = context->m_symbolInfo->data_capacity() - curCodewordCount;
+  int32_t available = context->symbol_info_->data_capacity() - curCodewordCount;
   if (rest == 2) {
     *buffer += (wchar_t)'\0';
     while (buffer->GetLength() >= 3)
@@ -129,7 +129,7 @@
     if (context->hasMoreCharacters()) {
       context->writeCodeword(CBC_HighLevelEncoder::C40_UNLATCH);
     }
-    context->m_pos--;
+    context->pos_--;
   } else if (rest == 0) {
     while (buffer->GetLength() >= 3)
       WriteNextTriplet(context, buffer);
@@ -195,15 +195,16 @@
                                               int32_t lastCharSize) {
   DCHECK(lastCharSize >= 0);
 
-  if (context->m_pos < 1)
+  if (context->pos_ < 1) {
     return -1;
+  }
 
   size_t count = buffer->GetLength();
   if (count < static_cast<size_t>(lastCharSize))
     return -1;
 
   buffer->Delete(count - lastCharSize, lastCharSize);
-  context->m_pos--;
+  context->pos_--;
   wchar_t c = context->getCurrentChar();
   WideString removed;
   int32_t len = EncodeChar(c, &removed);
diff --git a/fxbarcode/datamatrix/BC_DefaultPlacement.cpp b/fxbarcode/datamatrix/BC_DefaultPlacement.cpp
index fbb4d76..ed3f518 100644
--- a/fxbarcode/datamatrix/BC_DefaultPlacement.cpp
+++ b/fxbarcode/datamatrix/BC_DefaultPlacement.cpp
@@ -42,12 +42,12 @@
 CBC_DefaultPlacement::CBC_DefaultPlacement(WideString codewords,
                                            int32_t numcols,
                                            int32_t numrows)
-    : m_codewords(std::move(codewords)),
-      m_numrows(numrows),
-      m_numcols(numcols),
-      m_bits(Fx2DSizeOrDie(numcols, numrows), 2) {
-  CHECK_GT(m_numrows, 0);
-  CHECK_GT(m_numcols, 0);
+    : codewords_(std::move(codewords)),
+      numrows_(numrows),
+      numcols_(numcols),
+      bits_(Fx2DSizeOrDie(numcols, numrows), 2) {
+  CHECK_GT(numrows_, 0);
+  CHECK_GT(numcols_, 0);
   Init();
 }
 
@@ -56,25 +56,25 @@
 bool CBC_DefaultPlacement::GetBit(int32_t col, int32_t row) const {
   CHECK_GE(col, 0);
   CHECK_GE(row, 0);
-  CHECK_LT(col, m_numcols);
-  CHECK_LT(row, m_numrows);
-  return m_bits[GetIndex(col, row, m_numcols)] == 1;
+  CHECK_LT(col, numcols_);
+  CHECK_LT(row, numrows_);
+  return bits_[GetIndex(col, row, numcols_)] == 1;
 }
 
 void CBC_DefaultPlacement::SetBit(int32_t col, int32_t row, bool bit) {
   DCHECK_GE(col, 0);
   DCHECK_GE(row, 0);
-  DCHECK_LT(col, m_numcols);
-  DCHECK_LT(row, m_numrows);
-  m_bits[GetIndex(col, row, m_numcols)] = bit ? 1 : 0;
+  DCHECK_LT(col, numcols_);
+  DCHECK_LT(row, numrows_);
+  bits_[GetIndex(col, row, numcols_)] = bit ? 1 : 0;
 }
 
 bool CBC_DefaultPlacement::HasBit(int32_t col, int32_t row) const {
   DCHECK_GE(col, 0);
   DCHECK_GE(row, 0);
-  DCHECK_LT(col, m_numcols);
-  DCHECK_LT(row, m_numrows);
-  return m_bits[GetIndex(col, row, m_numcols)] != 2;
+  DCHECK_LT(col, numcols_);
+  DCHECK_LT(row, numrows_);
+  return bits_[GetIndex(col, row, numcols_)] != 2;
 }
 
 void CBC_DefaultPlacement::Init() {
@@ -82,40 +82,40 @@
   int32_t row = 4;
   int32_t col = 0;
   do {
-    if ((row == m_numrows) && (col == 0)) {
+    if ((row == numrows_) && (col == 0)) {
       SetCorner1(pos++);
     }
-    if ((row == m_numrows - 2) && (col == 0) && ((m_numcols % 4) != 0)) {
+    if ((row == numrows_ - 2) && (col == 0) && ((numcols_ % 4) != 0)) {
       SetCorner2(pos++);
     }
-    if ((row == m_numrows - 2) && (col == 0) && (m_numcols % 8 == 4)) {
+    if ((row == numrows_ - 2) && (col == 0) && (numcols_ % 8 == 4)) {
       SetCorner3(pos++);
     }
-    if ((row == m_numrows + 4) && (col == 2) && ((m_numcols % 8) == 0)) {
+    if ((row == numrows_ + 4) && (col == 2) && ((numcols_ % 8) == 0)) {
       SetCorner4(pos++);
     }
     do {
-      if ((row < m_numrows) && (col >= 0) && !HasBit(col, row)) {
+      if ((row < numrows_) && (col >= 0) && !HasBit(col, row)) {
         SetUtah(row, col, pos++);
       }
       row -= 2;
       col += 2;
-    } while (row >= 0 && (col < m_numcols));
+    } while (row >= 0 && (col < numcols_));
     row++;
     col += 3;
     do {
-      if ((row >= 0) && (col < m_numcols) && !HasBit(col, row)) {
+      if ((row >= 0) && (col < numcols_) && !HasBit(col, row)) {
         SetUtah(row, col, pos++);
       }
       row += 2;
       col -= 2;
-    } while ((row < m_numrows) && (col >= 0));
+    } while ((row < numrows_) && (col >= 0));
     row += 3;
     col++;
-  } while ((row < m_numrows) || (col < m_numcols));
-  if (!HasBit(m_numcols - 1, m_numrows - 1)) {
-    SetBit(m_numcols - 1, m_numrows - 1, true);
-    SetBit(m_numcols - 2, m_numrows - 2, true);
+  } while ((row < numrows_) || (col < numcols_));
+  if (!HasBit(numcols_ - 1, numrows_ - 1)) {
+    SetBit(numcols_ - 1, numrows_ - 1, true);
+    SetBit(numcols_ - 2, numrows_ - 2, true);
   }
 }
 
@@ -124,14 +124,14 @@
                                      int32_t pos,
                                      int32_t bit) {
   if (row < 0) {
-    row += m_numrows;
-    col += 4 - ((m_numrows + 4) % 8);
+    row += numrows_;
+    col += 4 - ((numrows_ + 4) % 8);
   }
   if (col < 0) {
-    col += m_numcols;
-    row += 4 - ((m_numcols + 4) % 8);
+    col += numcols_;
+    row += 4 - ((numcols_ + 4) % 8);
   }
-  int32_t v = m_codewords[pos];
+  int32_t v = codewords_[pos];
   v &= 1 << (8 - bit);
   SetBit(col, row, v != 0);
 }
@@ -148,45 +148,45 @@
 }
 
 void CBC_DefaultPlacement::SetCorner1(int32_t pos) {
-  SetModule(m_numrows - 1, 0, pos, 1);
-  SetModule(m_numrows - 1, 1, pos, 2);
-  SetModule(m_numrows - 1, 2, pos, 3);
-  SetModule(0, m_numcols - 2, pos, 4);
-  SetModule(0, m_numcols - 1, pos, 5);
-  SetModule(1, m_numcols - 1, pos, 6);
-  SetModule(2, m_numcols - 1, pos, 7);
-  SetModule(3, m_numcols - 1, pos, 8);
+  SetModule(numrows_ - 1, 0, pos, 1);
+  SetModule(numrows_ - 1, 1, pos, 2);
+  SetModule(numrows_ - 1, 2, pos, 3);
+  SetModule(0, numcols_ - 2, pos, 4);
+  SetModule(0, numcols_ - 1, pos, 5);
+  SetModule(1, numcols_ - 1, pos, 6);
+  SetModule(2, numcols_ - 1, pos, 7);
+  SetModule(3, numcols_ - 1, pos, 8);
 }
 
 void CBC_DefaultPlacement::SetCorner2(int32_t pos) {
-  SetModule(m_numrows - 3, 0, pos, 1);
-  SetModule(m_numrows - 2, 0, pos, 2);
-  SetModule(m_numrows - 1, 0, pos, 3);
-  SetModule(0, m_numcols - 4, pos, 4);
-  SetModule(0, m_numcols - 3, pos, 5);
-  SetModule(0, m_numcols - 2, pos, 6);
-  SetModule(0, m_numcols - 1, pos, 7);
-  SetModule(1, m_numcols - 1, pos, 8);
+  SetModule(numrows_ - 3, 0, pos, 1);
+  SetModule(numrows_ - 2, 0, pos, 2);
+  SetModule(numrows_ - 1, 0, pos, 3);
+  SetModule(0, numcols_ - 4, pos, 4);
+  SetModule(0, numcols_ - 3, pos, 5);
+  SetModule(0, numcols_ - 2, pos, 6);
+  SetModule(0, numcols_ - 1, pos, 7);
+  SetModule(1, numcols_ - 1, pos, 8);
 }
 
 void CBC_DefaultPlacement::SetCorner3(int32_t pos) {
-  SetModule(m_numrows - 3, 0, pos, 1);
-  SetModule(m_numrows - 2, 0, pos, 2);
-  SetModule(m_numrows - 1, 0, pos, 3);
-  SetModule(0, m_numcols - 2, pos, 4);
-  SetModule(0, m_numcols - 1, pos, 5);
-  SetModule(1, m_numcols - 1, pos, 6);
-  SetModule(2, m_numcols - 1, pos, 7);
-  SetModule(3, m_numcols - 1, pos, 8);
+  SetModule(numrows_ - 3, 0, pos, 1);
+  SetModule(numrows_ - 2, 0, pos, 2);
+  SetModule(numrows_ - 1, 0, pos, 3);
+  SetModule(0, numcols_ - 2, pos, 4);
+  SetModule(0, numcols_ - 1, pos, 5);
+  SetModule(1, numcols_ - 1, pos, 6);
+  SetModule(2, numcols_ - 1, pos, 7);
+  SetModule(3, numcols_ - 1, pos, 8);
 }
 
 void CBC_DefaultPlacement::SetCorner4(int32_t pos) {
-  SetModule(m_numrows - 1, 0, pos, 1);
-  SetModule(m_numrows - 1, m_numcols - 1, pos, 2);
-  SetModule(0, m_numcols - 3, pos, 3);
-  SetModule(0, m_numcols - 2, pos, 4);
-  SetModule(0, m_numcols - 1, pos, 5);
-  SetModule(1, m_numcols - 3, pos, 6);
-  SetModule(1, m_numcols - 2, pos, 7);
-  SetModule(1, m_numcols - 1, pos, 8);
+  SetModule(numrows_ - 1, 0, pos, 1);
+  SetModule(numrows_ - 1, numcols_ - 1, pos, 2);
+  SetModule(0, numcols_ - 3, pos, 3);
+  SetModule(0, numcols_ - 2, pos, 4);
+  SetModule(0, numcols_ - 1, pos, 5);
+  SetModule(1, numcols_ - 3, pos, 6);
+  SetModule(1, numcols_ - 2, pos, 7);
+  SetModule(1, numcols_ - 1, pos, 8);
 }
diff --git a/fxbarcode/datamatrix/BC_DefaultPlacement.h b/fxbarcode/datamatrix/BC_DefaultPlacement.h
index 7a5b201..e70a357 100644
--- a/fxbarcode/datamatrix/BC_DefaultPlacement.h
+++ b/fxbarcode/datamatrix/BC_DefaultPlacement.h
@@ -31,10 +31,10 @@
   void SetBit(int32_t col, int32_t row, bool bit);
   bool HasBit(int32_t col, int32_t row) const;
 
-  const WideString m_codewords;
-  const int32_t m_numrows;
-  const int32_t m_numcols;
-  DataVector<uint8_t> m_bits;
+  const WideString codewords_;
+  const int32_t numrows_;
+  const int32_t numcols_;
+  DataVector<uint8_t> bits_;
 };
 
 #endif  // FXBARCODE_DATAMATRIX_BC_DEFAULTPLACEMENT_H_
diff --git a/fxbarcode/datamatrix/BC_EdifactEncoder.cpp b/fxbarcode/datamatrix/BC_EdifactEncoder.cpp
index bc81c7b..9960acb 100644
--- a/fxbarcode/datamatrix/BC_EdifactEncoder.cpp
+++ b/fxbarcode/datamatrix/BC_EdifactEncoder.cpp
@@ -63,7 +63,7 @@
       return false;
 
     int32_t available =
-        context->m_symbolInfo->data_capacity() - context->getCodewordCount();
+        context->symbol_info_->data_capacity() - context->getCodewordCount();
     int32_t remaining = context->getRemainingCharacters();
     if (remaining == 0 && available <= 2)
       return true;
@@ -81,7 +81,7 @@
       return false;
 
     int32_t available =
-        context->m_symbolInfo->data_capacity() - context->getCodewordCount();
+        context->symbol_info_->data_capacity() - context->getCodewordCount();
     if (available >= 3) {
       restInAscii = false;
       if (!context->UpdateSymbolInfo(context->getCodewordCount() +
@@ -93,7 +93,7 @@
 
   if (restInAscii) {
     context->resetSymbolInfo();
-    context->m_pos -= restChars;
+    context->pos_ -= restChars;
   } else {
     context->writeCodewords(encoded);
   }
@@ -132,7 +132,7 @@
     if (!AppendEncodedChar(c, &buffer))
       return false;
 
-    context->m_pos++;
+    context->pos_++;
     size_t count = buffer.GetLength();
     if (count >= 4) {
       WideString encoded = EncodeToEdifactCodewords(buffer);
@@ -142,7 +142,7 @@
       context->writeCodewords(encoded);
       buffer.Delete(0, 4);
       CBC_HighLevelEncoder::Encoding newMode =
-          CBC_HighLevelEncoder::LookAheadTest(context->m_msg, context->m_pos,
+          CBC_HighLevelEncoder::LookAheadTest(context->msg_, context->pos_,
                                               GetEncodingMode());
       if (newMode != GetEncodingMode()) {
         context->SignalEncoderChange(CBC_HighLevelEncoder::Encoding::ASCII);
diff --git a/fxbarcode/datamatrix/BC_EncoderContext.cpp b/fxbarcode/datamatrix/BC_EncoderContext.cpp
index 823e95e..4f6f7ea 100644
--- a/fxbarcode/datamatrix/BC_EncoderContext.cpp
+++ b/fxbarcode/datamatrix/BC_EncoderContext.cpp
@@ -36,53 +36,53 @@
   for (size_t i = 0; i < c; i++) {
     wchar_t ch = static_cast<wchar_t>(dststr[i] & 0xff);
     if (ch == '?' && dststr[i] != '?') {
-      m_bHasCharactersOutsideISO88591Encoding = true;
+      has_characters_outside_iso88591_encoding_ = true;
     }
     sb += ch;
   }
-  m_msg = std::move(sb);
-  m_codewords.Reserve(m_msg.GetLength());
+  msg_ = std::move(sb);
+  codewords_.Reserve(msg_.GetLength());
 }
 
 CBC_EncoderContext::~CBC_EncoderContext() = default;
 
 void CBC_EncoderContext::setSkipAtEnd(int32_t count) {
-  m_skipAtEnd = count;
+  skip_at_end_ = count;
 }
 wchar_t CBC_EncoderContext::getCurrentChar() {
-  return m_msg[m_pos];
+  return msg_[pos_];
 }
 wchar_t CBC_EncoderContext::getCurrent() {
-  return m_msg[m_pos];
+  return msg_[pos_];
 }
 
 void CBC_EncoderContext::writeCodewords(const WideString& codewords) {
-  m_codewords += codewords;
+  codewords_ += codewords;
 }
 
 void CBC_EncoderContext::writeCodeword(wchar_t codeword) {
-  m_codewords += codeword;
+  codewords_ += codeword;
 }
 
 size_t CBC_EncoderContext::getCodewordCount() {
-  return m_codewords.GetLength();
+  return codewords_.GetLength();
 }
 
 void CBC_EncoderContext::SignalEncoderChange(
     CBC_HighLevelEncoder::Encoding encoding) {
-  m_newEncoding = encoding;
+  new_encoding_ = encoding;
 }
 
 void CBC_EncoderContext::ResetEncoderSignal() {
-  m_newEncoding = CBC_HighLevelEncoder::Encoding::UNKNOWN;
+  new_encoding_ = CBC_HighLevelEncoder::Encoding::UNKNOWN;
 }
 
 bool CBC_EncoderContext::hasMoreCharacters() {
-  return m_pos < getTotalMessageCharCount();
+  return pos_ < getTotalMessageCharCount();
 }
 
 size_t CBC_EncoderContext::getRemainingCharacters() {
-  return getTotalMessageCharCount() - m_pos;
+  return getTotalMessageCharCount() - pos_;
 }
 
 bool CBC_EncoderContext::UpdateSymbolInfo() {
@@ -90,18 +90,19 @@
 }
 
 bool CBC_EncoderContext::UpdateSymbolInfo(size_t len) {
-  if (!m_symbolInfo || len > m_symbolInfo->data_capacity()) {
-    m_symbolInfo = CBC_SymbolInfo::Lookup(len, m_bAllowRectangular);
-    if (!m_symbolInfo)
+  if (!symbol_info_ || len > symbol_info_->data_capacity()) {
+    symbol_info_ = CBC_SymbolInfo::Lookup(len, allow_rectangular_);
+    if (!symbol_info_) {
       return false;
+    }
   }
   return true;
 }
 
 void CBC_EncoderContext::resetSymbolInfo() {
-  m_bAllowRectangular = true;
+  allow_rectangular_ = true;
 }
 
 size_t CBC_EncoderContext::getTotalMessageCharCount() {
-  return m_msg.GetLength() - m_skipAtEnd;
+  return msg_.GetLength() - skip_at_end_;
 }
diff --git a/fxbarcode/datamatrix/BC_EncoderContext.h b/fxbarcode/datamatrix/BC_EncoderContext.h
index 329ebb2..15e21bc 100644
--- a/fxbarcode/datamatrix/BC_EncoderContext.h
+++ b/fxbarcode/datamatrix/BC_EncoderContext.h
@@ -33,22 +33,22 @@
   void resetSymbolInfo();
 
   bool HasCharactersOutsideISO88591Encoding() const {
-    return m_bHasCharactersOutsideISO88591Encoding;
+    return has_characters_outside_iso88591_encoding_;
   }
 
-  WideString m_msg;
-  WideString m_codewords;
-  size_t m_pos = 0;
-  CBC_HighLevelEncoder::Encoding m_newEncoding =
+  WideString msg_;
+  WideString codewords_;
+  size_t pos_ = 0;
+  CBC_HighLevelEncoder::Encoding new_encoding_ =
       CBC_HighLevelEncoder::Encoding::UNKNOWN;
-  UnownedPtr<const CBC_SymbolInfo> m_symbolInfo;
+  UnownedPtr<const CBC_SymbolInfo> symbol_info_;
 
  private:
   size_t getTotalMessageCharCount();
 
-  bool m_bAllowRectangular = false;  // Force square when false.
-  bool m_bHasCharactersOutsideISO88591Encoding = false;
-  size_t m_skipAtEnd = 0;
+  bool allow_rectangular_ = false;  // Force square when false.
+  bool has_characters_outside_iso88591_encoding_ = false;
+  size_t skip_at_end_ = 0;
 };
 
 #endif  // FXBARCODE_DATAMATRIX_BC_ENCODERCONTEXT_H_
diff --git a/fxbarcode/datamatrix/BC_HighLevelEncoder.cpp b/fxbarcode/datamatrix/BC_HighLevelEncoder.cpp
index b8358fc..df3696d 100644
--- a/fxbarcode/datamatrix/BC_HighLevelEncoder.cpp
+++ b/fxbarcode/datamatrix/BC_HighLevelEncoder.cpp
@@ -135,11 +135,11 @@
     if (left == kMacro05Header) {
       context.writeCodeword(kMacro05);
       context.setSkipAtEnd(2);
-      context.m_pos += 6;
+      context.pos_ += 6;
     } else if (left == kMacro06Header) {
       context.writeCodeword(kMacro06);
       context.setSkipAtEnd(2);
-      context.m_pos += 6;
+      context.pos_ += 6;
     }
   }
 
@@ -155,21 +155,21 @@
     if (!encoders[EncoderIndex(encodingMode)]->Encode(&context))
       return WideString();
 
-    if (context.m_newEncoding != Encoding::UNKNOWN) {
-      encodingMode = context.m_newEncoding;
+    if (context.new_encoding_ != Encoding::UNKNOWN) {
+      encodingMode = context.new_encoding_;
       context.ResetEncoderSignal();
     }
   }
-  size_t len = context.m_codewords.GetLength();
+  size_t len = context.codewords_.GetLength();
   if (!context.UpdateSymbolInfo())
     return WideString();
 
-  size_t capacity = context.m_symbolInfo->data_capacity();
+  size_t capacity = context.symbol_info_->data_capacity();
   if (len < capacity) {
     if (encodingMode != Encoding::ASCII && encodingMode != Encoding::BASE256)
       context.writeCodeword(0x00fe);
   }
-  WideString codewords = context.m_codewords;
+  WideString codewords = context.codewords_;
   if (codewords.GetLength() < capacity)
     codewords += kPad;
 
diff --git a/fxbarcode/datamatrix/BC_X12Encoder.cpp b/fxbarcode/datamatrix/BC_X12Encoder.cpp
index 655b7ac..532d1e3 100644
--- a/fxbarcode/datamatrix/BC_X12Encoder.cpp
+++ b/fxbarcode/datamatrix/BC_X12Encoder.cpp
@@ -41,7 +41,7 @@
   WideString buffer;
   while (context->hasMoreCharacters()) {
     wchar_t c = context->getCurrentChar();
-    context->m_pos++;
+    context->pos_++;
     if (EncodeChar(c, &buffer) <= 0)
       return false;
 
@@ -49,7 +49,7 @@
     if ((count % 3) == 0) {
       WriteNextTriplet(context, &buffer);
       CBC_HighLevelEncoder::Encoding newMode =
-          CBC_HighLevelEncoder::LookAheadTest(context->m_msg, context->m_pos,
+          CBC_HighLevelEncoder::LookAheadTest(context->msg_, context->pos_,
                                               GetEncodingMode());
       if (newMode != GetEncodingMode()) {
         context->SignalEncoderChange(newMode);
@@ -66,14 +66,14 @@
     return false;
 
   int32_t available =
-      context->m_symbolInfo->data_capacity() - context->getCodewordCount();
+      context->symbol_info_->data_capacity() - context->getCodewordCount();
   size_t count = buffer->GetLength();
   if (count == 2) {
     context->writeCodeword(CBC_HighLevelEncoder::X12_UNLATCH);
-    context->m_pos -= 2;
+    context->pos_ -= 2;
     context->SignalEncoderChange(CBC_HighLevelEncoder::Encoding::ASCII);
   } else if (count == 1) {
-    context->m_pos--;
+    context->pos_--;
     if (available > 1) {
       context->writeCodeword(CBC_HighLevelEncoder::X12_UNLATCH);
     }
diff --git a/fxbarcode/oned/BC_OneDimWriter.cpp b/fxbarcode/oned/BC_OneDimWriter.cpp
index 2e9093d..adaaa29 100644
--- a/fxbarcode/oned/BC_OneDimWriter.cpp
+++ b/fxbarcode/oned/BC_OneDimWriter.cpp
@@ -54,35 +54,35 @@
 CBC_OneDimWriter::~CBC_OneDimWriter() = default;
 
 void CBC_OneDimWriter::SetPrintChecksum(bool checksum) {
-  m_bPrintChecksum = checksum;
+  print_checksum_ = checksum;
 }
 
 void CBC_OneDimWriter::SetDataLength(int32_t length) {
-  m_iDataLenth = length;
+  data_length_ = length;
 }
 
 void CBC_OneDimWriter::SetCalcChecksum(bool state) {
-  m_bCalcChecksum = state;
+  calc_checksum_ = state;
 }
 
 bool CBC_OneDimWriter::SetFont(CFX_Font* cFont) {
   if (!cFont)
     return false;
 
-  m_pFont = cFont;
+  font_ = cFont;
   return true;
 }
 
 void CBC_OneDimWriter::SetFontSize(float size) {
-  m_fFontSize = size;
+  font_size_ = size;
 }
 
 void CBC_OneDimWriter::SetFontStyle(int32_t style) {
-  m_iFontStyle = style;
+  font_style_ = style;
 }
 
 void CBC_OneDimWriter::SetFontColor(FX_ARGB color) {
-  m_fontColor = color;
+  font_color_ = color;
 }
 
 pdfium::span<uint8_t> CBC_OneDimWriter::AppendPattern(
@@ -155,11 +155,11 @@
                                        float locX,
                                        float locY,
                                        int32_t barWidth) {
-  int32_t iFontSize = static_cast<int32_t>(fabs(m_fFontSize));
+  int32_t iFontSize = static_cast<int32_t>(fabs(font_size_));
   int32_t iTextHeight = iFontSize + 1;
   CFX_FloatRect rect((float)locX, (float)locY, (float)(locX + geWidth),
                      (float)(locY + iTextHeight));
-  if (geWidth != m_Width) {
+  if (geWidth != width_) {
     rect.right -= 1;
   }
   FX_RECT re = matrix.TransformRect(rect).GetOuterRect();
@@ -167,38 +167,39 @@
   CFX_Matrix affine_matrix(1.0, 0.0, 0.0, -1.0, (float)locX,
                            (float)(locY + iFontSize));
   affine_matrix.Concat(matrix);
-  device->DrawNormalText(pCharPos.first(str.GetLength()), m_pFont,
+  device->DrawNormalText(pCharPos.first(str.GetLength()), font_,
                          static_cast<float>(iFontSize), affine_matrix,
-                         m_fontColor, GetTextRenderOptions());
+                         font_color_, GetTextRenderOptions());
 }
 
 bool CBC_OneDimWriter::ShowChars(WideStringView contents,
                                  CFX_RenderDevice* device,
                                  const CFX_Matrix& matrix,
                                  int32_t barWidth) {
-  if (!device || !m_pFont)
+  if (!device || !font_) {
     return false;
+  }
 
   ByteString str = FX_UTF8Encode(contents);
   std::vector<TextCharPos> charpos(str.GetLength());
   float charsLen = 0;
   float geWidth = 0;
-  if (m_locTextLoc == BC_TEXT_LOC::kAboveEmbed ||
-      m_locTextLoc == BC_TEXT_LOC::kBelowEmbed) {
+  if (loc_text_loc_ == BC_TEXT_LOC::kAboveEmbed ||
+      loc_text_loc_ == BC_TEXT_LOC::kBelowEmbed) {
     geWidth = 0;
-  } else if (m_locTextLoc == BC_TEXT_LOC::kAbove ||
-             m_locTextLoc == BC_TEXT_LOC::kBelow) {
+  } else if (loc_text_loc_ == BC_TEXT_LOC::kAbove ||
+             loc_text_loc_ == BC_TEXT_LOC::kBelow) {
     geWidth = (float)barWidth;
   }
-  int32_t iFontSize = static_cast<int32_t>(fabs(m_fFontSize));
+  int32_t iFontSize = static_cast<int32_t>(fabs(font_size_));
   int32_t iTextHeight = iFontSize + 1;
-  CalcTextInfo(str, charpos, m_pFont, geWidth, iFontSize, charsLen);
+  CalcTextInfo(str, charpos, font_, geWidth, iFontSize, charsLen);
   if (charsLen < 1)
     return true;
 
   int32_t locX = 0;
   int32_t locY = 0;
-  switch (m_locTextLoc) {
+  switch (loc_text_loc_) {
     case BC_TEXT_LOC::kAboveEmbed:
       locX = static_cast<int32_t>(barWidth - charsLen) / 2;
       locY = 0;
@@ -211,13 +212,13 @@
       break;
     case BC_TEXT_LOC::kBelowEmbed:
       locX = static_cast<int32_t>(barWidth - charsLen) / 2;
-      locY = m_Height - iTextHeight;
+      locY = height_ - iTextHeight;
       geWidth = charsLen;
       break;
     case BC_TEXT_LOC::kBelow:
     default:
       locX = 0;
-      locY = m_Height - iTextHeight;
+      locY = height_ - iTextHeight;
       geWidth = (float)barWidth;
       break;
   }
@@ -229,26 +230,27 @@
 bool CBC_OneDimWriter::RenderDeviceResult(CFX_RenderDevice* device,
                                           const CFX_Matrix& matrix,
                                           WideStringView contents) {
-  if (m_output.empty())
+  if (output_.empty()) {
     return false;
+  }
 
   CFX_GraphStateData stateData;
   CFX_Path path;
-  path.AppendRect(0, 0, static_cast<float>(m_Width),
-                  static_cast<float>(m_Height));
+  path.AppendRect(0, 0, static_cast<float>(width_),
+                  static_cast<float>(height_));
   device->DrawPath(path, &matrix, &stateData, kBackgroundColor,
                    kBackgroundColor, CFX_FillRenderOptions::EvenOddOptions());
-  CFX_Matrix scaledMatrix(m_outputHScale, 0.0, 0.0,
-                          static_cast<float>(m_Height), 0.0, 0.0);
+  CFX_Matrix scaledMatrix(output_hscale_, 0.0, 0.0, static_cast<float>(height_),
+                          0.0, 0.0);
   scaledMatrix.Concat(matrix);
-  for (const auto& rect : m_output) {
+  for (const auto& rect : output_) {
     CFX_GraphStateData data;
     device->DrawPath(rect, &scaledMatrix, &data, kBarColor, 0,
                      CFX_FillRenderOptions::WindingOptions());
   }
 
-  return m_locTextLoc == BC_TEXT_LOC::kNone || !contents.Contains(' ') ||
-         ShowChars(contents, device, matrix, m_barWidth);
+  return loc_text_loc_ == BC_TEXT_LOC::kNone || !contents.Contains(' ') ||
+         ShowChars(contents, device, matrix, bar_width_);
 }
 
 bool CBC_OneDimWriter::RenderResult(WideStringView contents,
@@ -256,18 +258,18 @@
   if (code.empty())
     return false;
 
-  m_ModuleHeight = std::max(m_ModuleHeight, 20);
+  module_height_ = std::max(module_height_, 20);
   const size_t original_codelength = code.size();
-  const int32_t leftPadding = m_bLeftPadding ? 7 : 0;
-  const int32_t rightPadding = m_bRightPadding ? 7 : 0;
+  const int32_t leftPadding = left_padding_ ? 7 : 0;
+  const int32_t rightPadding = right_padding_ ? 7 : 0;
   const size_t codelength = code.size() + leftPadding + rightPadding;
-  m_outputHScale =
-      m_Width > 0 ? static_cast<float>(m_Width) / static_cast<float>(codelength)
-                  : 1.0;
-  m_barWidth = m_Width;
+  output_hscale_ =
+      width_ > 0 ? static_cast<float>(width_) / static_cast<float>(codelength)
+                 : 1.0;
+  bar_width_ = width_;
 
-  m_output.clear();
-  m_output.reserve(original_codelength);
+  output_.clear();
+  output_.reserve(original_codelength);
   for (size_t i = 0; i < original_codelength; ++i) {
     if (code[i] != 1)
       continue;
@@ -276,8 +278,8 @@
     if (output_index >= codelength)
       return true;
 
-    m_output.emplace_back();
-    m_output.back().AppendRect(output_index, 0.0f, output_index + 1, 1.0f);
+    output_.emplace_back();
+    output_.back().AppendRect(output_index, 0.0f, output_index + 1, 1.0f);
   }
   return true;
 }
diff --git a/fxbarcode/oned/BC_OneDimWriter.h b/fxbarcode/oned/BC_OneDimWriter.h
index 1251d4e..ea5fdd7 100644
--- a/fxbarcode/oned/BC_OneDimWriter.h
+++ b/fxbarcode/oned/BC_OneDimWriter.h
@@ -77,23 +77,23 @@
                                       pdfium::span<const uint8_t> pattern,
                                       bool startColor);
 
-  bool m_bPrintChecksum = true;
-  bool m_bCalcChecksum = false;
-  bool m_bLeftPadding = false;
-  bool m_bRightPadding = false;
+  bool print_checksum_ = true;
+  bool calc_checksum_ = false;
+  bool left_padding_ = false;
+  bool right_padding_ = false;
 
-  UnownedPtr<CFX_Font> m_pFont;
-  float m_fFontSize = 10.0f;
-  int32_t m_iFontStyle = 0;
-  uint32_t m_fontColor = 0xff000000;
-  BC_TEXT_LOC m_locTextLoc = BC_TEXT_LOC::kBelowEmbed;
+  UnownedPtr<CFX_Font> font_;
+  float font_size_ = 10.0f;
+  int32_t font_style_ = 0;
+  uint32_t font_color_ = 0xff000000;
+  BC_TEXT_LOC loc_text_loc_ = BC_TEXT_LOC::kBelowEmbed;
 
-  int32_t m_iDataLenth = 0;
-  size_t m_iContentLen = 0;
+  int32_t data_length_ = 0;
+  size_t content_len_ = 0;
 
-  std::vector<CFX_Path> m_output;
-  int32_t m_barWidth;
-  float m_outputHScale;
+  std::vector<CFX_Path> output_;
+  int32_t bar_width_;
+  float output_hscale_;
 };
 
 #endif  // FXBARCODE_ONED_BC_ONEDIMWRITER_H_
diff --git a/fxbarcode/oned/BC_OnedCodaBarWriter.cpp b/fxbarcode/oned/BC_OnedCodaBarWriter.cpp
index eaaadc5..9625a66 100644
--- a/fxbarcode/oned/BC_OnedCodaBarWriter.cpp
+++ b/fxbarcode/oned/BC_OnedCodaBarWriter.cpp
@@ -68,7 +68,7 @@
   if (!pdfium::Contains(kStartEndChars, start))
     return false;
 
-  m_chStart = start;
+  ch_start_ = start;
   return true;
 }
 
@@ -76,23 +76,23 @@
   if (!pdfium::Contains(kStartEndChars, end))
     return false;
 
-  m_chEnd = end;
+  ch_end_ = end;
   return true;
 }
 
 void CBC_OnedCodaBarWriter::SetDataLength(int32_t length) {
-  m_iDataLenth = length + 2;
+  data_length_ = length + 2;
 }
 
 void CBC_OnedCodaBarWriter::SetTextLocation(BC_TEXT_LOC location) {
-  m_locTextLoc = location;
+  loc_text_loc_ = location;
 }
 
 bool CBC_OnedCodaBarWriter::SetWideNarrowRatio(int8_t ratio) {
   if (ratio < 2 || ratio > 3)
     return false;
 
-  m_iWideNarrRatio = ratio;
+  wide_narr_ratio_ = ratio;
   return true;
 }
 
@@ -120,10 +120,10 @@
 }
 
 DataVector<uint8_t> CBC_OnedCodaBarWriter::Encode(const ByteString& contents) {
-  ByteString data = m_chStart + contents + m_chEnd;
-  m_iContentLen = data.GetLength();
+  ByteString data = ch_start_ + contents + ch_end_;
+  content_len_ = data.GetLength();
   DataVector<uint8_t> result(
-      Fx2DSizeOrDie(m_iWideNarrRatio * 7, data.GetLength()));
+      Fx2DSizeOrDie(wide_narr_ratio_ * 7, data.GetLength()));
   char ch;
   int32_t position = 0;
   for (size_t index = 0; index < data.GetLength(); index++) {
@@ -157,7 +157,7 @@
     while (bit < 7) {
       result[position] = color;
       position++;
-      if (((code >> (6 - bit)) & 1) == 0 || counter == m_iWideNarrRatio - 1) {
+      if (((code >> (6 - bit)) & 1) == 0 || counter == wide_narr_ratio_ - 1) {
         color = !color;
         bit++;
         counter = 0;
@@ -175,8 +175,8 @@
 }
 
 WideString CBC_OnedCodaBarWriter::encodedContents(WideStringView contents) {
-  WideString strStart(static_cast<wchar_t>(m_chStart));
-  WideString strEnd(static_cast<wchar_t>(m_chEnd));
+  WideString strStart(static_cast<wchar_t>(ch_start_));
+  WideString strEnd(static_cast<wchar_t>(ch_end_));
   return strStart + contents + strEnd;
 }
 
diff --git a/fxbarcode/oned/BC_OnedCodaBarWriter.h b/fxbarcode/oned/BC_OnedCodaBarWriter.h
index 32d2f59..ae24d35 100644
--- a/fxbarcode/oned/BC_OnedCodaBarWriter.h
+++ b/fxbarcode/oned/BC_OnedCodaBarWriter.h
@@ -33,9 +33,9 @@
   WideString encodedContents(WideStringView contents);
 
  private:
-  char m_chStart = 'A';
-  char m_chEnd = 'B';
-  int8_t m_iWideNarrRatio = 2;
+  char ch_start_ = 'A';
+  char ch_end_ = 'B';
+  int8_t wide_narr_ratio_ = 2;
 };
 
 #endif  // FXBARCODE_ONED_BC_ONEDCODABARWRITER_H_
diff --git a/fxbarcode/oned/BC_OnedCode128Writer.cpp b/fxbarcode/oned/BC_OnedCode128Writer.cpp
index a32ef6d..eaa74e2 100644
--- a/fxbarcode/oned/BC_OnedCode128Writer.cpp
+++ b/fxbarcode/oned/BC_OnedCode128Writer.cpp
@@ -86,9 +86,9 @@
 }  // namespace
 
 CBC_OnedCode128Writer::CBC_OnedCode128Writer(BC_TYPE type)
-    : m_codeFormat(type) {
-  DCHECK(m_codeFormat == BC_TYPE::kCode128B ||
-         m_codeFormat == BC_TYPE::kCode128C);
+    : code_format_(type) {
+  DCHECK(code_format_ == BC_TYPE::kCode128B ||
+         code_format_ == BC_TYPE::kCode128C);
 }
 
 CBC_OnedCode128Writer::~CBC_OnedCode128Writer() = default;
@@ -99,7 +99,7 @@
 }
 
 WideString CBC_OnedCode128Writer::FilterContents(WideStringView contents) {
-  const wchar_t limit = m_codeFormat == BC_TYPE::kCode128B ? 126 : 106;
+  const wchar_t limit = code_format_ == BC_TYPE::kCode128B ? 126 : 106;
 
   WideString filtered;
   filtered.Reserve(contents.GetLength());
@@ -116,7 +116,7 @@
 }
 
 void CBC_OnedCode128Writer::SetTextLocation(BC_TEXT_LOC location) {
-  m_locTextLoc = location;
+  loc_text_loc_ = location;
 }
 
 DataVector<uint8_t> CBC_OnedCode128Writer::Encode(const ByteString& contents) {
@@ -125,15 +125,16 @@
 
   std::vector<int32_t> patterns;
   int32_t checkSum = 0;
-  if (m_codeFormat == BC_TYPE::kCode128B)
+  if (code_format_ == BC_TYPE::kCode128B) {
     checkSum = Encode128B(contents, &patterns);
-  else
+  } else {
     checkSum = Encode128C(contents, &patterns);
+  }
 
   checkSum %= 103;
   patterns.push_back(checkSum);
   patterns.push_back(CODE_STOP);
-  m_iContentLen = contents.GetLength() + 3;
+  content_len_ = contents.GetLength() + 3;
   int32_t codeWidth = 0;
   for (const auto& patternIndex : patterns) {
     for (size_t i = 0; i < kPatternSize; ++i)
diff --git a/fxbarcode/oned/BC_OnedCode128Writer.h b/fxbarcode/oned/BC_OnedCode128Writer.h
index 121c02b..3ef4d63 100644
--- a/fxbarcode/oned/BC_OnedCode128Writer.h
+++ b/fxbarcode/oned/BC_OnedCode128Writer.h
@@ -32,10 +32,10 @@
   WideString FilterContents(WideStringView contents) override;
   void SetTextLocation(BC_TEXT_LOC location) override;
 
-  BC_TYPE GetType() const { return m_codeFormat; }
+  BC_TYPE GetType() const { return code_format_; }
 
  private:
-  const BC_TYPE m_codeFormat;
+  const BC_TYPE code_format_;
 };
 
 #endif  // FXBARCODE_ONED_BC_ONEDCODE128WRITER_H_
diff --git a/fxbarcode/oned/BC_OnedCode39Writer.cpp b/fxbarcode/oned/BC_OnedCode39Writer.cpp
index 1973f6b..575c01d 100644
--- a/fxbarcode/oned/BC_OnedCode39Writer.cpp
+++ b/fxbarcode/oned/BC_OnedCode39Writer.cpp
@@ -135,14 +135,14 @@
 }
 
 void CBC_OnedCode39Writer::SetTextLocation(BC_TEXT_LOC location) {
-  m_locTextLoc = location;
+  loc_text_loc_ = location;
 }
 
 bool CBC_OnedCode39Writer::SetWideNarrowRatio(int8_t ratio) {
   if (ratio < 2 || ratio > 3)
     return false;
 
-  m_iWideNarrRatio = ratio;
+  wide_narr_ratio_ = ratio;
   return true;
 }
 
@@ -155,41 +155,42 @@
   static constexpr int32_t kWideStrideNum = 3;
   static constexpr int32_t kNarrowStrideNum = kArraySize - kWideStrideNum;
   ByteString encodedContents = contents;
-  if (m_bCalcChecksum)
+  if (calc_checksum_) {
     encodedContents += checksum;
-  m_iContentLen = encodedContents.GetLength();
+  }
+  content_len_ = encodedContents.GetLength();
   size_t code_width =
-      (kWideStrideNum * m_iWideNarrRatio + kNarrowStrideNum) * 2 + 1 +
-      m_iContentLen;
-  for (size_t j = 0; j < m_iContentLen; j++) {
+      (kWideStrideNum * wide_narr_ratio_ + kNarrowStrideNum) * 2 + 1 +
+      content_len_;
+  for (size_t j = 0; j < content_len_; j++) {
     for (size_t i = 0; i < kOnedCode39AlphabetLen; i++) {
       if (kOnedCode39Alphabet[i] != encodedContents[j]) {
         continue;
       }
-      ToIntArray(kOnedCode39CharacterEncoding[i], m_iWideNarrRatio, widths);
+      ToIntArray(kOnedCode39CharacterEncoding[i], wide_narr_ratio_, widths);
       for (size_t k = 0; k < kArraySize; k++)
         code_width += widths[k];
     }
   }
   DataVector<uint8_t> result(code_width);
   auto result_span = pdfium::make_span(result);
-  ToIntArray(kOnedCode39CharacterEncoding[39], m_iWideNarrRatio, widths);
+  ToIntArray(kOnedCode39CharacterEncoding[39], wide_narr_ratio_, widths);
   result_span = AppendPattern(result_span, widths, true);
 
   static constexpr uint8_t kNarrowWhite[] = {1};
   result_span = AppendPattern(result_span, kNarrowWhite, false);
 
-  for (int32_t l = m_iContentLen - 1; l >= 0; l--) {
+  for (int32_t l = content_len_ - 1; l >= 0; l--) {
     for (size_t i = 0; i < kOnedCode39AlphabetLen; i++) {
       if (kOnedCode39Alphabet[i] != encodedContents[l]) {
         continue;
       }
-      ToIntArray(kOnedCode39CharacterEncoding[i], m_iWideNarrRatio, widths);
+      ToIntArray(kOnedCode39CharacterEncoding[i], wide_narr_ratio_, widths);
       result_span = AppendPattern(result_span, widths, true);
     }
     result_span = AppendPattern(result_span, kNarrowWhite, false);
   }
-  ToIntArray(kOnedCode39CharacterEncoding[39], m_iWideNarrRatio, widths);
+  ToIntArray(kOnedCode39CharacterEncoding[39], wide_narr_ratio_, widths);
   AppendPattern(result_span, widths, true);
 
   for (size_t i = 0; i < code_width / 2; i++) {
@@ -203,7 +204,7 @@
 bool CBC_OnedCode39Writer::encodedContents(WideStringView contents,
                                            WideString* result) {
   *result = WideString(contents);
-  if (m_bCalcChecksum && m_bPrintChecksum) {
+  if (calc_checksum_ && print_checksum_) {
     WideString checksumContent = FilterContents(contents);
     ByteString str = checksumContent.ToUTF8();
     char checksum;
diff --git a/fxbarcode/oned/BC_OnedCode39Writer.h b/fxbarcode/oned/BC_OnedCode39Writer.h
index 55ac3f1..d2819e7 100644
--- a/fxbarcode/oned/BC_OnedCode39Writer.h
+++ b/fxbarcode/oned/BC_OnedCode39Writer.h
@@ -32,7 +32,7 @@
  private:
   static constexpr size_t kArraySize = 9;
 
-  int8_t m_iWideNarrRatio = 3;
+  int8_t wide_narr_ratio_ = 3;
 };
 
 #endif  // FXBARCODE_ONED_BC_ONEDCODE39WRITER_H_
diff --git a/fxbarcode/oned/BC_OnedEAN13Writer.cpp b/fxbarcode/oned/BC_OnedEAN13Writer.cpp
index 0da74f1..8410f4c 100644
--- a/fxbarcode/oned/BC_OnedEAN13Writer.cpp
+++ b/fxbarcode/oned/BC_OnedEAN13Writer.cpp
@@ -67,8 +67,8 @@
 }  // namespace
 
 CBC_OnedEAN13Writer::CBC_OnedEAN13Writer() {
-  m_bLeftPadding = true;
-  m_codeWidth = 3 + (7 * 6) + 5 + (7 * 6) + 3;
+  left_padding_ = true;
+  code_width_ = 3 + (7 * 6) + 5 + (7 * 6) + 3;
 }
 CBC_OnedEAN13Writer::~CBC_OnedEAN13Writer() = default;
 
@@ -102,10 +102,10 @@
   if (contents.GetLength() != 13)
     return DataVector<uint8_t>();
 
-  m_iDataLenth = 13;
+  data_length_ = 13;
   int32_t firstDigit = FXSYS_DecimalCharToInt(contents.Front());
   int32_t parities = kFirstDigitEncodings[firstDigit];
-  DataVector<uint8_t> result(m_codeWidth);
+  DataVector<uint8_t> result(code_width_);
   auto result_span = pdfium::make_span(result);
   result_span = AppendPattern(result_span, kOnedEAN13StartPattern, true);
 
@@ -139,71 +139,71 @@
   ByteString str = FX_UTF8Encode(contents);
   size_t length = str.GetLength();
   std::vector<TextCharPos> charpos(length);
-  int32_t iFontSize = static_cast<int32_t>(fabs(m_fFontSize));
+  int32_t iFontSize = static_cast<int32_t>(fabs(font_size_));
   int32_t iTextHeight = iFontSize + 1;
   ByteString tempStr = str.Substr(1, 6);
   static constexpr int32_t kWidth = 42;
 
-  CFX_Matrix matr(m_outputHScale, 0.0, 0.0, 1.0, 0.0, 0.0);
-  CFX_FloatRect rect(kLeftPosition, (float)(m_Height - iTextHeight),
-                     kLeftPosition + kWidth - 0.5, (float)m_Height);
+  CFX_Matrix matr(output_hscale_, 0.0, 0.0, 1.0, 0.0, 0.0);
+  CFX_FloatRect rect(kLeftPosition, (float)(height_ - iTextHeight),
+                     kLeftPosition + kWidth - 0.5, (float)height_);
   matr.Concat(matrix);
   FX_RECT re = matr.TransformRect(rect).GetOuterRect();
   device->FillRect(re, kBackgroundColor);
-  CFX_FloatRect rect1(kLeftPosition + 47, (float)(m_Height - iTextHeight),
-                      kLeftPosition + 47 + kWidth - 0.5, (float)m_Height);
-  CFX_Matrix matr1(m_outputHScale, 0.0, 0.0, 1.0, 0.0, 0.0);
+  CFX_FloatRect rect1(kLeftPosition + 47, (float)(height_ - iTextHeight),
+                      kLeftPosition + 47 + kWidth - 0.5, (float)height_);
+  CFX_Matrix matr1(output_hscale_, 0.0, 0.0, 1.0, 0.0, 0.0);
   matr1.Concat(matrix);
   re = matr1.TransformRect(rect1).GetOuterRect();
   device->FillRect(re, kBackgroundColor);
-  CFX_Matrix matr2(m_outputHScale, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
-  CFX_FloatRect rect2(0.0f, (float)(m_Height - iTextHeight), 6.5f,
-                      (float)m_Height);
+  CFX_Matrix matr2(output_hscale_, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
+  CFX_FloatRect rect2(0.0f, (float)(height_ - iTextHeight), 6.5f,
+                      (float)height_);
   matr2.Concat(matrix);
   re = matr2.TransformRect(rect2).GetOuterRect();
   device->FillRect(re, kBackgroundColor);
 
   float blank = 0.0f;
   length = tempStr.GetLength();
-  int32_t strWidth = static_cast<int32_t>(kWidth * m_outputHScale);
+  int32_t strWidth = static_cast<int32_t>(kWidth * output_hscale_);
 
   pdfium::span<TextCharPos> charpos_span = pdfium::make_span(charpos);
-  CalcTextInfo(tempStr, charpos_span.subspan(1), m_pFont, (float)strWidth,
+  CalcTextInfo(tempStr, charpos_span.subspan(1), font_, (float)strWidth,
                iFontSize, blank);
   {
     CFX_Matrix affine_matrix1(1.0, 0.0, 0.0, -1.0,
-                              kLeftPosition * m_outputHScale,
-                              (float)(m_Height - iTextHeight) + iFontSize);
+                              kLeftPosition * output_hscale_,
+                              (float)(height_ - iTextHeight) + iFontSize);
     affine_matrix1.Concat(matrix);
-    device->DrawNormalText(charpos_span.subspan(1, length), m_pFont,
+    device->DrawNormalText(charpos_span.subspan(1, length), font_,
                            static_cast<float>(iFontSize), affine_matrix1,
-                           m_fontColor, GetTextRenderOptions());
+                           font_color_, GetTextRenderOptions());
   }
   tempStr = str.Substr(7, 6);
   length = tempStr.GetLength();
-  CalcTextInfo(tempStr, charpos_span.subspan(7), m_pFont, (float)strWidth,
+  CalcTextInfo(tempStr, charpos_span.subspan(7), font_, (float)strWidth,
                iFontSize, blank);
   {
     CFX_Matrix affine_matrix1(1.0, 0.0, 0.0, -1.0,
-                              (kLeftPosition + 47) * m_outputHScale,
-                              (float)(m_Height - iTextHeight + iFontSize));
+                              (kLeftPosition + 47) * output_hscale_,
+                              (float)(height_ - iTextHeight + iFontSize));
     affine_matrix1.Concat(matrix);
-    device->DrawNormalText(charpos_span.subspan(7, length), m_pFont,
+    device->DrawNormalText(charpos_span.subspan(7, length), font_,
                            static_cast<float>(iFontSize), affine_matrix1,
-                           m_fontColor, GetTextRenderOptions());
+                           font_color_, GetTextRenderOptions());
   }
   tempStr = str.First(1);
   length = tempStr.GetLength();
-  strWidth = 7 * static_cast<int32_t>(strWidth * m_outputHScale);
+  strWidth = 7 * static_cast<int32_t>(strWidth * output_hscale_);
 
-  CalcTextInfo(tempStr, charpos, m_pFont, (float)strWidth, iFontSize, blank);
+  CalcTextInfo(tempStr, charpos, font_, (float)strWidth, iFontSize, blank);
   {
     CFX_Matrix affine_matrix1(1.0, 0.0, 0.0, -1.0, 0.0,
-                              (float)(m_Height - iTextHeight + iFontSize));
+                              (float)(height_ - iTextHeight + iFontSize));
     affine_matrix1.Concat(matrix);
-    device->DrawNormalText(charpos_span.first(length), m_pFont,
+    device->DrawNormalText(charpos_span.first(length), font_,
                            static_cast<float>(iFontSize), affine_matrix1,
-                           m_fontColor, GetTextRenderOptions());
+                           font_color_, GetTextRenderOptions());
   }
   return true;
 }
diff --git a/fxbarcode/oned/BC_OnedEAN13Writer.h b/fxbarcode/oned/BC_OnedEAN13Writer.h
index 8c7ff1c..fbf1941 100644
--- a/fxbarcode/oned/BC_OnedEAN13Writer.h
+++ b/fxbarcode/oned/BC_OnedEAN13Writer.h
@@ -32,7 +32,7 @@
                  const CFX_Matrix& matrix,
                  int32_t barWidth) override;
 
-  int32_t m_codeWidth;
+  int32_t code_width_;
 };
 
 #endif  // FXBARCODE_ONED_BC_ONEDEAN13WRITER_H_
diff --git a/fxbarcode/oned/BC_OnedEAN8Writer.cpp b/fxbarcode/oned/BC_OnedEAN8Writer.cpp
index 6b1445f..e452bd2 100644
--- a/fxbarcode/oned/BC_OnedEAN8Writer.cpp
+++ b/fxbarcode/oned/BC_OnedEAN8Writer.cpp
@@ -57,18 +57,18 @@
 }  // namespace
 
 CBC_OnedEAN8Writer::CBC_OnedEAN8Writer() {
-  m_iDataLenth = 8;
+  data_length_ = 8;
 }
 
 CBC_OnedEAN8Writer::~CBC_OnedEAN8Writer() = default;
 
 void CBC_OnedEAN8Writer::SetDataLength(int32_t length) {
-  m_iDataLenth = 8;
+  data_length_ = 8;
 }
 
 void CBC_OnedEAN8Writer::SetTextLocation(BC_TEXT_LOC location) {
   if (location == BC_TEXT_LOC::kBelowEmbed)
-    m_locTextLoc = location;
+    loc_text_loc_ = location;
 }
 
 bool CBC_OnedEAN8Writer::CheckContentValidity(WideStringView contents) {
@@ -101,7 +101,7 @@
   if (contents.GetLength() != 8)
     return {};
 
-  DataVector<uint8_t> result(m_codeWidth);
+  DataVector<uint8_t> result(code_width_);
   auto result_span = pdfium::make_span(result);
   result_span = AppendPattern(result_span, kOnedEAN8StartPattern, true);
 
@@ -137,46 +137,46 @@
   static constexpr int32_t kWidth = 28;
   float blank = 0.0f;
 
-  int32_t iFontSize = static_cast<int32_t>(fabs(m_fFontSize));
+  int32_t iFontSize = static_cast<int32_t>(fabs(font_size_));
   int32_t iTextHeight = iFontSize + 1;
 
-  CFX_Matrix matr(m_outputHScale, 0.0, 0.0, 1.0, 0.0, 0.0);
-  CFX_FloatRect rect(kLeftPosition, (float)(m_Height - iTextHeight),
-                     kLeftPosition + kWidth - 0.5, (float)m_Height);
+  CFX_Matrix matr(output_hscale_, 0.0, 0.0, 1.0, 0.0, 0.0);
+  CFX_FloatRect rect(kLeftPosition, (float)(height_ - iTextHeight),
+                     kLeftPosition + kWidth - 0.5, (float)height_);
   matr.Concat(matrix);
   FX_RECT re = matr.TransformRect(rect).GetOuterRect();
   device->FillRect(re, kBackgroundColor);
-  CFX_Matrix matr1(m_outputHScale, 0.0, 0.0, 1.0, 0.0, 0.0);
-  CFX_FloatRect rect1(kLeftPosition + 33, (float)(m_Height - iTextHeight),
-                      kLeftPosition + 33 + kWidth - 0.5, (float)m_Height);
+  CFX_Matrix matr1(output_hscale_, 0.0, 0.0, 1.0, 0.0, 0.0);
+  CFX_FloatRect rect1(kLeftPosition + 33, (float)(height_ - iTextHeight),
+                      kLeftPosition + 33 + kWidth - 0.5, (float)height_);
   matr1.Concat(matrix);
   re = matr1.TransformRect(rect1).GetOuterRect();
   device->FillRect(re, kBackgroundColor);
-  int32_t strWidth = static_cast<int32_t>(kWidth * m_outputHScale);
+  int32_t strWidth = static_cast<int32_t>(kWidth * output_hscale_);
 
   pdfium::span<TextCharPos> charpos_span = pdfium::make_span(charpos);
-  CalcTextInfo(tempStr, charpos, m_pFont, (float)strWidth, iFontSize, blank);
+  CalcTextInfo(tempStr, charpos, font_, (float)strWidth, iFontSize, blank);
   {
     CFX_Matrix affine_matrix1(1.0, 0.0, 0.0, -1.0,
-                              kLeftPosition * m_outputHScale,
-                              (float)(m_Height - iTextHeight + iFontSize));
+                              kLeftPosition * output_hscale_,
+                              (float)(height_ - iTextHeight + iFontSize));
     affine_matrix1.Concat(matrix);
-    device->DrawNormalText(charpos_span.first(iLen), m_pFont,
+    device->DrawNormalText(charpos_span.first(iLen), font_,
                            static_cast<float>(iFontSize), affine_matrix1,
-                           m_fontColor, GetTextRenderOptions());
+                           font_color_, GetTextRenderOptions());
   }
   tempStr = str.Substr(4, 4);
   iLen = tempStr.GetLength();
-  CalcTextInfo(tempStr, charpos_span.subspan(4), m_pFont, (float)strWidth,
+  CalcTextInfo(tempStr, charpos_span.subspan(4), font_, (float)strWidth,
                iFontSize, blank);
   {
     CFX_Matrix affine_matrix1(1.0, 0.0, 0.0, -1.0,
-                              (kLeftPosition + 33) * m_outputHScale,
-                              (float)(m_Height - iTextHeight + iFontSize));
+                              (kLeftPosition + 33) * output_hscale_,
+                              (float)(height_ - iTextHeight + iFontSize));
     affine_matrix1.Concat(matrix);
-    device->DrawNormalText(charpos_span.subspan(4, iLen), m_pFont,
+    device->DrawNormalText(charpos_span.subspan(4, iLen), font_,
                            static_cast<float>(iFontSize), affine_matrix1,
-                           m_fontColor, GetTextRenderOptions());
+                           font_color_, GetTextRenderOptions());
   }
   return true;
 }
diff --git a/fxbarcode/oned/BC_OnedEAN8Writer.h b/fxbarcode/oned/BC_OnedEAN8Writer.h
index 3f633e6..98c113b 100644
--- a/fxbarcode/oned/BC_OnedEAN8Writer.h
+++ b/fxbarcode/oned/BC_OnedEAN8Writer.h
@@ -36,7 +36,7 @@
                  int32_t barWidth) override;
 
   static constexpr int32_t kDefaultCodeWidth = 3 + (7 * 4) + 5 + (7 * 4) + 3;
-  int32_t m_codeWidth = kDefaultCodeWidth;
+  int32_t code_width_ = kDefaultCodeWidth;
 };
 
 #endif  // FXBARCODE_ONED_BC_ONEDEAN8WRITER_H_
diff --git a/fxbarcode/oned/BC_OnedUPCAWriter.cpp b/fxbarcode/oned/BC_OnedUPCAWriter.cpp
index d9539a1..d597409 100644
--- a/fxbarcode/oned/BC_OnedUPCAWriter.cpp
+++ b/fxbarcode/oned/BC_OnedUPCAWriter.cpp
@@ -35,8 +35,8 @@
 #include "fxbarcode/oned/BC_OnedEAN13Writer.h"
 
 CBC_OnedUPCAWriter::CBC_OnedUPCAWriter() {
-  m_bLeftPadding = true;
-  m_bRightPadding = true;
+  left_padding_ = true;
+  right_padding_ = true;
 }
 
 CBC_OnedUPCAWriter::~CBC_OnedUPCAWriter() = default;
@@ -64,7 +64,7 @@
 }
 
 void CBC_OnedUPCAWriter::InitEANWriter() {
-  m_subWriter = std::make_unique<CBC_OnedEAN13Writer>();
+  sub_writer_ = std::make_unique<CBC_OnedEAN13Writer>();
 }
 
 int32_t CBC_OnedUPCAWriter::CalcChecksum(const ByteString& contents) {
@@ -86,8 +86,8 @@
 
 DataVector<uint8_t> CBC_OnedUPCAWriter::Encode(const ByteString& contents) {
   ByteString toEAN13String = '0' + contents;
-  m_iDataLenth = 13;
-  return m_subWriter->Encode(toEAN13String);
+  data_length_ = 13;
+  return sub_writer_->Encode(toEAN13String);
 }
 
 bool CBC_OnedUPCAWriter::ShowChars(WideStringView contents,
@@ -106,86 +106,86 @@
   float blank = 0.0f;
 
   length = tempStr.GetLength();
-  int32_t iFontSize = static_cast<int32_t>(fabs(m_fFontSize));
+  int32_t iFontSize = static_cast<int32_t>(fabs(font_size_));
   int32_t iTextHeight = iFontSize + 1;
 
-  CFX_Matrix matr(m_outputHScale, 0.0, 0.0, 1.0, 0.0, 0.0);
-  CFX_FloatRect rect(kLeftPosition, (float)(m_Height - iTextHeight),
-                     kLeftPosition + kWidth - 0.5, (float)m_Height);
+  CFX_Matrix matr(output_hscale_, 0.0, 0.0, 1.0, 0.0, 0.0);
+  CFX_FloatRect rect(kLeftPosition, (float)(height_ - iTextHeight),
+                     kLeftPosition + kWidth - 0.5, (float)height_);
   matr.Concat(matrix);
   FX_RECT re = matr.TransformRect(rect).GetOuterRect();
   device->FillRect(re, kBackgroundColor);
-  CFX_Matrix matr1(m_outputHScale, 0.0, 0.0, 1.0, 0.0, 0.0);
-  CFX_FloatRect rect1(kLeftPosition + 40, (float)(m_Height - iTextHeight),
-                      kLeftPosition + 40 + kWidth - 0.5, (float)m_Height);
+  CFX_Matrix matr1(output_hscale_, 0.0, 0.0, 1.0, 0.0, 0.0);
+  CFX_FloatRect rect1(kLeftPosition + 40, (float)(height_ - iTextHeight),
+                      kLeftPosition + 40 + kWidth - 0.5, (float)height_);
   matr1.Concat(matrix);
   re = matr1.TransformRect(rect1).GetOuterRect();
   device->FillRect(re, kBackgroundColor);
   static constexpr float kWidth1 = 7.0f;
-  CFX_Matrix matr2(m_outputHScale, 0.0, 0.0, 1.0, 0.0, 0.0);
-  CFX_FloatRect rect2(0.0, (float)(m_Height - iTextHeight), kWidth1 - 1,
-                      (float)m_Height);
+  CFX_Matrix matr2(output_hscale_, 0.0, 0.0, 1.0, 0.0, 0.0);
+  CFX_FloatRect rect2(0.0, (float)(height_ - iTextHeight), kWidth1 - 1,
+                      (float)height_);
   matr2.Concat(matrix);
   re = matr2.TransformRect(rect2).GetOuterRect();
   device->FillRect(re, kBackgroundColor);
-  CFX_Matrix matr3(m_outputHScale, 0.0, 0.0, 1.0, 0.0, 0.0);
-  CFX_FloatRect rect3(kLeftPosition + 85, (float)(m_Height - iTextHeight),
-                      kLeftPosition + 85 + kWidth1 - 0.5, (float)m_Height);
+  CFX_Matrix matr3(output_hscale_, 0.0, 0.0, 1.0, 0.0, 0.0);
+  CFX_FloatRect rect3(kLeftPosition + 85, (float)(height_ - iTextHeight),
+                      kLeftPosition + 85 + kWidth1 - 0.5, (float)height_);
   matr3.Concat(matrix);
   re = matr3.TransformRect(rect3).GetOuterRect();
   device->FillRect(re, kBackgroundColor);
-  float strWidth = kWidth * m_outputHScale;
+  float strWidth = kWidth * output_hscale_;
 
   pdfium::span<TextCharPos> charpos_span = pdfium::make_span(charpos);
-  CalcTextInfo(tempStr, charpos_span.subspan(1), m_pFont, strWidth, iFontSize,
+  CalcTextInfo(tempStr, charpos_span.subspan(1), font_, strWidth, iFontSize,
                blank);
   {
     CFX_Matrix affine_matrix1(1.0, 0.0, 0.0, -1.0,
-                              kLeftPosition * m_outputHScale,
-                              (float)(m_Height - iTextHeight + iFontSize));
+                              kLeftPosition * output_hscale_,
+                              (float)(height_ - iTextHeight + iFontSize));
     affine_matrix1.Concat(matrix);
-    device->DrawNormalText(charpos_span.subspan(1, length), m_pFont,
+    device->DrawNormalText(charpos_span.subspan(1, length), font_,
                            static_cast<float>(iFontSize), affine_matrix1,
-                           m_fontColor, GetTextRenderOptions());
+                           font_color_, GetTextRenderOptions());
   }
   tempStr = str.Substr(6, 5);
   length = tempStr.GetLength();
-  CalcTextInfo(tempStr, charpos_span.subspan(6), m_pFont, strWidth, iFontSize,
+  CalcTextInfo(tempStr, charpos_span.subspan(6), font_, strWidth, iFontSize,
                blank);
   {
     CFX_Matrix affine_matrix1(1.0, 0.0, 0.0, -1.0,
-                              (kLeftPosition + 40) * m_outputHScale,
-                              (float)(m_Height - iTextHeight + iFontSize));
+                              (kLeftPosition + 40) * output_hscale_,
+                              (float)(height_ - iTextHeight + iFontSize));
     affine_matrix1.Concat(matrix);
-    device->DrawNormalText(charpos_span.subspan(6, length), m_pFont,
+    device->DrawNormalText(charpos_span.subspan(6, length), font_,
                            static_cast<float>(iFontSize), affine_matrix1,
-                           m_fontColor, GetTextRenderOptions());
+                           font_color_, GetTextRenderOptions());
   }
   tempStr = str.First(1);
   length = tempStr.GetLength();
-  strWidth = 7 * m_outputHScale;
+  strWidth = 7 * output_hscale_;
 
-  CalcTextInfo(tempStr, charpos, m_pFont, strWidth, iFontSize, blank);
+  CalcTextInfo(tempStr, charpos, font_, strWidth, iFontSize, blank);
   {
     CFX_Matrix affine_matrix1(1.0, 0.0, 0.0, -1.0, 0,
-                              (float)(m_Height - iTextHeight + iFontSize));
+                              (float)(height_ - iTextHeight + iFontSize));
     affine_matrix1.Concat(matrix);
-    device->DrawNormalText(charpos_span.first(length), m_pFont,
+    device->DrawNormalText(charpos_span.first(length), font_,
                            static_cast<float>(iFontSize), affine_matrix1,
-                           m_fontColor, GetTextRenderOptions());
+                           font_color_, GetTextRenderOptions());
   }
   tempStr = str.Substr(11, 1);
   length = tempStr.GetLength();
-  CalcTextInfo(tempStr, charpos_span.subspan(11), m_pFont, strWidth, iFontSize,
+  CalcTextInfo(tempStr, charpos_span.subspan(11), font_, strWidth, iFontSize,
                blank);
   {
     CFX_Matrix affine_matrix1(1.0, 0.0, 0.0, -1.0,
-                              (kLeftPosition + 85) * m_outputHScale,
-                              (float)(m_Height - iTextHeight + iFontSize));
+                              (kLeftPosition + 85) * output_hscale_,
+                              (float)(height_ - iTextHeight + iFontSize));
     affine_matrix1.Concat(matrix);
-    device->DrawNormalText(charpos_span.subspan(11, length), m_pFont,
+    device->DrawNormalText(charpos_span.subspan(11, length), font_,
                            static_cast<float>(iFontSize), affine_matrix1,
-                           m_fontColor, GetTextRenderOptions());
+                           font_color_, GetTextRenderOptions());
   }
   return true;
 }
diff --git a/fxbarcode/oned/BC_OnedUPCAWriter.h b/fxbarcode/oned/BC_OnedUPCAWriter.h
index 7d8beff..501e296 100644
--- a/fxbarcode/oned/BC_OnedUPCAWriter.h
+++ b/fxbarcode/oned/BC_OnedUPCAWriter.h
@@ -35,7 +35,7 @@
                  const CFX_Matrix& matrix,
                  int32_t barWidth) override;
 
-  std::unique_ptr<CBC_OnedEAN13Writer> m_subWriter;
+  std::unique_ptr<CBC_OnedEAN13Writer> sub_writer_;
 };
 
 #endif  // FXBARCODE_ONED_BC_ONEDUPCAWRITER_H_
diff --git a/fxbarcode/pdf417/BC_PDF417.cpp b/fxbarcode/pdf417/BC_PDF417.cpp
index 257268f..91c2726 100644
--- a/fxbarcode/pdf417/BC_PDF417.cpp
+++ b/fxbarcode/pdf417/BC_PDF417.cpp
@@ -361,7 +361,7 @@
 CBC_PDF417::~CBC_PDF417() = default;
 
 CBC_BarcodeMatrix* CBC_PDF417::getBarcodeMatrix() {
-  return m_barcodeMatrix.get();
+  return barcode_matrix_.get();
 }
 
 bool CBC_PDF417::GenerateBarcodeLogic(WideStringView msg,
@@ -409,9 +409,9 @@
     return false;
 
   WideString fullCodewords = dataCodewords + ec.value();
-  m_barcodeMatrix = std::make_unique<CBC_BarcodeMatrix>(cols, rows);
+  barcode_matrix_ = std::make_unique<CBC_BarcodeMatrix>(cols, rows);
   encodeLowLevel(fullCodewords, cols, rows, errorCorrectionLevel,
-                 m_barcodeMatrix.get());
+                 barcode_matrix_.get());
   return true;
 }
 
@@ -419,10 +419,10 @@
                                int32_t minCols,
                                int32_t maxRows,
                                int32_t minRows) {
-  m_maxCols = maxCols;
-  m_minCols = minCols;
-  m_maxRows = maxRows;
-  m_minRows = minRows;
+  max_cols_ = maxCols;
+  min_cols_ = minCols;
+  max_rows_ = maxRows;
+  min_rows_ = minRows;
 }
 
 int32_t CBC_PDF417::calculateNumberOfRows(int32_t m, int32_t k, int32_t c) {
@@ -501,13 +501,15 @@
     int32_t errorCorrectionCodeWords) const {
   std::vector<int32_t> dimensions;
   float ratio = 0.0f;
-  for (int32_t cols = m_minCols; cols <= m_maxCols; cols++) {
+  for (int32_t cols = min_cols_; cols <= max_cols_; cols++) {
     int32_t rows =
         calculateNumberOfRows(sourceCodeWords, errorCorrectionCodeWords, cols);
-    if (rows < m_minRows)
+    if (rows < min_rows_) {
       break;
-    if (rows > m_maxRows)
+    }
+    if (rows > max_rows_) {
       continue;
+    }
     float newRatio =
         ((17 * cols + 69) * DEFAULT_MODULE_WIDTH) / (rows * HEIGHT);
     if (!dimensions.empty() &&
@@ -521,14 +523,14 @@
   }
   if (dimensions.empty()) {
     int32_t rows = calculateNumberOfRows(sourceCodeWords,
-                                         errorCorrectionCodeWords, m_maxCols);
-    if (rows < m_minRows) {
+                                         errorCorrectionCodeWords, max_cols_);
+    if (rows < min_rows_) {
       dimensions.resize(2);
-      dimensions[0] = m_maxCols;
-      dimensions[1] = m_minRows;
+      dimensions[0] = max_cols_;
+      dimensions[1] = min_rows_;
     } else if (rows >= 3 && rows <= 90) {
       dimensions.resize(2);
-      dimensions[0] = m_maxCols;
+      dimensions[0] = max_cols_;
       dimensions[1] = rows;
     }
   }
diff --git a/fxbarcode/pdf417/BC_PDF417.h b/fxbarcode/pdf417/BC_PDF417.h
index 0312deb..7ce69c6 100644
--- a/fxbarcode/pdf417/BC_PDF417.h
+++ b/fxbarcode/pdf417/BC_PDF417.h
@@ -49,11 +49,11 @@
       size_t sourceCodeWords,
       int32_t errorCorrectionCodeWords) const;
 
-  std::unique_ptr<CBC_BarcodeMatrix> m_barcodeMatrix;
-  int32_t m_minCols = 1;
-  int32_t m_maxCols = 30;
-  int32_t m_minRows = 3;
-  int32_t m_maxRows = 90;
+  std::unique_ptr<CBC_BarcodeMatrix> barcode_matrix_;
+  int32_t min_cols_ = 1;
+  int32_t max_cols_ = 30;
+  int32_t min_rows_ = 3;
+  int32_t max_rows_ = 90;
 };
 
 #endif  // FXBARCODE_PDF417_BC_PDF417_H_
diff --git a/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp b/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp
index c0d52c6..10bcc22 100644
--- a/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp
+++ b/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp
@@ -29,19 +29,20 @@
 #include "fxbarcode/pdf417/BC_PDF417BarcodeRow.h"
 
 CBC_BarcodeMatrix::CBC_BarcodeMatrix(size_t width, size_t height)
-    : m_width((width + 4) * 17 + 1), m_height(height) {
-  m_matrix.resize(m_height);
-  for (size_t i = 0; i < m_height; ++i)
-    m_matrix[i] = std::make_unique<CBC_BarcodeRow>(m_width);
+    : width_((width + 4) * 17 + 1), height_(height) {
+  matrix_.resize(height_);
+  for (size_t i = 0; i < height_; ++i) {
+    matrix_[i] = std::make_unique<CBC_BarcodeRow>(width_);
+  }
 }
 
 CBC_BarcodeMatrix::~CBC_BarcodeMatrix() = default;
 
 DataVector<uint8_t> CBC_BarcodeMatrix::toBitArray() {
-  DataVector<uint8_t> bit_array(m_width * m_height);
+  DataVector<uint8_t> bit_array(width_ * height_);
   pdfium::span<uint8_t> bit_array_span(bit_array);
-  for (size_t i = 0; i < m_height; ++i) {
-    fxcrt::Copy(m_matrix[i]->GetRow(), bit_array_span.subspan(i * m_width));
+  for (size_t i = 0; i < height_; ++i) {
+    fxcrt::Copy(matrix_[i]->GetRow(), bit_array_span.subspan(i * width_));
   }
   return bit_array;
 }
diff --git a/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h b/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h
index 2ed8834..316365e 100644
--- a/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h
+++ b/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h
@@ -21,15 +21,15 @@
   CBC_BarcodeMatrix(size_t width, size_t height);
   ~CBC_BarcodeMatrix();
 
-  CBC_BarcodeRow* getRow(size_t row) const { return m_matrix[row].get(); }
-  size_t getWidth() const { return m_width; }
-  size_t getHeight() const { return m_height; }
+  CBC_BarcodeRow* getRow(size_t row) const { return matrix_[row].get(); }
+  size_t getWidth() const { return width_; }
+  size_t getHeight() const { return height_; }
   DataVector<uint8_t> toBitArray();
 
  private:
-  std::vector<std::unique_ptr<CBC_BarcodeRow>> m_matrix;
-  size_t m_width;
-  size_t m_height;
+  std::vector<std::unique_ptr<CBC_BarcodeRow>> matrix_;
+  size_t width_;
+  size_t height_;
 };
 
 #endif  // FXBARCODE_PDF417_BC_PDF417BARCODEMATRIX_H_
diff --git a/fxbarcode/pdf417/BC_PDF417Writer.cpp b/fxbarcode/pdf417/BC_PDF417Writer.cpp
index 9526d55..3734e18 100644
--- a/fxbarcode/pdf417/BC_PDF417Writer.cpp
+++ b/fxbarcode/pdf417/BC_PDF417Writer.cpp
@@ -62,8 +62,8 @@
 CBC_PDF417Writer::EncodeResult CBC_PDF417Writer::Encode(
     WideStringView contents) const {
   CBC_PDF417 encoder;
-  int32_t col = (m_Width / m_ModuleWidth - 69) / 17;
-  int32_t row = m_Height / (m_ModuleWidth * 20);
+  int32_t col = (width_ / module_width_ - 69) / 17;
+  int32_t row = height_ / (module_width_ * 20);
   if (row >= 3 && row <= 90 && col >= 1 && col <= 30)
     encoder.setDimensions(col, 1, row, 3);
   else if (col >= 1 && col <= 30)
diff --git a/fxbarcode/qrcode/BC_QRCoder.cpp b/fxbarcode/qrcode/BC_QRCoder.cpp
index f08d253..39ea291 100644
--- a/fxbarcode/qrcode/BC_QRCoder.cpp
+++ b/fxbarcode/qrcode/BC_QRCoder.cpp
@@ -33,77 +33,77 @@
 CBC_QRCoder::~CBC_QRCoder() = default;
 
 const CBC_QRCoderErrorCorrectionLevel* CBC_QRCoder::GetECLevel() const {
-  return m_ecLevel;
+  return ec_level_;
 }
 
 int32_t CBC_QRCoder::GetVersion() const {
-  return m_version;
+  return version_;
 }
 
 int32_t CBC_QRCoder::GetMatrixWidth() const {
-  return m_matrixWidth;
+  return matrix_width_;
 }
 
 int32_t CBC_QRCoder::GetMaskPattern() const {
-  return m_maskPattern;
+  return mask_pattern_;
 }
 
 int32_t CBC_QRCoder::GetNumTotalBytes() const {
-  return m_numTotalBytes;
+  return num_total_bytes_;
 }
 
 int32_t CBC_QRCoder::GetNumDataBytes() const {
-  return m_numDataBytes;
+  return num_data_bytes_;
 }
 
 int32_t CBC_QRCoder::GetNumRSBlocks() const {
-  return m_numRSBlocks;
+  return num_rsblocks_;
 }
 
 std::unique_ptr<CBC_CommonByteMatrix> CBC_QRCoder::TakeMatrix() {
-  return std::move(m_matrix);
+  return std::move(matrix_);
 }
 
 bool CBC_QRCoder::IsValid() const {
-  return m_ecLevel && m_version != -1 && m_matrixWidth != -1 &&
-         m_maskPattern != -1 && m_numTotalBytes != -1 && m_numDataBytes != -1 &&
-         m_numECBytes != -1 && m_numRSBlocks != -1 &&
-         IsValidMaskPattern(m_maskPattern) &&
-         m_numTotalBytes == m_numDataBytes + m_numECBytes && m_matrix &&
-         m_matrixWidth == pdfium::checked_cast<int32_t>(m_matrix->GetWidth()) &&
-         m_matrix->GetWidth() == m_matrix->GetHeight();
+  return ec_level_ && version_ != -1 && matrix_width_ != -1 &&
+         mask_pattern_ != -1 && num_total_bytes_ != -1 &&
+         num_data_bytes_ != -1 && num_ecbytes_ != -1 && num_rsblocks_ != -1 &&
+         IsValidMaskPattern(mask_pattern_) &&
+         num_total_bytes_ == num_data_bytes_ + num_ecbytes_ && matrix_ &&
+         matrix_width_ == pdfium::checked_cast<int32_t>(matrix_->GetWidth()) &&
+         matrix_->GetWidth() == matrix_->GetHeight();
 }
 
 void CBC_QRCoder::SetECLevel(const CBC_QRCoderErrorCorrectionLevel* ecLevel) {
-  m_ecLevel = ecLevel;
+  ec_level_ = ecLevel;
 }
 
 void CBC_QRCoder::SetVersion(int32_t version) {
-  m_version = version;
+  version_ = version;
 }
 
 void CBC_QRCoder::SetMatrixWidth(int32_t width) {
-  m_matrixWidth = width;
+  matrix_width_ = width;
 }
 
 void CBC_QRCoder::SetMaskPattern(int32_t pattern) {
-  m_maskPattern = pattern;
+  mask_pattern_ = pattern;
 }
 
 void CBC_QRCoder::SetNumDataBytes(int32_t bytes) {
-  m_numDataBytes = bytes;
+  num_data_bytes_ = bytes;
 }
 
 void CBC_QRCoder::SetNumTotalBytes(int32_t value) {
-  m_numTotalBytes = value;
+  num_total_bytes_ = value;
 }
 
 void CBC_QRCoder::SetNumRSBlocks(int32_t block) {
-  m_numRSBlocks = block;
+  num_rsblocks_ = block;
 }
 
 void CBC_QRCoder::SetNumECBytes(int32_t value) {
-  m_numECBytes = value;
+  num_ecbytes_ = value;
 }
 
 bool CBC_QRCoder::IsValidMaskPattern(int32_t maskPattern) {
@@ -111,5 +111,5 @@
 }
 
 void CBC_QRCoder::SetMatrix(std::unique_ptr<CBC_CommonByteMatrix> pMatrix) {
-  m_matrix = std::move(pMatrix);
+  matrix_ = std::move(pMatrix);
 }
diff --git a/fxbarcode/qrcode/BC_QRCoder.h b/fxbarcode/qrcode/BC_QRCoder.h
index e120b51..2aed778 100644
--- a/fxbarcode/qrcode/BC_QRCoder.h
+++ b/fxbarcode/qrcode/BC_QRCoder.h
@@ -45,15 +45,15 @@
   void SetMatrix(std::unique_ptr<CBC_CommonByteMatrix> pMatrix);
 
  private:
-  UnownedPtr<const CBC_QRCoderErrorCorrectionLevel> m_ecLevel;
-  int32_t m_version = -1;
-  int32_t m_matrixWidth = -1;
-  int32_t m_maskPattern = -1;
-  int32_t m_numTotalBytes = -1;
-  int32_t m_numDataBytes = -1;
-  int32_t m_numECBytes = -1;
-  int32_t m_numRSBlocks = -1;
-  std::unique_ptr<CBC_CommonByteMatrix> m_matrix;
+  UnownedPtr<const CBC_QRCoderErrorCorrectionLevel> ec_level_;
+  int32_t version_ = -1;
+  int32_t matrix_width_ = -1;
+  int32_t mask_pattern_ = -1;
+  int32_t num_total_bytes_ = -1;
+  int32_t num_data_bytes_ = -1;
+  int32_t num_ecbytes_ = -1;
+  int32_t num_rsblocks_ = -1;
+  std::unique_ptr<CBC_CommonByteMatrix> matrix_;
 };
 
 #endif  // FXBARCODE_QRCODE_BC_QRCODER_H_
diff --git a/fxbarcode/qrcode/BC_QRCoderBitVector.cpp b/fxbarcode/qrcode/BC_QRCoderBitVector.cpp
index 33c4ea8..0166820 100644
--- a/fxbarcode/qrcode/BC_QRCoderBitVector.cpp
+++ b/fxbarcode/qrcode/BC_QRCoderBitVector.cpp
@@ -30,28 +30,28 @@
 CBC_QRCoderBitVector::~CBC_QRCoderBitVector() = default;
 
 int32_t CBC_QRCoderBitVector::At(size_t index) const {
-  CHECK(index < m_sizeInBits);
-  int32_t value = m_array[index >> 3] & 0xff;
+  CHECK(index < size_in_bits_);
+  int32_t value = array_[index >> 3] & 0xff;
   return (value >> (7 - (index & 0x7))) & 1;
 }
 
 size_t CBC_QRCoderBitVector::sizeInBytes() const {
-  return (m_sizeInBits + 7) >> 3;
+  return (size_in_bits_ + 7) >> 3;
 }
 
 size_t CBC_QRCoderBitVector::Size() const {
-  return m_sizeInBits;
+  return size_in_bits_;
 }
 
 void CBC_QRCoderBitVector::AppendBit(int32_t bit) {
   DCHECK(bit == 0 || bit == 1);
-  int32_t numBitsInLastByte = m_sizeInBits & 0x7;
+  int32_t numBitsInLastByte = size_in_bits_ & 0x7;
   if (numBitsInLastByte == 0) {
     AppendByte(0);
-    m_sizeInBits -= 8;
+    size_in_bits_ -= 8;
   }
-  m_array[m_sizeInBits >> 3] |= (bit << (7 - numBitsInLastByte));
-  ++m_sizeInBits;
+  array_[size_in_bits_ >> 3] |= (bit << (7 - numBitsInLastByte));
+  ++size_in_bits_;
 }
 
 void CBC_QRCoderBitVector::AppendBits(int32_t value, int32_t numBits) {
@@ -60,7 +60,7 @@
 
   int32_t numBitsLeft = numBits;
   while (numBitsLeft > 0) {
-    if ((m_sizeInBits & 0x7) == 0 && numBitsLeft >= 8) {
+    if ((size_in_bits_ & 0x7) == 0 && numBitsLeft >= 8) {
       AppendByte(static_cast<int8_t>((value >> (numBitsLeft - 8)) & 0xff));
       numBitsLeft -= 8;
     } else {
@@ -76,22 +76,24 @@
 }
 
 bool CBC_QRCoderBitVector::XOR(const CBC_QRCoderBitVector* other) {
-  if (m_sizeInBits != other->Size())
+  if (size_in_bits_ != other->Size()) {
     return false;
+  }
 
   pdfium::span<const uint8_t> other_span = other->GetArray();
   for (size_t i = 0; i < sizeInBytes(); ++i)
-    m_array[i] ^= other_span[i];
+    array_[i] ^= other_span[i];
   return true;
 }
 
 pdfium::span<const uint8_t> CBC_QRCoderBitVector::GetArray() const {
-  return m_array;
+  return array_;
 }
 
 void CBC_QRCoderBitVector::AppendByte(int8_t value) {
-  if ((m_sizeInBits >> 3) == m_array.size())
-    m_array.push_back(0);
-  m_array[m_sizeInBits >> 3] = value;
-  m_sizeInBits += 8;
+  if ((size_in_bits_ >> 3) == array_.size()) {
+    array_.push_back(0);
+  }
+  array_[size_in_bits_ >> 3] = value;
+  size_in_bits_ += 8;
 }
diff --git a/fxbarcode/qrcode/BC_QRCoderBitVector.h b/fxbarcode/qrcode/BC_QRCoderBitVector.h
index 13b77ee..86c7a5b 100644
--- a/fxbarcode/qrcode/BC_QRCoderBitVector.h
+++ b/fxbarcode/qrcode/BC_QRCoderBitVector.h
@@ -31,8 +31,8 @@
  private:
   void AppendByte(int8_t value);
 
-  size_t m_sizeInBits = 0;
-  DataVector<uint8_t> m_array;
+  size_t size_in_bits_ = 0;
+  DataVector<uint8_t> array_;
 };
 
 #endif  // FXBARCODE_QRCODE_BC_QRCODERBITVECTOR_H_
diff --git a/fxbarcode/qrcode/BC_QRCoderErrorCorrectionLevel.cpp b/fxbarcode/qrcode/BC_QRCoderErrorCorrectionLevel.cpp
index 4f89fba..95715ce 100644
--- a/fxbarcode/qrcode/BC_QRCoderErrorCorrectionLevel.cpp
+++ b/fxbarcode/qrcode/BC_QRCoderErrorCorrectionLevel.cpp
@@ -30,7 +30,7 @@
 CBC_QRCoderErrorCorrectionLevel::CBC_QRCoderErrorCorrectionLevel(
     int32_t ordinal,
     int32_t bits)
-    : m_ordinal(ordinal), m_bits(bits) {}
+    : ordinal_(ordinal), bits_(bits) {}
 
 CBC_QRCoderErrorCorrectionLevel::~CBC_QRCoderErrorCorrectionLevel() = default;
 
diff --git a/fxbarcode/qrcode/BC_QRCoderErrorCorrectionLevel.h b/fxbarcode/qrcode/BC_QRCoderErrorCorrectionLevel.h
index 6cb8bb4..6dbf86c 100644
--- a/fxbarcode/qrcode/BC_QRCoderErrorCorrectionLevel.h
+++ b/fxbarcode/qrcode/BC_QRCoderErrorCorrectionLevel.h
@@ -21,14 +21,14 @@
 
   ~CBC_QRCoderErrorCorrectionLevel();
 
-  int32_t Ordinal() const { return m_ordinal; }
-  int32_t GetBits() const { return m_bits; }
+  int32_t Ordinal() const { return ordinal_; }
+  int32_t GetBits() const { return bits_; }
 
  private:
   CBC_QRCoderErrorCorrectionLevel(int32_t ordinal, int32_t bits);
 
-  int32_t m_ordinal;
-  int32_t m_bits;
+  int32_t ordinal_;
+  int32_t bits_;
 };
 
 #endif  // FXBARCODE_QRCODE_BC_QRCODERERRORCORRECTIONLEVEL_H_
diff --git a/fxbarcode/qrcode/BC_QRCoderMode.cpp b/fxbarcode/qrcode/BC_QRCoderMode.cpp
index 1d03ca0..4a28d5f 100644
--- a/fxbarcode/qrcode/BC_QRCoderMode.cpp
+++ b/fxbarcode/qrcode/BC_QRCoderMode.cpp
@@ -33,7 +33,8 @@
 
 CBC_QRCoderMode::CBC_QRCoderMode(std::vector<int32_t> charCountBits,
                                  int32_t bits)
-    : m_characterCountBitsForVersions(std::move(charCountBits)), m_bits(bits) {}
+    : character_count_bits_for_versions_(std::move(charCountBits)),
+      bits_(bits) {}
 
 CBC_QRCoderMode::~CBC_QRCoderMode() = default;
 
@@ -53,12 +54,13 @@
 }
 
 int32_t CBC_QRCoderMode::GetBits() const {
-  return m_bits;
+  return bits_;
 }
 
 int32_t CBC_QRCoderMode::GetCharacterCountBits(int32_t number) const {
-  if (m_characterCountBitsForVersions.empty())
+  if (character_count_bits_for_versions_.empty()) {
     return 0;
+  }
 
   int32_t offset;
   if (number <= 9)
@@ -68,7 +70,7 @@
   else
     offset = 2;
 
-  int32_t result = m_characterCountBitsForVersions[offset];
+  int32_t result = character_count_bits_for_versions_[offset];
   DCHECK(result != 0);
   return result;
 }
diff --git a/fxbarcode/qrcode/BC_QRCoderMode.h b/fxbarcode/qrcode/BC_QRCoderMode.h
index 0e12d7d..b400411 100644
--- a/fxbarcode/qrcode/BC_QRCoderMode.h
+++ b/fxbarcode/qrcode/BC_QRCoderMode.h
@@ -28,8 +28,8 @@
  private:
   CBC_QRCoderMode(std::vector<int32_t> charCountBits, int32_t bits);
 
-  std::vector<int32_t> m_characterCountBitsForVersions;
-  const int32_t m_bits;
+  std::vector<int32_t> character_count_bits_for_versions_;
+  const int32_t bits_;
 };
 
 #endif  // FXBARCODE_QRCODE_BC_QRCODERMODE_H_
diff --git a/fxbarcode/qrcode/BC_QRCoderVersion.cpp b/fxbarcode/qrcode/BC_QRCoderVersion.cpp
index a33bd10..6f79061 100644
--- a/fxbarcode/qrcode/BC_QRCoderVersion.cpp
+++ b/fxbarcode/qrcode/BC_QRCoderVersion.cpp
@@ -37,12 +37,12 @@
 
 CBC_QRCoderVersion::CBC_QRCoderVersion(int32_t versionNumber,
                                        const ECBlockDataRow& row)
-    : m_versionNumber(versionNumber) {
-  m_ecBlocksArray[0] = std::make_unique<CBC_QRCoderECBlockData>(row[0]);
-  m_ecBlocksArray[1] = std::make_unique<CBC_QRCoderECBlockData>(row[1]);
-  m_ecBlocksArray[2] = std::make_unique<CBC_QRCoderECBlockData>(row[2]);
-  m_ecBlocksArray[3] = std::make_unique<CBC_QRCoderECBlockData>(row[3]);
-  m_totalCodeWords = m_ecBlocksArray[0]->GetTotalDataCodeWords();
+    : version_number_(versionNumber) {
+  ec_blocks_array_[0] = std::make_unique<CBC_QRCoderECBlockData>(row[0]);
+  ec_blocks_array_[1] = std::make_unique<CBC_QRCoderECBlockData>(row[1]);
+  ec_blocks_array_[2] = std::make_unique<CBC_QRCoderECBlockData>(row[2]);
+  ec_blocks_array_[3] = std::make_unique<CBC_QRCoderECBlockData>(row[3]);
+  total_code_words_ = ec_blocks_array_[0]->GetTotalDataCodeWords();
 }
 
 CBC_QRCoderVersion::~CBC_QRCoderVersion() = default;
@@ -73,18 +73,18 @@
 }
 
 int32_t CBC_QRCoderVersion::GetVersionNumber() const {
-  return m_versionNumber;
+  return version_number_;
 }
 
 int32_t CBC_QRCoderVersion::GetTotalCodeWords() const {
-  return m_totalCodeWords;
+  return total_code_words_;
 }
 
 int32_t CBC_QRCoderVersion::GetDimensionForVersion() const {
-  return 17 + 4 * m_versionNumber;
+  return 17 + 4 * version_number_;
 }
 
 const CBC_QRCoderECBlockData* CBC_QRCoderVersion::GetECBlocksForLevel(
     const CBC_QRCoderErrorCorrectionLevel& ecLevel) const {
-  return m_ecBlocksArray[ecLevel.Ordinal()].get();
+  return ec_blocks_array_[ecLevel.Ordinal()].get();
 }
diff --git a/fxbarcode/qrcode/BC_QRCoderVersion.h b/fxbarcode/qrcode/BC_QRCoderVersion.h
index d4746f6..f1ff16c 100644
--- a/fxbarcode/qrcode/BC_QRCoderVersion.h
+++ b/fxbarcode/qrcode/BC_QRCoderVersion.h
@@ -33,9 +33,9 @@
       const CBC_QRCoderErrorCorrectionLevel& ecLevel) const;
 
  private:
-  const int32_t m_versionNumber;
-  int32_t m_totalCodeWords;
-  std::array<std::unique_ptr<CBC_QRCoderECBlockData>, 4> m_ecBlocksArray;
+  const int32_t version_number_;
+  int32_t total_code_words_;
+  std::array<std::unique_ptr<CBC_QRCoderECBlockData>, 4> ec_blocks_array_;
 };
 
 #endif  // FXBARCODE_QRCODE_BC_QRCODERVERSION_H_