diff --git a/fuzzer/cdm_engine_fuzzer.cpp b/fuzzer/cdm_engine_fuzzer.cpp
index 0f1e5937..64ca2b13 100644
--- a/fuzzer/cdm_engine_fuzzer.cpp
+++ b/fuzzer/cdm_engine_fuzzer.cpp
@@ -15,18 +15,20 @@
  *
  */
 
-#include "vendor_widevine_fuzz_helper.h"
 #include <cdm_engine.h>
 #include <cdm_engine_factory.h>
-#include <fstream>
 #include <fuzzer/FuzzedDataProvider.h>
-#include <iostream>
 #include <stdlib.h>
-#include <string>
 #include <wv_cdm_constants.h>
 #include <wv_cdm_event_listener.h>
 #include <wv_cdm_types.h>
 
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include "vendor_widevine_fuzz_helper.h"
+
 const int32_t kMinByte = 0;
 const int32_t kMaxByte = 256;
 const int32_t kMinEnum = 0;
@@ -37,9 +39,9 @@ const int32_t kMinKey = 10;
 const int32_t kMaxKey = 1000;
 const int32_t kMinSize = 1;
 const int32_t kMaxSize = 100;
-const char* kKeySystem = "widevine";
-const char* kKeySetIdPrefix = "ksid";
-const char* kEmptyString = "";
+const char *kKeySystem = "widevine";
+const char *kKeySetIdPrefix = "ksid";
+const char *kEmptyString = "";
 const std::string kUsageFilePrefixL1 = "/data/vendor/mediadrm/IDM0/L1/";
 const std::string kUsageFilePrefixL3 = "/data/vendor/mediadrm/IDM0/L3/";
 const std::string kCertFile = kUsageFilePrefixL3 + "cert.bin";
@@ -83,7 +85,7 @@ std::string kInitType[] = {ISO_BMFF_VIDEO_MIME_TYPE, WEBM_VIDEO_MIME_TYPE,
                            WEBM_INIT_DATA_FORMAT};
 
 class FuzzWvCdmEventListener : public WvCdmEventListener {
-public:
+ public:
   void OnSessionRenewalNeeded(const CdmSessionId & /*session_id*/) {}
   void OnSessionKeysChange(const CdmSessionId & /*session_id*/,
                            const CdmKeyStatusMap & /*keys_status*/,
@@ -93,413 +95,413 @@ public:
 };
 
 class CdmEngineFuzzer {
-public:
-  CdmEngineFuzzer(const uint8_t *data, size_t size) : mFdp(data, size){};
-  void process();
-  void init(CdmEngine *cdmEngine);
-  void createUsageFile(std::string mAppId);
-  std::vector<std::string> createVector(bool enableKeySetId);
+ public:
+  CdmEngineFuzzer(const uint8_t *data, size_t size) : fdp_(data, size){};
+  void Process();
+  void Init(CdmEngine *cdm_engine);
+  void CreateUsageFiles(std::string app_id_);
+  std::vector<std::string> CreateVector(bool enable_key_set_id);
 
-private:
-  FuzzedDataProvider mFdp;
-  std::ofstream mOutCertFile1;
-  std::ofstream mOutCertFile2;
-  std::ofstream mOutUsageFile1;
-  std::ofstream mOutUsageFile2;
-  std::string mAppId;
-  std::string mKeyId;
-  std::string mSign;
-  std::string mDefaultUrl;
-  std::unique_ptr<wvutil::FileSystem> mFileSystem =
+ private:
+  FuzzedDataProvider fdp_;
+  std::ofstream out_cert_file_1_;
+  std::ofstream out_cert_file_2_;
+  std::ofstream out_usage_file_1_;
+  std::ofstream out_usage_file_2_;
+  std::string app_id_;
+  std::string key_id_;
+  std::string sign_;
+  std::string default_url_;
+  std::unique_ptr<wvutil::FileSystem> file_system_ =
       std::make_unique<wvutil::FileSystem>();
-  std::unique_ptr<FuzzCdmClientPropertySet> mFuzzCdmClientPropertySet =
-      std::make_unique<FuzzCdmClientPropertySet>(&mFdp);
-  CdmSessionId mSessionId;
-  CdmKeySystem mKeySystem;
-  CdmKeySetId mKeySetId;
+  std::unique_ptr<FuzzCdmClientPropertySet> fuzz_cdm_client_property_ =
+      std::make_unique<FuzzCdmClientPropertySet>(&fdp_);
+  CdmSessionId session_id_;
+  CdmKeySystem key_system_;
+  CdmKeySetId key_set_id_;
 };
 
-void CdmEngineFuzzer::createUsageFile(std::string mAppId) {
+void CdmEngineFuzzer::CreateUsageFiles(std::string app_id_) {
   /**
    * These files are being fetched by the GetUsageInfo() &
    * RemoveAllUsageInfo() APIs, since they were not created
    * by any other API calls in the fuzzer, we are creating them.
    */
-  DeviceFiles deviceFiles(mFileSystem.get());
-  std::string fileName = deviceFiles.GetUsageInfoFileName(mAppId);
-  std::string createFile1 = kUsageFilePrefixL1 + fileName;
-  std::string createFile2 = kUsageFilePrefixL3 + fileName;
-  mOutUsageFile1.open(createFile1.c_str());
-  mOutUsageFile2.open(createFile2.c_str());
+  DeviceFiles device_files(file_system_.get());
+  std::string file_name = device_files.GetUsageInfoFileName(app_id_);
+  std::string create_file_1 = kUsageFilePrefixL1 + file_name;
+  std::string create_file_2 = kUsageFilePrefixL3 + file_name;
+  out_usage_file_1_.open(create_file_1.c_str());
+  out_usage_file_2_.open(create_file_2.c_str());
 }
 
-std::vector<std::string> CdmEngineFuzzer::createVector(bool enableKeySetId) {
-  int32_t size = mFdp.ConsumeIntegralInRange(kMinSize, kMaxSize);
+std::vector<std::string> CdmEngineFuzzer::CreateVector(bool enable_key_set_id) {
+  int32_t size = fdp_.ConsumeIntegralInRange(kMinSize, kMaxSize);
   std::vector<std::string> vector;
   for (int i = 0; i < size; ++i) {
-    vector.push_back(enableKeySetId ? mKeySetId
-                                    : mFdp.ConsumeRandomLengthString(kMaxByte));
+    vector.push_back(enable_key_set_id ? key_set_id_
+                                    : fdp_.ConsumeRandomLengthString(kMaxByte));
   }
   return vector;
 }
 
-void CdmEngineFuzzer::init(CdmEngine *cdmEngine) {
-  mAppId =
-      std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize));
-  mKeyId =
-      std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize));
-  mSign = mFdp.ConsumeRandomLengthString(kMaxByte);
+void CdmEngineFuzzer::Init(CdmEngine *cdm_engine) {
+  app_id_ =
+      std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize));
+  key_id_ =
+      std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize));
+  sign_ = fdp_.ConsumeRandomLengthString(kMaxByte);
 
-  mKeySystem = mFdp.ConsumeBool() ? kKeySystem
-                                  : mFdp.ConsumeRandomLengthString(kMaxByte);
+  key_system_ = fdp_.ConsumeBool() ? kKeySystem
+                                  : fdp_.ConsumeRandomLengthString(kMaxByte);
 
-  FuzzWvCdmEventListener fuzzWvCdmEventListener;
-  cdmEngine->OpenSession(
-      mKeySystem,
-      mFdp.ConsumeBool() ? mFuzzCdmClientPropertySet.get() : nullptr,
-      mFdp.ConsumeBool() ? &fuzzWvCdmEventListener : nullptr, &mSessionId);
+  FuzzWvCdmEventListener fuzz_wv_cdm_event_listener;
+  cdm_engine->OpenSession(
+      key_system_,
+      fdp_.ConsumeBool() ? fuzz_cdm_client_property_.get() : nullptr,
+      fdp_.ConsumeBool() ? &fuzz_wv_cdm_event_listener : nullptr, &session_id_);
 
   std::string request;
-  mDefaultUrl = mFdp.ConsumeRandomLengthString(kMaxByte);
-  cdmEngine->GetProvisioningRequest(
-      (CdmCertificateType)mFdp.ConsumeIntegralInRange<int32_t>(kMinValue,
+  default_url_ = fdp_.ConsumeRandomLengthString(kMaxByte);
+  cdm_engine->GetProvisioningRequest(
+      (CdmCertificateType)fdp_.ConsumeIntegralInRange<int32_t>(kMinValue,
                                                                kMaxValue),
-      mFdp.ConsumeRandomLengthString(kMaxByte) /* cert_authority */,
-      mFdp.ConsumeRandomLengthString(kMaxByte) /* service_certificate */,
-      (RequestedSecurityLevel)mFdp.ConsumeIntegralInRange<uint32_t>(kMinValue,
+      fdp_.ConsumeRandomLengthString(kMaxByte) /* cert_authority */,
+      fdp_.ConsumeRandomLengthString(kMaxByte) /* service_certificate */,
+      (RequestedSecurityLevel)fdp_.ConsumeIntegralInRange<uint32_t>(kMinValue,
                                                                     kMaxValue),
-      mFdp.ConsumeBool() ? &request : nullptr, &mDefaultUrl);
+      fdp_.ConsumeBool() ? &request : nullptr, &default_url_);
 
   std::string cert;
-  std::string wrappedKey;
-  CdmProvisioningResponse responseMessage =
-      mFdp.ConsumeRandomLengthString(kMaxByte);
-  cdmEngine->HandleProvisioningResponse(
-      responseMessage,
-      (RequestedSecurityLevel)mFdp.ConsumeIntegralInRange<uint32_t>(kMinValue,
+  std::string wrapped_key;
+  CdmProvisioningResponse response_message =
+      fdp_.ConsumeRandomLengthString(kMaxByte);
+  cdm_engine->HandleProvisioningResponse(
+      response_message,
+      (RequestedSecurityLevel)fdp_.ConsumeIntegralInRange<uint32_t>(kMinValue,
                                                                     kMaxValue),
-      mFdp.ConsumeBool() ? &cert : nullptr,
-      mFdp.ConsumeBool() ? &wrappedKey : nullptr);
+      fdp_.ConsumeBool() ? &cert : nullptr,
+      fdp_.ConsumeBool() ? &wrapped_key : nullptr);
 
-  CdmAppParameterMap appParameters;
-  appParameters.insert({mFdp.ConsumeRandomLengthString(kMaxByte),
-                        mFdp.ConsumeRandomLengthString(kMaxByte)});
-  CdmInitData data = mFdp.ConsumeRandomLengthString(kMaxByte);
-  const std::string oecVersion =
-      std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize));
-  InitializationData init_data(mFdp.PickValueInArray<std::string>(kInitType),
-                               data, oecVersion);
+  CdmAppParameterMap app_parameters;
+  app_parameters.insert({fdp_.ConsumeRandomLengthString(kMaxByte),
+                        fdp_.ConsumeRandomLengthString(kMaxByte)});
+  CdmInitData data = fdp_.ConsumeRandomLengthString(kMaxByte);
+  const std::string oec_version =
+      std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize));
+  InitializationData init_data(fdp_.PickValueInArray<std::string>(kInitType),
+                               data, oec_version);
 
-  mKeySetId =
+  key_set_id_ =
       kKeySetIdPrefix +
-      std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey));
+      std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey));
 
-  CdmLicenseType generateLicType =
-      static_cast<CdmLicenseType>(mFdp.ConsumeIntegralInRange(
+  CdmLicenseType generate_lic_type =
+      static_cast<CdmLicenseType>(fdp_.ConsumeIntegralInRange(
           static_cast<int32_t>(CdmLicenseType::kLicenseTypeOffline),
           static_cast<int32_t>(CdmLicenseType::kLicenseTypeEmbeddedKeyData)));
-  CdmKeyRequest keyRequest;
-  keyRequest.message = mFdp.ConsumeRandomLengthString(kMaxByte);
-  keyRequest.type = static_cast<CdmKeyRequestType>(mFdp.ConsumeIntegralInRange(
+  CdmKeyRequest key_request;
+  key_request.message = fdp_.ConsumeRandomLengthString(kMaxByte);
+  key_request.type = static_cast<CdmKeyRequestType>(fdp_.ConsumeIntegralInRange(
       static_cast<uint32_t>(CdmKeyRequestType::kKeyRequestTypeUnknown),
       static_cast<uint32_t>(CdmKeyRequestType::kKeyRequestTypeUpdate)));
-  keyRequest.url = mFdp.ConsumeBool()
-                       ? mDefaultUrl
-                       : mFdp.ConsumeRandomLengthString(kMaxByte);
-  cdmEngine->GenerateKeyRequest(mSessionId,
-                                mFdp.ConsumeBool() ? mKeySetId : kEmptyString,
-                                init_data, generateLicType, appParameters,
-                                mFdp.ConsumeBool() ? &keyRequest : nullptr);
+  key_request.url = fdp_.ConsumeBool()
+                       ? default_url_
+                       : fdp_.ConsumeRandomLengthString(kMaxByte);
+  cdm_engine->GenerateKeyRequest(session_id_,
+                                fdp_.ConsumeBool() ? key_set_id_ : kEmptyString,
+                                init_data, generate_lic_type, app_parameters,
+                                fdp_.ConsumeBool() ? &key_request : nullptr);
 
-  CdmLicenseType addLicType =
-      static_cast<CdmLicenseType>(mFdp.ConsumeIntegralInRange(
+  CdmLicenseType add_lic_type =
+      static_cast<CdmLicenseType>(fdp_.ConsumeIntegralInRange(
           static_cast<int32_t>(CdmLicenseType::kLicenseTypeOffline),
           static_cast<int32_t>(CdmLicenseType::kLicenseTypeEmbeddedKeyData)));
-  CdmKeyResponse keyData =
-      std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey));
-  cdmEngine->AddKey(mSessionId, mFdp.ConsumeBool() ? keyData : kEmptyString,
-                    &addLicType, &mKeySetId);
+  CdmKeyResponse key_data =
+      std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey));
+  cdm_engine->AddKey(session_id_, fdp_.ConsumeBool() ? key_data : kEmptyString,
+                    &add_lic_type, &key_set_id_);
 }
 
-void CdmEngineFuzzer::process() {
-  CdmEngine *cdmEngine = CdmEngineFactory::CreateCdmEngine(mFileSystem.get());
+void CdmEngineFuzzer::Process() {
+  CdmEngine *cdm_engine = CdmEngineFactory::CreateCdmEngine(file_system_.get());
 
-  CdmEngineFuzzer::init(cdmEngine);
+  CdmEngineFuzzer::Init(cdm_engine);
 
    int32_t runs = kMaxRuns;
   /* Limited the while loop to prevent a timeout caused by the
   /* CryptoSession constructor, which took time to initialize
   /* OEMCrypto in each iteration.*/
-  while (mFdp.remaining_bytes() > 0 && --runs) {
-    auto invokeCdmEngineAPI = mFdp.PickValueInArray<
+  while (fdp_.remaining_bytes() > 0 && --runs) {
+    auto invoke_cdm_engine_API = fdp_.PickValueInArray<
         const std::function<void()>>({
-        [&]() { cdmEngine->OnTimerEvent(); },
-        [&]() { cdmEngine->IsOpenSession(mSessionId); },
-        [&]() { cdmEngine->SetDefaultOtaKeyboxFallbackDurationRules(); },
-        [&]() { cdmEngine->SetFastOtaKeyboxFallbackDurationRules(); },
+        [&]() { cdm_engine->OnTimerEvent(); },
+        [&]() { cdm_engine->IsOpenSession(session_id_); },
+        [&]() { cdm_engine->SetDefaultOtaKeyboxFallbackDurationRules(); },
+        [&]() { cdm_engine->SetFastOtaKeyboxFallbackDurationRules(); },
         [&]() {
-          cdmEngine->OpenSession(
-              mKeySystem, nullptr /* property_set */,
-              mFdp.ConsumeRandomLengthString(kMaxByte) /* forced_session_id */,
+          cdm_engine->OpenSession(
+              key_system_, nullptr /* property_set */,
+              fdp_.ConsumeRandomLengthString(kMaxByte) /* forced_session_id */,
               nullptr /* event_listener */);
         },
         [&]() {
-          cdmEngine->StoreAtscLicense(
-              static_cast<RequestedSecurityLevel>(mFdp.ConsumeIntegralInRange(
+          cdm_engine->StoreAtscLicense(
+              static_cast<RequestedSecurityLevel>(fdp_.ConsumeIntegralInRange(
                   static_cast<int32_t>(RequestedSecurityLevel::kLevelDefault),
                   static_cast<int32_t>(RequestedSecurityLevel::kLevel3))),
-              mKeySetId,
-              mFdp.ConsumeRandomLengthString(
+              key_set_id_,
+              fdp_.ConsumeRandomLengthString(
                   kMaxByte) /* serialized_license_data */);
         },
-        [&]() { cdmEngine->RestoreKey(mSessionId, mKeySetId); },
+        [&]() { cdm_engine->RestoreKey(session_id_, key_set_id_); },
         [&]() {
-          cdmEngine->SetSessionServiceCertificate(
-              mSessionId, mFdp.ConsumeRandomLengthString(
+          cdm_engine->SetSessionServiceCertificate(
+              session_id_, fdp_.ConsumeRandomLengthString(
                               kMaxByte) /* service_certificate */);
         },
         [&]() {
-          std::string queryResponse;
-          cdmEngine->QueryStatus(
-              static_cast<RequestedSecurityLevel>(mFdp.ConsumeIntegralInRange(
+          std::string query_response;
+          cdm_engine->QueryStatus(
+              static_cast<RequestedSecurityLevel>(fdp_.ConsumeIntegralInRange(
                   static_cast<int32_t>(RequestedSecurityLevel::kLevelDefault),
                   static_cast<int32_t>(RequestedSecurityLevel::kLevel3))),
-              mFdp.PickValueInArray<std::string>(kQueryToken),
-              mFdp.ConsumeBool() ? &queryResponse : nullptr);
+              fdp_.PickValueInArray<std::string>(kQueryToken),
+              fdp_.ConsumeBool() ? &query_response : nullptr);
         },
         [&]() {
-          CdmQueryMap queryResponse;
-          cdmEngine->QuerySessionStatus(mSessionId, &queryResponse);
+          CdmQueryMap query_response;
+          cdm_engine->QuerySessionStatus(session_id_, &query_response);
         },
         [&]() {
-          CdmKeyRequest keyRequest;
-          keyRequest.message = mFdp.ConsumeRandomLengthString(kMaxByte);
-          keyRequest.type =
-              static_cast<CdmKeyRequestType>(mFdp.ConsumeIntegralInRange(
+          CdmKeyRequest key_request;
+          key_request.message = fdp_.ConsumeRandomLengthString(kMaxByte);
+          key_request.type =
+              static_cast<CdmKeyRequestType>(fdp_.ConsumeIntegralInRange(
                   static_cast<uint32_t>(
                       CdmKeyRequestType::kKeyRequestTypeUnknown),
                   static_cast<uint32_t>(
                       CdmKeyRequestType::kKeyRequestTypeUpdate)));
-          keyRequest.url = mDefaultUrl;
+          key_request.url = default_url_;
 
-          cdmEngine->GenerateRenewalRequest(
-              mSessionId, mFdp.ConsumeBool() ? &keyRequest : nullptr);
+          cdm_engine->GenerateRenewalRequest(
+              session_id_, fdp_.ConsumeBool() ? &key_request : nullptr);
 
-          CdmKeyResponse keyData =
-              mFdp.ConsumeBool()
+          CdmKeyResponse key_data =
+              fdp_.ConsumeBool()
                   ? std::to_string(
-                        mFdp.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey))
+                        fdp_.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey))
                   : kEmptyString;
-          cdmEngine->RenewKey(mSessionId, keyData);
+          cdm_engine->RenewKey(session_id_, key_data);
         },
-        [&]() { cdmEngine->IsReleaseSession(mSessionId); },
-        [&]() { cdmEngine->IsOfflineSession(mSessionId); },
+        [&]() { cdm_engine->IsReleaseSession(session_id_); },
+        [&]() { cdm_engine->IsOfflineSession(session_id_); },
         [&]() {
-          mOutCertFile1.open(kCertFile.c_str());
-          mOutCertFile2.open(kCertFile1.c_str());
-          cdmEngine->RemoveOfflineLicense(
-              mKeySetId,
-              static_cast<CdmSecurityLevel>(mFdp.ConsumeIntegralInRange(
+          out_cert_file_1_.open(kCertFile.c_str());
+          out_cert_file_2_.open(kCertFile1.c_str());
+          cdm_engine->RemoveOfflineLicense(
+              key_set_id_,
+              static_cast<CdmSecurityLevel>(fdp_.ConsumeIntegralInRange(
                   static_cast<int32_t>(
                       CdmSecurityLevel::kSecurityLevelUninitialized),
                   static_cast<int32_t>(
                       CdmSecurityLevel::kSecurityLevelUnknown))));
         },
         [&]() {
-          CdmQueryMap queryResponse;
-          cdmEngine->QueryKeyStatus(mSessionId, &queryResponse);
+          CdmQueryMap query_response;
+          cdm_engine->QueryKeyStatus(session_id_, &query_response);
         },
         [&]() {
-          cdmEngine->IsSecurityLevelSupported(
-              (CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(kMinEnum,
+          cdm_engine->IsSecurityLevelSupported(
+              (CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(kMinEnum,
                                                                      kMaxEnum));
         },
         [&]() {
-          CdmKeyAllowedUsage keyUsage;
-          cdmEngine->QueryKeyAllowedUsage(
-              mSessionId, mKeyId, mFdp.ConsumeBool() ? &keyUsage : nullptr);
+          CdmKeyAllowedUsage key_usage;
+          cdm_engine->QueryKeyAllowedUsage(
+              session_id_, key_id_, fdp_.ConsumeBool() ? &key_usage : nullptr);
         },
         [&]() {
-          CdmKeyAllowedUsage keyUsage;
-          cdmEngine->QueryKeyAllowedUsage(mKeyId, mFdp.ConsumeBool() ? &keyUsage
-                                                                     : nullptr);
+          CdmKeyAllowedUsage key_usage;
+          cdm_engine->QueryKeyAllowedUsage(
+              key_id_, fdp_.ConsumeBool() ? &key_usage : nullptr);
         },
         [&]() {
-          CdmQueryMap queryResponse;
-          cdmEngine->QueryOemCryptoSessionId(mSessionId, &queryResponse);
+          CdmQueryMap query_response;
+          cdm_engine->QueryOemCryptoSessionId(session_id_, &query_response);
         },
         [&]() {
-          std::vector<std::string> keySetIds = createVector(true);
-          cdmEngine->ListStoredLicenses(
-              (CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(kMinEnum,
+          std::vector<std::string> key_set_ids = CreateVector(true);
+          cdm_engine->ListStoredLicenses(
+              (CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(kMinEnum,
                                                                      kMaxEnum),
-              mFdp.ConsumeBool() ? &keySetIds : nullptr);
+              fdp_.ConsumeBool() ? &key_set_ids : nullptr);
         },
         [&]() {
-          std::vector<std::string> keySetIds = createVector(true);
-          std::vector<std::string> providerSessionTokens = createVector(false);
+          std::vector<std::string> key_set_ids = CreateVector(true);
+          std::vector<std::string> provider_session_tokens = CreateVector(false);
 
-          cdmEngine->ListUsageIds(
-              mAppId,
-              (CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(kMinEnum,
+          cdm_engine->ListUsageIds(
+              app_id_,
+              (CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(kMinEnum,
                                                                      kMaxEnum),
-              mFdp.ConsumeBool() ? &keySetIds : nullptr,
-              mFdp.ConsumeBool() ? &providerSessionTokens : nullptr);
+              fdp_.ConsumeBool() ? &key_set_ids : nullptr,
+              fdp_.ConsumeBool() ? &provider_session_tokens : nullptr);
         },
         [&]() {
-          cdmEngine->DeleteUsageRecord(
-              mAppId,
-              (CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(kMinEnum,
+          cdm_engine->DeleteUsageRecord(
+              app_id_,
+              (CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(kMinEnum,
                                                                      kMaxEnum),
-              mKeySetId);
+              key_set_id_);
         },
         [&]() {
-          CdmOfflineLicenseState licenseState =
-              static_cast<CdmOfflineLicenseState>(mFdp.ConsumeIntegralInRange(
+          CdmOfflineLicenseState license_state =
+              static_cast<CdmOfflineLicenseState>(fdp_.ConsumeIntegralInRange(
                   static_cast<int32_t>(
                       CdmOfflineLicenseState::kLicenseStateActive),
                   static_cast<int32_t>(
                       CdmOfflineLicenseState::kLicenseStateUnknown)));
-          cdmEngine->GetOfflineLicenseState(
-              mKeySetId,
-              (CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(kMinEnum,
+          cdm_engine->GetOfflineLicenseState(
+              key_set_id_,
+              (CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(kMinEnum,
                                                                      kMaxEnum),
-              mFdp.ConsumeBool() ? &licenseState : nullptr);
+              fdp_.ConsumeBool() ? &license_state : nullptr);
         },
         [&]() {
-          cdmEngine->SetPlaybackId(mSessionId,
-                                   mFdp.ConsumeRandomLengthString(kMaxByte));
+          cdm_engine->SetPlaybackId(session_id_,
+                                   fdp_.ConsumeRandomLengthString(kMaxByte));
         },
         [&]() {
-          CdmUsageReport usageReport;
-          createUsageFile(mAppId);
-          int errorDetail;
-          cdmEngine->GetUsageInfo(mAppId,
-                                  mFdp.ConsumeBool() ? &errorDetail : nullptr,
-                                  mFdp.ConsumeBool() ? &usageReport : nullptr);
+          CdmUsageReport usage_report;
+          CreateUsageFiles(app_id_);
+          int error_detail;
+          cdm_engine->GetUsageInfo(app_id_,
+                                  fdp_.ConsumeBool() ? &error_detail : nullptr,
+                                  fdp_.ConsumeBool() ? &usage_report : nullptr);
         },
         [&]() {
-          createUsageFile(mAppId);
-          cdmEngine->RemoveAllUsageInfo(mAppId);
+          CreateUsageFiles(app_id_);
+          cdm_engine->RemoveAllUsageInfo(app_id_);
         },
         [&]() {
-          cdmEngine->ReleaseUsageInfo(
-              mFdp.ConsumeRandomLengthString(kMaxByte) /* message */);
+          cdm_engine->ReleaseUsageInfo(
+              fdp_.ConsumeRandomLengthString(kMaxByte) /* message */);
         },
         [&]() {
-          std::string releaseMessage = mFdp.ConsumeRandomLengthString(kMaxByte);
-          cdmEngine->LoadUsageSession(
-              mKeySetId, mFdp.ConsumeBool() ? &releaseMessage : nullptr);
+          std::string release_message = fdp_.ConsumeRandomLengthString(kMaxByte);
+          cdm_engine->LoadUsageSession(
+              key_set_id_, fdp_.ConsumeBool() ? &release_message : nullptr);
         },
         [&]() {
-          CdmDecryptionParametersV16 parameters(mKeyId);
-          cdmEngine->DecryptV16(mSessionId, parameters);
+          CdmDecryptionParametersV16 parameters(key_id_);
+          cdm_engine->DecryptV16(session_id_, parameters);
         },
         [&]() {
-          std::string out = mFdp.ConsumeRandomLengthString(kMaxByte);
-          std::string ivGE = mFdp.ConsumeRandomLengthString(kMaxByte);
-          cdmEngine->GenericEncrypt(
-              mSessionId, mFdp.ConsumeRandomLengthString(kMaxByte), mKeyId,
-              ivGE,
-              (CdmEncryptionAlgorithm)mFdp.ConsumeIntegralInRange<int32_t>(
+          std::string out = fdp_.ConsumeRandomLengthString(kMaxByte);
+          std::string iv_GE = fdp_.ConsumeRandomLengthString(kMaxByte);
+          cdm_engine->GenericEncrypt(
+              session_id_, fdp_.ConsumeRandomLengthString(kMaxByte), key_id_,
+              iv_GE,
+              (CdmEncryptionAlgorithm)fdp_.ConsumeIntegralInRange<int32_t>(
                   kMinValue, kMaxValue),
-              mFdp.ConsumeBool() ? &out : nullptr);
+              fdp_.ConsumeBool() ? &out : nullptr);
         },
         [&]() {
-          std::string out = mFdp.ConsumeRandomLengthString(kMaxByte);
-          std::string ivGE = mFdp.ConsumeRandomLengthString(kMaxByte);
-          cdmEngine->GenericDecrypt(
-              mSessionId, mFdp.ConsumeRandomLengthString(kMaxByte), mKeyId,
-              ivGE,
-              (CdmEncryptionAlgorithm)mFdp.ConsumeIntegralInRange<int32_t>(
+          std::string out = fdp_.ConsumeRandomLengthString(kMaxByte);
+          std::string iv_GE = fdp_.ConsumeRandomLengthString(kMaxByte);
+          cdm_engine->GenericDecrypt(
+              session_id_, fdp_.ConsumeRandomLengthString(kMaxByte), key_id_,
+              iv_GE,
+              (CdmEncryptionAlgorithm)fdp_.ConsumeIntegralInRange<int32_t>(
                   kMinValue, kMaxValue),
-              mFdp.ConsumeBool() ? &out : nullptr);
+              fdp_.ConsumeBool() ? &out : nullptr);
         },
         [&]() {
-          cdmEngine->GenericSign(
-              mSessionId, mFdp.ConsumeRandomLengthString(kMaxByte), mKeyId,
-              (CdmSigningAlgorithm)mFdp.ConsumeIntegralInRange<int32_t>(
+          cdm_engine->GenericSign(
+              session_id_, fdp_.ConsumeRandomLengthString(kMaxByte), key_id_,
+              (CdmSigningAlgorithm)fdp_.ConsumeIntegralInRange<int32_t>(
                   kMinValue, kMaxValue),
-              mFdp.ConsumeBool() ? &mSign : nullptr);
+              fdp_.ConsumeBool() ? &sign_ : nullptr);
 
-          cdmEngine->GenericVerify(
-              mSessionId, mFdp.ConsumeRandomLengthString(kMaxByte), mKeyId,
-              (CdmSigningAlgorithm)mFdp.ConsumeIntegralInRange<int32_t>(
+          cdm_engine->GenericVerify(
+              session_id_, fdp_.ConsumeRandomLengthString(kMaxByte), key_id_,
+              (CdmSigningAlgorithm)fdp_.ConsumeIntegralInRange<int32_t>(
                   kMinValue, kMaxValue),
-              mSign);
+              sign_);
         },
         [&]() {
-          cdmEngine->SetDebugIgnoreKeyboxCount(
-              mFdp.ConsumeIntegral<uint32_t>());
+          cdm_engine->SetDebugIgnoreKeyboxCount(
+              fdp_.ConsumeIntegral<uint32_t>());
         },
         [&]() {
-          std::string sessId = mFdp.ConsumeRandomLengthString(kMaxByte);
+          std::string sess_id = fdp_.ConsumeRandomLengthString(kMaxByte);
           std::string hash;
-          std::string hashString =
-              mFdp.ConsumeRandomLengthString(kMaxByte) + "," +
-              mFdp.ConsumeRandomLengthString(kMaxByte) + "," +
-              mFdp.ConsumeRandomLengthString(kMaxByte);
-          uint32_t frameNum = mFdp.ConsumeIntegral<uint32_t>();
-          cdmEngine->ParseDecryptHashString(
-              hashString, mFdp.ConsumeBool() ? &sessId : nullptr,
-              mFdp.ConsumeBool() ? &frameNum : nullptr,
-              mFdp.ConsumeBool() ? &hash : nullptr);
+          std::string hash_string =
+              fdp_.ConsumeRandomLengthString(kMaxByte) + "," +
+              fdp_.ConsumeRandomLengthString(kMaxByte) + "," +
+              fdp_.ConsumeRandomLengthString(kMaxByte);
+          uint32_t frame_num = fdp_.ConsumeIntegral<uint32_t>();
+          cdm_engine->ParseDecryptHashString(
+              hash_string, fdp_.ConsumeBool() ? &sess_id : nullptr,
+              fdp_.ConsumeBool() ? &frame_num : nullptr,
+              fdp_.ConsumeBool() ? &hash : nullptr);
 
-          cdmEngine->SetDecryptHash(mSessionId,
-                                    mFdp.ConsumeIntegral<uint32_t>(), hash);
+          cdm_engine->SetDecryptHash(session_id_,
+                                    fdp_.ConsumeIntegral<uint32_t>(), hash);
 
-          std::string hashError;
-          cdmEngine->GetDecryptHashError(
-              mSessionId, mFdp.ConsumeBool() ? &hashError : nullptr);
+          std::string hash_error;
+          cdm_engine->GetDecryptHashError(
+              session_id_, fdp_.ConsumeBool() ? &hash_error : nullptr);
         },
         [&]() {
-          std::string mSessionId = mFdp.ConsumeRandomLengthString(kMaxByte);
-          cdmEngine->FindSessionForKey(mKeyId, mFdp.ConsumeBool() ? &mSessionId
-                                                                  : nullptr);
+          std::string session_id = fdp_.ConsumeRandomLengthString(kMaxByte);
+          cdm_engine->FindSessionForKey(
+              key_id_, fdp_.ConsumeBool() ? &session_id : nullptr);
         },
         [&]() {
-          cdmEngine->NotifyResolution(
-              mSessionId, mFdp.ConsumeIntegral<uint32_t>() /* width */,
-              mFdp.ConsumeIntegral<uint32_t>() /* height */);
+          cdm_engine->NotifyResolution(
+              session_id_, fdp_.ConsumeIntegral<uint32_t>() /* width */,
+              fdp_.ConsumeIntegral<uint32_t>() /* height */);
         },
         [&]() {
-          cdmEngine->ValidateServiceCertificate(
-              mFdp.ConsumeRandomLengthString(kMaxByte) /* cert */);
+          cdm_engine->ValidateServiceCertificate(
+              fdp_.ConsumeRandomLengthString(kMaxByte) /* cert */);
         },
         [&]() {
-          CdmUsageReport usageReport;
-          createUsageFile(mAppId);
-          CdmSecureStopId ssid = mFdp.ConsumeRandomLengthString(kMaxByte);
-          int errorDetail = mFdp.ConsumeIntegral<int32_t>();
-          cdmEngine->GetUsageInfo(mAppId, ssid,
-                                  mFdp.ConsumeBool() ? &errorDetail : nullptr,
-                                  mFdp.ConsumeBool() ? &usageReport : nullptr);
+          CdmUsageReport usage_report;
+          CreateUsageFiles(app_id_);
+          CdmSecureStopId ssid = fdp_.ConsumeRandomLengthString(kMaxByte);
+          int error_detail = fdp_.ConsumeIntegral<int32_t>();
+          cdm_engine->GetUsageInfo(app_id_, ssid,
+                                  fdp_.ConsumeBool() ? &error_detail : nullptr,
+                                  fdp_.ConsumeBool() ? &usage_report : nullptr);
         },
         [&]() {
-          CdmSecureStopId ssid = mFdp.ConsumeRandomLengthString(kMaxByte);
-          cdmEngine->RemoveUsageInfo(mAppId, ssid);
+          CdmSecureStopId ssid = fdp_.ConsumeRandomLengthString(kMaxByte);
+          cdm_engine->RemoveUsageInfo(app_id_, ssid);
         },
-        [&]() { cdmEngine->RemoveLicense(mSessionId); },
-        [&]() { cdmEngine->IsKeyLoaded(mKeyId); },
+        [&]() { cdm_engine->RemoveLicense(session_id_); },
+        [&]() { cdm_engine->IsKeyLoaded(key_id_); },
     });
-    invokeCdmEngineAPI();
+    invoke_cdm_engine_API();
   }
 
-  cdmEngine->Unprovision((CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(
+  cdm_engine->Unprovision((CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(
       kMinEnum, kMaxEnum));
 
-  cdmEngine->RemoveKeys(mSessionId);
+  cdm_engine->RemoveKeys(session_id_);
 
-  mOutCertFile1.close();
-  mOutCertFile2.close();
-  mOutUsageFile1.close();
-  mOutUsageFile2.close();
+  out_cert_file_1_.close();
+  out_cert_file_2_.close();
+  out_usage_file_1_.close();
+  out_usage_file_2_.close();
 
-  delete cdmEngine;
+  delete cdm_engine;
 }
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  CdmEngineFuzzer cdmEngineFuzzer(data, size);
-  cdmEngineFuzzer.process();
+  CdmEngineFuzzer cdm_engine_fuzzer(data, size);
+  cdm_engine_fuzzer.Process();
   return 0;
 }