diff --git a/fuzzer/policy_timers_fuzzer.cpp b/fuzzer/policy_timers_fuzzer.cpp
index fda9054c..106c6451 100644
--- a/fuzzer/policy_timers_fuzzer.cpp
+++ b/fuzzer/policy_timers_fuzzer.cpp
@@ -15,172 +15,169 @@
  *
  */
 
+#include <fuzzer/FuzzedDataProvider.h>
+
 #include "policy_timers.h"
 #include "policy_timers_v16.h"
 #include "policy_timers_v18.h"
 #include "wv_cdm_event_listener.h"
-#include <fuzzer/FuzzedDataProvider.h>
 
 using namespace wvcdm;
 using namespace video_widevine;
 
 class PolicyTimersFuzzer {
-public:
-    PolicyTimersFuzzer(const uint8_t* data, size_t size) : mFdp(data, size) {};
-    void process();
+ public:
+  PolicyTimersFuzzer(const uint8_t* data, size_t size) : fdp_(data, size){};
+  void Process();
 
-private:
-    FuzzedDataProvider mFdp;
-    License mLicense;
-    void setUp();
+ private:
+  FuzzedDataProvider fdp_;
+  License license_;
+  void SetUp();
 };
 
-void policySetBool(std::function<void(bool)> function,
-                   FuzzedDataProvider *fdp) {
+void PolicySetBool(std::function<void(bool)> function,
+                   FuzzedDataProvider* fdp) {
   if (fdp->ConsumeBool()) {
     function(fdp->ConsumeBool());
   }
 }
-void policySetInt64(std::function<void(int64_t)> function,
-                    FuzzedDataProvider *fdp) {
+void PolicySetInt64(std::function<void(int64_t)> function,
+                    FuzzedDataProvider* fdp) {
   if (fdp->ConsumeBool()) {
     function(fdp->ConsumeIntegral<int64_t>());
   }
 }
 
-void PolicyTimersFuzzer::setUp() {
-    License_Policy* policy = mLicense.mutable_policy();
-    policySetBool(
+void PolicyTimersFuzzer::SetUp() {
+  License_Policy* policy = license_.mutable_policy();
+  PolicySetBool(
       std::bind(&License_Policy::set_can_renew, policy, std::placeholders::_1),
-      &mFdp);
-    policySetInt64(std::bind(&License_Policy::set_renewal_delay_seconds, policy,
+      &fdp_);
+  PolicySetInt64(std::bind(&License_Policy::set_renewal_delay_seconds, policy,
                            std::placeholders::_1),
-                 &mFdp);
-    policySetBool(std::bind(&License_Policy::set_soft_enforce_playback_duration,
+                 &fdp_);
+  PolicySetBool(std::bind(&License_Policy::set_soft_enforce_playback_duration,
                           policy, std::placeholders::_1),
-                &mFdp);
-    policySetInt64(std::bind(&License_Policy::set_renewal_retry_interval_seconds,
+                &fdp_);
+  PolicySetInt64(std::bind(&License_Policy::set_renewal_retry_interval_seconds,
                            policy, std::placeholders::_1),
-                 &mFdp);
-    policySetInt64(std::bind(&License_Policy::set_license_duration_seconds,
+                 &fdp_);
+  PolicySetInt64(std::bind(&License_Policy::set_license_duration_seconds,
                            policy, std::placeholders::_1),
-                 &mFdp);
-    if (mFdp.ConsumeBool()) {
-    video_widevine::License::Policy::TimerDelayBase timeDelayBase =
+                 &fdp_);
+  if (fdp_.ConsumeBool()) {
+    video_widevine::License::Policy::TimerDelayBase time_delay_base =
         (video_widevine::License::Policy::TimerDelayBase)
-            mFdp.ConsumeIntegralInRange<uint8_t>(
+            fdp_.ConsumeIntegralInRange<uint8_t>(
                 License_Policy_TimerDelayBase_TIMER_DELAY_BASE_UNSPECIFIED,
                 License_Policy_TimerDelayBase_FIRST_DECRYPT);
-    policy->set_initial_renewal_delay_base(timeDelayBase);
-    }
-    if (mFdp.ConsumeBool()) {
-        policy->set_playback_duration_seconds(mFdp.ConsumeIntegral<int64_t>());
-    }
-    if (mFdp.ConsumeBool()) {
-        policy->set_rental_duration_seconds(mFdp.ConsumeIntegral<int64_t>());
-    }
-    if (mFdp.ConsumeBool()) {
-        policy->set_renewal_recovery_duration_seconds(mFdp.ConsumeIntegral<int64_t>());
-    }
-    if (mFdp.ConsumeBool()) {
-        policy->set_soft_enforce_rental_duration(mFdp.ConsumeBool());
-    }
-    if (mFdp.ConsumeBool()) {
-        policy->set_can_play(mFdp.ConsumeBool());
-    }
-    mLicense.set_license_start_time(mFdp.ConsumeIntegral<int64_t>());
+    policy->set_initial_renewal_delay_base(time_delay_base);
+  }
+  if (fdp_.ConsumeBool()) {
+    policy->set_playback_duration_seconds(fdp_.ConsumeIntegral<int64_t>());
+  }
+  if (fdp_.ConsumeBool()) {
+    policy->set_rental_duration_seconds(fdp_.ConsumeIntegral<int64_t>());
+  }
+  if (fdp_.ConsumeBool()) {
+    policy->set_renewal_recovery_duration_seconds(
+        fdp_.ConsumeIntegral<int64_t>());
+  }
+  if (fdp_.ConsumeBool()) {
+    policy->set_soft_enforce_rental_duration(fdp_.ConsumeBool());
+  }
+  if (fdp_.ConsumeBool()) {
+    policy->set_can_play(fdp_.ConsumeBool());
+  }
+  license_.set_license_start_time(fdp_.ConsumeIntegral<int64_t>());
 }
 
-void PolicyTimersFuzzer::process() {
-    std::unique_ptr<PolicyTimers> policyTimers;
-    if (mFdp.ConsumeBool()) {
-        policyTimers = std::make_unique<PolicyTimersV16>();
-    }
-    else {
-        policyTimers = std::make_unique<PolicyTimersV18>();
-    }
+void PolicyTimersFuzzer::Process() {
+  std::unique_ptr<PolicyTimers> policy_timers;
+  if (fdp_.ConsumeBool()) {
+    policy_timers = std::make_unique<PolicyTimersV16>();
+  } else {
+    policy_timers = std::make_unique<PolicyTimersV18>();
+  }
 
-    while (mFdp.remaining_bytes()) {
-        auto invokePolicyTimersAPI =
-            mFdp.PickValueInArray<const std::function<void()>>({
-                [&]() {
-                  setUp();
-                },
-                [&]() {
-                  policyTimers->SetLicense(mLicense);
-                },
-                [&]() {
-                  policyTimers->BeginDecryption(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/);
-                },
-                [&]() {
-                  policyTimers->DecryptionEvent(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/);
-                },
-                [&]() {
-                  policyTimers->RestorePlaybackTimes(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/,
-                      mFdp.ConsumeIntegral<int64_t>() /*playback_start_time*/,
-                      mFdp.ConsumeIntegral<int64_t>() /*last_playback_time*/,
-                      mFdp.ConsumeIntegral<int64_t>() /* grace_period_end_time */);
-                },
-                [&]() {
-                  policyTimers->GetLicenseOrRentalOrPlaybackDurationRemaining(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/);
-                },
-                [&]() {
-                  policyTimers->GetPlaybackDurationRemaining(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/);
-                },
-                [&]() {
-                  int64_t secondsSinceLastPlayed = mFdp.ConsumeIntegral<int64_t>();
-                  policyTimers->GetSecondsSinceStarted(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/,
-                      mFdp.ConsumeBool() ? &secondsSinceLastPlayed : nullptr);
-                },
-                [&]() {
-                  int64_t secondsSinceLastPlayed = mFdp.ConsumeIntegral<int64_t>();
-                  policyTimers->GetSecondsSinceLastPlayed(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/,
-                      mFdp.ConsumeBool() ? &secondsSinceLastPlayed : nullptr);
-                },
-                [&]() {
-                  policyTimers->IsLicenseForFuture(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/);
-                },
-                [&]() {
-                  int64_t expiryTime = mFdp.ConsumeIntegral<int64_t>();
-                  policyTimers->UpdateExpirationTime(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/,
-                      mFdp.ConsumeBool() ? &expiryTime : nullptr);
-                },
-                [&]() {
-                  policyTimers->HasRenewalRetryIntervalExpired(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/);
-                },
-                [&]() {
-                  policyTimers->UpdateRenewalRequest(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/);
-                },
-                [&]() {
-                  policyTimers->HasRenewalRecoveryDurationExpired(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/);
-                },
-                [&]() {
-                  policyTimers->HasRenewalDelayExpired(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/);
-                },
-                [&]() {
-                  policyTimers->UpdateLicense(
-                      mFdp.ConsumeIntegral<int64_t>() /*current_time*/, mLicense);
-                },
-            });
-        invokePolicyTimersAPI();
-    }
+  while (fdp_.remaining_bytes()) {
+    auto invoke_policy_timers_API =
+        fdp_.PickValueInArray<const std::function<void()>>({
+            [&]() { SetUp(); },
+            [&]() { policy_timers->SetLicense(license_); },
+            [&]() {
+              policy_timers->BeginDecryption(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
+            },
+            [&]() {
+              policy_timers->DecryptionEvent(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
+            },
+            [&]() {
+              policy_timers->RestorePlaybackTimes(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/,
+                  fdp_.ConsumeIntegral<int64_t>() /*playback_start_time*/,
+                  fdp_.ConsumeIntegral<int64_t>() /*last_playback_time*/,
+                  fdp_.ConsumeIntegral<int64_t>() /* grace_period_end_time */);
+            },
+            [&]() {
+              policy_timers->GetLicenseOrRentalOrPlaybackDurationRemaining(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
+            },
+            [&]() {
+              policy_timers->GetPlaybackDurationRemaining(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
+            },
+            [&]() {
+              int64_t seconds_since_last_played = fdp_.ConsumeIntegral<int64_t>();
+              policy_timers->GetSecondsSinceStarted(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/,
+                  fdp_.ConsumeBool() ? &seconds_since_last_played : nullptr);
+            },
+            [&]() {
+              int64_t seconds_since_last_played = fdp_.ConsumeIntegral<int64_t>();
+              policy_timers->GetSecondsSinceLastPlayed(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/,
+                  fdp_.ConsumeBool() ? &seconds_since_last_played : nullptr);
+            },
+            [&]() {
+              policy_timers->IsLicenseForFuture(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
+            },
+            [&]() {
+              int64_t expiry_time = fdp_.ConsumeIntegral<int64_t>();
+              policy_timers->UpdateExpirationTime(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/,
+                  fdp_.ConsumeBool() ? &expiry_time : nullptr);
+            },
+            [&]() {
+              policy_timers->HasRenewalRetryIntervalExpired(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
+            },
+            [&]() {
+              policy_timers->UpdateRenewalRequest(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
+            },
+            [&]() {
+              policy_timers->HasRenewalRecoveryDurationExpired(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
+            },
+            [&]() {
+              policy_timers->HasRenewalDelayExpired(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
+            },
+            [&]() {
+              policy_timers->UpdateLicense(
+                  fdp_.ConsumeIntegral<int64_t>() /*current_time*/, license_);
+            },
+        });
+    invoke_policy_timers_API();
+  }
 }
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t * data, size_t size) {
-    PolicyTimersFuzzer policyTimersFuzzer(data, size);
-    policyTimersFuzzer.process();
-    return 0;
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  PolicyTimersFuzzer policy_timers_fuzzer(data, size);
+  policy_timers_fuzzer.Process();
+  return 0;
 }