Reformat wv core/src files

[ Merge of http://go/wvgerrit/80484 ] Clang-format has been run on files in core/src. clang-format has been turned off for some blocks but otherwise no other changes have been made. Bug: 134365840 Test: WV unit/integration tests Change-Id: I6e509f25136f84d37de3d920084302f0f2c23dc4
2019-06-03 17:14:18 -07:00
parent 47c2068d6a
commit a178eed57d
20 changed files with 713 additions and 760 deletions
--- a/libwvdrmengine/cdm/core/src/cdm_engine.cpp
+++ b/libwvdrmengine/cdm/core/src/cdm_engine.cpp
@@ -24,7 +24,7 @@
 #include "wv_cdm_event_listener.h"

 namespace {
-const uint64_t kReleaseSessionTimeToLive = 60;  // seconds
+const uint64_t kReleaseSessionTimeToLive = 60;      // seconds
 const uint32_t kUpdateUsageInformationPeriod = 60;  // seconds
 const size_t kUsageReportsPerRequest = 1;

@@ -96,23 +96,27 @@ CdmEngine::~CdmEngine() {
  session_map_.Terminate();
 }

-CdmResponseType CdmEngine::OpenSession(
-    const CdmKeySystem& key_system, CdmClientPropertySet* property_set,
-    const CdmSessionId& forced_session_id, WvCdmEventListener* event_listener) {
+CdmResponseType CdmEngine::OpenSession(const CdmKeySystem& key_system,
+                                       CdmClientPropertySet* property_set,
+                                       const CdmSessionId& forced_session_id,
+                                       WvCdmEventListener* event_listener) {
  return OpenSession(key_system, property_set, event_listener,
                     &forced_session_id, NULL);
 }

-CdmResponseType CdmEngine::OpenSession(
-    const CdmKeySystem& key_system, CdmClientPropertySet* property_set,
-    WvCdmEventListener* event_listener, CdmSessionId* session_id) {
-  return OpenSession(key_system, property_set, event_listener, NULL, session_id);
+CdmResponseType CdmEngine::OpenSession(const CdmKeySystem& key_system,
+                                       CdmClientPropertySet* property_set,
+                                       WvCdmEventListener* event_listener,
+                                       CdmSessionId* session_id) {
+  return OpenSession(key_system, property_set, event_listener, NULL,
+                     session_id);
 }

-CdmResponseType CdmEngine::OpenSession(
-    const CdmKeySystem& key_system, CdmClientPropertySet* property_set,
-    WvCdmEventListener* event_listener, const CdmSessionId* forced_session_id,
-    CdmSessionId* session_id) {
+CdmResponseType CdmEngine::OpenSession(const CdmKeySystem& key_system,
+                                       CdmClientPropertySet* property_set,
+                                       WvCdmEventListener* event_listener,
+                                       const CdmSessionId* forced_session_id,
+                                       CdmSessionId* session_id) {
  LOGI("CdmEngine::OpenSession");

  if (!ValidateKeySystem(key_system)) {
@@ -135,15 +139,14 @@ CdmResponseType CdmEngine::OpenSession(

  std::unique_ptr<CdmSession> new_session(
      new CdmSession(file_system_, metrics_->AddSession()));
-  CdmResponseType sts = new_session->Init(property_set, forced_session_id,
-                                          event_listener);
+  CdmResponseType sts =
+      new_session->Init(property_set, forced_session_id, event_listener);
  if (sts != NO_ERROR) {
    if (sts == NEED_PROVISIONING) {
      cert_provisioning_requested_security_level_ =
          new_session->GetRequestedSecurityLevel();
      // Reserve a session ID so the CDM can return success.
-      if (session_id)
-        *session_id = new_session->GenerateSessionId();
+      if (session_id) *session_id = new_session->GenerateSessionId();
    } else {
      LOGE("CdmEngine::OpenSession: bad session init: %d", sts);
    }
@@ -176,8 +179,7 @@ CdmResponseType CdmEngine::OpenKeySetSession(
    key_set_in_use =
        release_key_sets_.find(key_set_id) != release_key_sets_.end();
  }
-  if (key_set_in_use)
-    CloseKeySetSession(key_set_id);
+  if (key_set_in_use) CloseKeySetSession(key_set_id);

  CdmSessionId session_id;
  CdmResponseType sts = OpenSession(KEY_SYSTEM, property_set, event_listener,
@@ -186,8 +188,8 @@ CdmResponseType CdmEngine::OpenKeySetSession(
  if (sts != NO_ERROR) return sts;

  std::unique_lock<std::mutex> lock(release_key_sets_lock_);
-  release_key_sets_[key_set_id] = std::make_pair(session_id,
-      clock_.GetCurrentTime() + kReleaseSessionTimeToLive);
+  release_key_sets_[key_set_id] = std::make_pair(
+      session_id, clock_.GetCurrentTime() + kReleaseSessionTimeToLive);

  return NO_ERROR;
 }
@@ -283,16 +285,17 @@ CdmResponseType CdmEngine::GenerateKeyRequest(

  key_request->message.clear();

-  if (license_type == kLicenseTypeRelease &&
-      !session->license_received()) {
+  if (license_type == kLicenseTypeRelease && !session->license_received()) {
    int error_detail = NO_ERROR;
    sts = session->RestoreOfflineSession(key_set_id, kLicenseTypeRelease,
                                         &error_detail);
    session->GetMetrics()->cdm_session_restore_offline_session_.Increment(
        sts, error_detail);
    if (sts != KEY_ADDED) {
-      LOGE("CdmEngine::GenerateKeyRequest: key release restoration failed,"
-           "sts = %d", static_cast<int>(sts));
+      LOGE(
+          "CdmEngine::GenerateKeyRequest: key release restoration failed,"
+          "sts = %d",
+          static_cast<int>(sts));
      return sts;
    }
  }
@@ -307,8 +310,10 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
      cert_provisioning_requested_security_level_ =
          session->GetRequestedSecurityLevel();
    }
-    LOGE("CdmEngine::GenerateKeyRequest: key request generation failed, "
-         "sts = %d", static_cast<int>(sts));
+    LOGE(
+        "CdmEngine::GenerateKeyRequest: key request generation failed, "
+        "sts = %d",
+        static_cast<int>(sts));
    return sts;
  }

@@ -325,8 +330,8 @@ CdmResponseType CdmEngine::AddKey(const CdmSessionId& session_id,
                                  CdmKeySetId* key_set_id) {
  LOGI("CdmEngine::AddKey: %s", session_id.c_str());
  if (license_type == nullptr) {
-      LOGE("CdmEngine::AddKey: license_type cannot be null.");
-      return PARAMETER_NULL;
+    LOGE("CdmEngine::AddKey: license_type cannot be null.");
+    return PARAMETER_NULL;
  }

  CdmSessionId id = session_id;
@@ -364,7 +369,6 @@ CdmResponseType CdmEngine::AddKey(const CdmSessionId& session_id,
    return EMPTY_KEY_DATA_1;
  }

-
  CdmResponseType sts = (session->AddKey(key_data));

  if (sts == KEY_ADDED) {
@@ -380,8 +384,8 @@ CdmResponseType CdmEngine::AddKey(const CdmSessionId& session_id,
  }

  if (key_set_id) {
-    if ((session->is_offline() ||
-         session->has_provider_session_token()) && !license_type_release) {
+    if ((session->is_offline() || session->has_provider_session_token()) &&
+        !license_type_release) {
      *key_set_id = session->key_set_id();
      LOGI("CdmEngine::AddKey: key set ID: %s", key_set_id->c_str());
    } else {
@@ -508,12 +512,8 @@ CdmResponseType CdmEngine::RenewKey(const CdmSessionId& session_id,
  }

  CdmResponseType sts;
-  M_TIME(
-      sts = session->RenewKey(
-          key_data),
-      session->GetMetrics(),
-      cdm_session_renew_key_,
-      sts);
+  M_TIME(sts = session->RenewKey(key_data), session->GetMetrics(),
+         cdm_session_renew_key_, sts);

  if (KEY_ADDED != sts) {
    LOGE("CdmEngine::RenewKey: keys not added, sts=%d", static_cast<int>(sts));
@@ -571,24 +571,23 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
      LOGW("CdmEngine::QueryStatus: GetHdcpCapabilities failed: %d", status);
      return status;
    }
-    *query_response =
-        MapHdcpVersion(query_token == QUERY_KEY_CURRENT_HDCP_LEVEL ?
-                       current_hdcp : max_hdcp);
+    *query_response = MapHdcpVersion(
+        query_token == QUERY_KEY_CURRENT_HDCP_LEVEL ? current_hdcp : max_hdcp);
    return NO_ERROR;
  } else if (query_token == QUERY_KEY_USAGE_SUPPORT) {
    bool supports_usage_reporting;
    bool got_info = crypto_session->UsageInformationSupport(
-        security_level,
-        &supports_usage_reporting);
+        security_level, &supports_usage_reporting);

    if (!got_info) {
      LOGW("CdmEngine::QueryStatus: UsageInformationSupport failed");
-      metrics_->GetCryptoMetrics()->crypto_session_usage_information_support_
-          .SetError(got_info);
+      metrics_->GetCryptoMetrics()
+          ->crypto_session_usage_information_support_.SetError(got_info);
      return UNKNOWN_ERROR;
    }
-    metrics_->GetCryptoMetrics()->crypto_session_usage_information_support_
-        .Record(supports_usage_reporting);
+    metrics_->GetCryptoMetrics()
+        ->crypto_session_usage_information_support_.Record(
+            supports_usage_reporting);

    *query_response =
        supports_usage_reporting ? QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
@@ -607,9 +606,8 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
    return NO_ERROR;
  } else if (query_token == QUERY_KEY_MAX_NUMBER_OF_SESSIONS) {
    size_t maximum_number_of_sessions = 0;
-    status =
-        crypto_session->GetMaxNumberOfSessions(security_level,
-                                               &maximum_number_of_sessions);
+    status = crypto_session->GetMaxNumberOfSessions(
+        security_level, &maximum_number_of_sessions);

    if (status != NO_ERROR) {
      LOGW("CdmEngine::QueryStatus: GetMaxNumberOfOpenSessions failed: %d",
@@ -671,18 +669,14 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
    }
    return NO_ERROR;
  } else if (query_token == QUERY_KEY_DECRYPT_HASH_SUPPORT) {
-    *query_response = std::to_string(crypto_session->IsDecryptHashSupported(
-        security_level));
+    *query_response =
+        std::to_string(crypto_session->IsDecryptHashSupported(security_level));
    return NO_ERROR;
  }

-  M_TIME(
-      status = crypto_session->Open(
-          security_level),
-      metrics_->GetCryptoMetrics(),
-      crypto_session_open_,
-      status,
-      security_level);
+  M_TIME(status = crypto_session->Open(security_level),
+         metrics_->GetCryptoMetrics(), crypto_session_open_, status,
+         security_level);

  if (status != NO_ERROR) return status;

@@ -690,8 +684,8 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
  if (query_token == QUERY_KEY_DEVICE_ID) {
    std::string deviceId;
    status = crypto_session->GetExternalDeviceUniqueId(&deviceId);
-    metrics_->GetCryptoMetrics()->crypto_session_get_device_unique_id_
-        .Increment(status);
+    metrics_->GetCryptoMetrics()
+        ->crypto_session_get_device_unique_id_.Increment(status);
    if (status != NO_ERROR) return status;

    *query_response = deviceId;
@@ -800,8 +794,8 @@ CdmResponseType CdmEngine::QueryKeyAllowedUsage(const std::string& key_id,
  CdmSessionList sessions;
  session_map_.GetSessionList(sessions);

-  for (CdmSessionList::iterator iter = sessions.begin();
-       iter != sessions.end(); ++iter) {
+  for (CdmSessionList::iterator iter = sessions.begin(); iter != sessions.end();
+       ++iter) {
    session_sts = (*iter)->QueryKeyAllowedUsage(key_id, &found_in_this_session);
    if (session_sts == NO_ERROR) {
      if (found) {
@@ -844,8 +838,8 @@ bool CdmEngine::IsSecurityLevelSupported(CdmSecurityLevel level) {

  switch (level) {
    case kSecurityLevelL1:
-      return
-          crypto_session->GetSecurityLevel(kLevelDefault) == kSecurityLevelL1;
+      return crypto_session->GetSecurityLevel(kLevelDefault) ==
+             kSecurityLevelL1;
    case kSecurityLevelL3:
      return crypto_session->GetSecurityLevel(kLevel3) == kSecurityLevelL3;
    default:
@@ -917,8 +911,9 @@ CdmResponseType CdmEngine::HandleProvisioningResponse(
    return INVALID_PROVISIONING_PARAMETERS_1;
  }
  if (wrapped_key == NULL) {
-    LOGE("CdmEngine::HandleProvisioningResponse: invalid wrapped key "
-         "destination");
+    LOGE(
+        "CdmEngine::HandleProvisioningResponse: invalid wrapped key "
+        "destination");
    cert_provisioning_.reset(NULL);
    return INVALID_PROVISIONING_PARAMETERS_2;
  }
@@ -928,13 +923,10 @@ CdmResponseType CdmEngine::HandleProvisioningResponse(
    std::unique_ptr<CryptoSession> crypto_session(
        CryptoSession::MakeCryptoSession(metrics_->GetCryptoMetrics()));
    CdmResponseType status;
-    M_TIME(
-        status = crypto_session->Open(
-            cert_provisioning_requested_security_level_),
-        metrics_->GetCryptoMetrics(),
-        crypto_session_open_,
-        status,
-        cert_provisioning_requested_security_level_);
+    M_TIME(status = crypto_session->Open(
+               cert_provisioning_requested_security_level_),
+           metrics_->GetCryptoMetrics(), crypto_session_open_, status,
+           cert_provisioning_requested_security_level_);
    if (NO_ERROR != status) {
      LOGE(
          "CdmEngine::HandleProvisioningResponse: provisioning object "
@@ -967,7 +959,7 @@ bool CdmEngine::IsProvisioned(CdmSecurityLevel security_level) {
  // attempts to load it. If this fails, initialization will return an error.
  UsagePropertySet property_set;
  property_set.set_security_level(
-    security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault);
+      security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault);

  CdmSession session(file_system_, metrics_->AddSession());

@@ -986,8 +978,8 @@ CdmResponseType CdmEngine::Unprovision(CdmSecurityLevel security_level) {
      CryptoSession::MakeCryptoSession(metrics_->GetCryptoMetrics()));
  CdmClientTokenType token_type = kClientTokenUninitialized;
  CdmResponseType res = crypto_session->GetProvisioningMethod(
-    security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault,
-    &token_type);
+      security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault,
+      &token_type);
  if (res != NO_ERROR) {
    return res;
  } else if (token_type == kClientTokenDrmCert) {
@@ -1020,23 +1012,18 @@ CdmResponseType CdmEngine::DeleteUsageTable(CdmSecurityLevel security_level) {
  std::unique_ptr<CryptoSession> crypto_session(
      CryptoSession::MakeCryptoSession(metrics_->GetCryptoMetrics()));
  CdmResponseType status;
-  M_TIME(
-      status = crypto_session->Open(
-          security_level == kSecurityLevelL3 ?
-              kLevel3 :
-              kLevelDefault),
-      metrics_->GetCryptoMetrics(),
-      crypto_session_open_,
-      status,
-      security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault);
+  M_TIME(status = crypto_session->Open(
+             security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault),
+         metrics_->GetCryptoMetrics(), crypto_session_open_, status,
+         security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault);
  if (NO_ERROR != status) {
    LOGE("CdmEngine::DeleteUsageTable: error opening crypto session: %d",
-       status);
+         status);
    return UNPROVISION_ERROR_4;
  }
  status = crypto_session->DeleteAllUsageReports();
-  metrics_->GetCryptoMetrics()->crypto_session_delete_all_usage_reports_
-      .Increment(status);
+  metrics_->GetCryptoMetrics()
+      ->crypto_session_delete_all_usage_reports_.Increment(status);
  if (status != NO_ERROR) {
    LOGE("CdmEngine::DeleteUsageTable: error deleteing usage reports: %d",
         status);
@@ -1063,8 +1050,7 @@ CdmResponseType CdmEngine::ListStoredLicenses(
 }

 CdmResponseType CdmEngine::ListUsageIds(
-    const std::string& app_id,
-    CdmSecurityLevel security_level,
+    const std::string& app_id, CdmSecurityLevel security_level,
    std::vector<std::string>* ksids,
    std::vector<std::string>* provider_session_tokens) {
  DeviceFiles handle(file_system_);
@@ -1105,8 +1091,7 @@ CdmResponseType CdmEngine::DeleteUsageRecord(const std::string& app_id,
 }

 CdmResponseType CdmEngine::GetOfflineLicenseState(
-    const CdmKeySetId &key_set_id,
-    CdmSecurityLevel security_level,
+    const CdmKeySetId& key_set_id, CdmSecurityLevel security_level,
    CdmOfflineLicenseState* license_state) {
  DeviceFiles handle(file_system_);
  if (!handle.Init(security_level)) {
@@ -1132,33 +1117,31 @@ CdmResponseType CdmEngine::GetOfflineLicenseState(
  uint32_t usage_entry_number;
  DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;

-  if (handle.RetrieveLicense(key_set_id, &state, &offline_init_data,
-          &key_request, &key_response,
+  if (handle.RetrieveLicense(
+          key_set_id, &state, &offline_init_data, &key_request, &key_response,
          &offline_key_renewal_request, &offline_key_renewal_response,
-          &offline_release_server_url,
-          &playback_start_time, &last_playback_time, &grace_period_end_time,
-          &app_parameters, &usage_entry, &usage_entry_number,
-          &sub_error_code)) {
-      *license_state = MapDeviceFilesLicenseState(state);
+          &offline_release_server_url, &playback_start_time,
+          &last_playback_time, &grace_period_end_time, &app_parameters,
+          &usage_entry, &usage_entry_number, &sub_error_code)) {
+    *license_state = MapDeviceFilesLicenseState(state);
  } else {
-    LOGE("CdmEngine::GetOfflineLicenseState:: failed to retrieve license state "
-         "key set id = %s",
-         key_set_id.c_str());
-         return GET_OFFLINE_LICENSE_STATE_ERROR_2;
+    LOGE(
+        "CdmEngine::GetOfflineLicenseState:: failed to retrieve license state "
+        "key set id = %s",
+        key_set_id.c_str());
+    return GET_OFFLINE_LICENSE_STATE_ERROR_2;
  }
  return NO_ERROR;
 }

 CdmResponseType CdmEngine::RemoveOfflineLicense(
-    const CdmKeySetId &key_set_id,
-    CdmSecurityLevel security_level) {
-
+    const CdmKeySetId& key_set_id, CdmSecurityLevel security_level) {
  UsagePropertySet property_set;
  property_set.set_security_level(
      security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault);
  DeviceFiles handle(file_system_);
-  CdmResponseType sts = OpenKeySetSession(key_set_id,
-      &property_set, nullptr /* event listener */);
+  CdmResponseType sts = OpenKeySetSession(key_set_id, &property_set,
+                                          nullptr /* event listener */);
  if (sts != NO_ERROR) {
    if (!handle.Init(security_level)) {
      LOGE("CdmEngine::RemoveOfflineLicense: cannot initialize device files");
@@ -1173,7 +1156,7 @@ CdmResponseType CdmEngine::RemoveOfflineLicense(
  CdmKeyRequest key_request;
  // Calling with no session_id is okay
  sts = GenerateKeyRequest(session_id, key_set_id, dummy_init_data,
-          kLicenseTypeRelease, dummy_app_params, &key_request);
+                           kLicenseTypeRelease, dummy_app_params, &key_request);
  if (sts == KEY_MESSAGE) {
    std::unique_lock<std::mutex> lock(release_key_sets_lock_);
    CdmReleaseKeySetMap::iterator iter = release_key_sets_.find(key_set_id);
@@ -1226,8 +1209,8 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
  CdmKeyResponse license_response;
  std::string usage_entry;
  DeviceFiles::CdmUsageData usage_data;
-  if (!handle.RetrieveUsageInfo(DeviceFiles::GetUsageInfoFileName(app_id),
-                                ssid, &usage_data)) {
+  if (!handle.RetrieveUsageInfo(DeviceFiles::GetUsageInfoFileName(app_id), ssid,
+                                &usage_data)) {
    usage_property_set_->set_security_level(kLevel3);
    usage_property_set_->set_app_id(app_id);
    usage_session_.reset(new CdmSession(file_system_, metrics_->AddSession()));
@@ -1376,8 +1359,8 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,

 CdmResponseType CdmEngine::RemoveAllUsageInfo(
    const std::string& app_id, CdmSecurityLevel cdm_security_level) {
-  LOGI("CdmEngine::RemoveAllUsageInfo: %s, security level: %d",
-       app_id.c_str(), cdm_security_level);
+  LOGI("CdmEngine::RemoveAllUsageInfo: %s, security level: %d", app_id.c_str(),
+       cdm_security_level);
  if (usage_property_set_.get() == nullptr) {
    usage_property_set_.reset(new UsagePropertySet());
  }
@@ -1400,36 +1383,38 @@ CdmResponseType CdmEngine::RemoveAllUsageInfo(
        // might cause other entries to be shifted and information updated.
        do {
          if (!handle.RetrieveUsageInfo(
-              DeviceFiles::GetUsageInfoFileName(app_id),
-              &usage_data)) {
-            LOGW("CdmEngine::RemoveAllUsageInfo: failed to retrieve usage info");
+                  DeviceFiles::GetUsageInfoFileName(app_id), &usage_data)) {
+            LOGW(
+                "CdmEngine::RemoveAllUsageInfo: failed to retrieve usage info");
            break;
          }

          if (usage_data.empty()) break;

          CdmResponseType res = usage_session_->DeleteUsageEntry(
-            usage_data[0].usage_entry_number);
+              usage_data[0].usage_entry_number);

          if (res != NO_ERROR) {
-            LOGW("CdmEngine::RemoveAllUsageInfo: failed to delete usage "
-                 "entry: error: %d", res);
+            LOGW(
+                "CdmEngine::RemoveAllUsageInfo: failed to delete usage "
+                "entry: error: %d",
+                res);
            break;
          }

-          if (!handle.DeleteUsageInfo(
-              DeviceFiles::GetUsageInfoFileName(app_id),
-              usage_data[0].provider_session_token)) {
-            LOGW("CdmEngine::RemoveAllUsageInfo: failed to delete usage "
-                 "info");
+          if (!handle.DeleteUsageInfo(DeviceFiles::GetUsageInfoFileName(app_id),
+                                      usage_data[0].provider_session_token)) {
+            LOGW(
+                "CdmEngine::RemoveAllUsageInfo: failed to delete usage "
+                "info");
            break;
          }
        } while (!usage_data.empty());

        std::vector<std::string> provider_session_tokens;
        if (!handle.DeleteAllUsageInfoForApp(
-            DeviceFiles::GetUsageInfoFileName(app_id),
-            &provider_session_tokens)) {
+                DeviceFiles::GetUsageInfoFileName(app_id),
+                &provider_session_tokens)) {
          status = REMOVE_ALL_USAGE_INFO_ERROR_5;
        }
        break;
@@ -1437,14 +1422,17 @@ CdmResponseType CdmEngine::RemoveAllUsageInfo(
      case kUsageTableSupport: {
        std::vector<std::string> provider_session_tokens;
        if (!handle.DeleteAllUsageInfoForApp(
-            DeviceFiles::GetUsageInfoFileName(app_id),
-            &provider_session_tokens)) {
-          LOGE("CdmEngine::RemoveAllUsageInfo: failed to delete %d secure"
-              "stops", cdm_security_level);
+                DeviceFiles::GetUsageInfoFileName(app_id),
+                &provider_session_tokens)) {
+          LOGE(
+              "CdmEngine::RemoveAllUsageInfo: failed to delete %d secure"
+              "stops",
+              cdm_security_level);
          status = REMOVE_ALL_USAGE_INFO_ERROR_1;
        } else {
-          CdmResponseType status2 = usage_session_->
-              DeleteMultipleUsageInformation(provider_session_tokens);
+          CdmResponseType status2 =
+              usage_session_->DeleteMultipleUsageInformation(
+                  provider_session_tokens);
          if (status2 != NO_ERROR) status = status2;
        }
        break;
@@ -1468,8 +1456,7 @@ CdmResponseType CdmEngine::RemoveAllUsageInfo(const std::string& app_id) {
 }

 CdmResponseType CdmEngine::RemoveUsageInfo(
-    const std::string& app_id,
-    const CdmSecureStopId& provider_session_token) {
+    const std::string& app_id, const CdmSecureStopId& provider_session_token) {
  LOGI("CdmEngine::RemoveUsageInfo: %s, PST: %s", app_id.c_str(),
       provider_session_token.c_str());
  if (NULL == usage_property_set_.get()) {
@@ -1482,11 +1469,11 @@ CdmResponseType CdmEngine::RemoveUsageInfo(
    DeviceFiles handle(file_system_);
    if (handle.Init(static_cast<CdmSecurityLevel>(j))) {
      SecurityLevel security_level =
-          static_cast<CdmSecurityLevel>(j) == kSecurityLevelL3
-              ? kLevel3
-              : kLevelDefault;
+          static_cast<CdmSecurityLevel>(j) == kSecurityLevelL3 ? kLevel3
+                                                               : kLevelDefault;
      usage_property_set_->set_security_level(security_level);
-      usage_session_.reset(new CdmSession(file_system_, metrics_->AddSession()));
+      usage_session_.reset(
+          new CdmSession(file_system_, metrics_->AddSession()));
      usage_session_->Init(usage_property_set_.get());

      std::vector<DeviceFiles::CdmUsageData> usage_data;
@@ -1495,10 +1482,10 @@ CdmResponseType CdmEngine::RemoveUsageInfo(
      CdmUsageEntry usage_entry;
      uint32_t usage_entry_number;

-      if (!handle.RetrieveUsageInfo(
-          DeviceFiles::GetUsageInfoFileName(app_id), provider_session_token,
-          &license_request, &license_response, &usage_entry,
-          &usage_entry_number)) {
+      if (!handle.RetrieveUsageInfo(DeviceFiles::GetUsageInfoFileName(app_id),
+                                    provider_session_token, &license_request,
+                                    &license_response, &usage_entry,
+                                    &usage_entry_number)) {
        // Try other security level
        continue;
      }
@@ -1507,24 +1494,23 @@ CdmResponseType CdmEngine::RemoveUsageInfo(
        case kUsageEntrySupport: {
          status = usage_session_->DeleteUsageEntry(usage_entry_number);

-          if (!handle.DeleteUsageInfo(
-                DeviceFiles::GetUsageInfoFileName(app_id),
-                provider_session_token)) {
-              status = REMOVE_USAGE_INFO_ERROR_1;
+          if (!handle.DeleteUsageInfo(DeviceFiles::GetUsageInfoFileName(app_id),
+                                      provider_session_token)) {
+            status = REMOVE_USAGE_INFO_ERROR_1;
          }
          usage_session_.reset(NULL);
          return status;
        }
        case kUsageTableSupport: {
          std::vector<std::string> provider_session_tokens;
-          handle.DeleteUsageInfo(
-              DeviceFiles::GetUsageInfoFileName(app_id),
-              provider_session_token);
+          handle.DeleteUsageInfo(DeviceFiles::GetUsageInfoFileName(app_id),
+                                 provider_session_token);
          std::unique_ptr<CryptoSession> crypto_session(
              CryptoSession::MakeCryptoSession(metrics_->GetCryptoMetrics()));
-          status = crypto_session->Open(
-              static_cast<CdmSecurityLevel>(j) == kSecurityLevelL3
-              ? kLevel3 : kLevelDefault);
+          status = crypto_session->Open(static_cast<CdmSecurityLevel>(j) ==
+                                                kSecurityLevelL3
+                                            ? kLevel3
+                                            : kLevelDefault);
          if (status == NO_ERROR) {
            crypto_session->UpdateUsageInformation();
            status =
@@ -1598,19 +1584,18 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,

  DeviceFiles::CdmUsageData usage_data;
  if (!handle.RetrieveUsageInfoByKeySetId(
-                  DeviceFiles::GetUsageInfoFileName(app_id), key_set_id,
-                  &(usage_data.provider_session_token),
-                  &(usage_data.license_request),
-                  &(usage_data.license), &(usage_data.usage_entry),
-                  &(usage_data.usage_entry_number))) {
+          DeviceFiles::GetUsageInfoFileName(app_id), key_set_id,
+          &(usage_data.provider_session_token), &(usage_data.license_request),
+          &(usage_data.license), &(usage_data.usage_entry),
+          &(usage_data.usage_entry_number))) {
    LOGE("CdmEngine::LoadUsageSession: unable to find usage information");
    return LOAD_USAGE_INFO_MISSING;
  }

  int error_detail = NO_ERROR;
  usage_data.key_set_id = key_set_id;
-  CdmResponseType status = session->RestoreUsageSession(usage_data,
-                                                        &error_detail);
+  CdmResponseType status =
+      session->RestoreUsageSession(usage_data, &error_detail);
  session->GetMetrics()->cdm_session_restore_usage_session_.Increment(
      status, error_detail);
  if (KEY_ADDED != status) {
@@ -1698,10 +1683,12 @@ CdmResponseType CdmEngine::Decrypt(const CdmSessionId& session_id,
  return session->Decrypt(parameters);
 }

-CdmResponseType CdmEngine::GenericEncrypt(
-      const std::string& session_id, const std::string& in_buffer,
-      const std::string& key_id, const std::string& iv,
-      CdmEncryptionAlgorithm algorithm, std::string* out_buffer) {
+CdmResponseType CdmEngine::GenericEncrypt(const std::string& session_id,
+                                          const std::string& in_buffer,
+                                          const std::string& key_id,
+                                          const std::string& iv,
+                                          CdmEncryptionAlgorithm algorithm,
+                                          std::string* out_buffer) {
  if (out_buffer == NULL) {
    LOGE("CdmEngine::GenericEncrypt: no out_buffer provided");
    return PARAMETER_NULL;
@@ -1715,11 +1702,12 @@ CdmResponseType CdmEngine::GenericEncrypt(
  return session->GenericEncrypt(in_buffer, key_id, iv, algorithm, out_buffer);
 }

-CdmResponseType CdmEngine::GenericDecrypt(
-      const std::string& session_id, const std::string& in_buffer,
-      const std::string& key_id, const std::string& iv,
-      CdmEncryptionAlgorithm algorithm,
-      std::string* out_buffer) {
+CdmResponseType CdmEngine::GenericDecrypt(const std::string& session_id,
+                                          const std::string& in_buffer,
+                                          const std::string& key_id,
+                                          const std::string& iv,
+                                          CdmEncryptionAlgorithm algorithm,
+                                          std::string* out_buffer) {
  if (out_buffer == NULL) {
    LOGE("CdmEngine::GenericDecrypt: no out_buffer provided");
    return PARAMETER_NULL;
@@ -1733,10 +1721,11 @@ CdmResponseType CdmEngine::GenericDecrypt(
  return session->GenericDecrypt(in_buffer, key_id, iv, algorithm, out_buffer);
 }

-CdmResponseType CdmEngine::GenericSign(
-    const std::string& session_id, const std::string& message,
-    const std::string& key_id, CdmSigningAlgorithm algorithm,
-    std::string* signature) {
+CdmResponseType CdmEngine::GenericSign(const std::string& session_id,
+                                       const std::string& message,
+                                       const std::string& key_id,
+                                       CdmSigningAlgorithm algorithm,
+                                       std::string* signature) {
  if (signature == NULL) {
    LOGE("CdmEngine::GenericSign: no signature buffer provided");
    return PARAMETER_NULL;
@@ -1750,10 +1739,11 @@ CdmResponseType CdmEngine::GenericSign(
  return session->GenericSign(message, key_id, algorithm, signature);
 }

-CdmResponseType CdmEngine::GenericVerify(
-    const std::string& session_id, const std::string& message,
-    const std::string& key_id, CdmSigningAlgorithm algorithm,
-    const std::string& signature) {
+CdmResponseType CdmEngine::GenericVerify(const std::string& session_id,
+                                         const std::string& message,
+                                         const std::string& key_id,
+                                         CdmSigningAlgorithm algorithm,
+                                         const std::string& signature) {
  std::shared_ptr<CdmSession> session;
  if (!session_map_.FindSession(session_id, &session)) {
    LOGE("CdmEngine::GenericVerify: session_id not found = %s ",
@@ -1764,10 +1754,8 @@ CdmResponseType CdmEngine::GenericVerify(
 }

 CdmResponseType CdmEngine::ParseDecryptHashString(
-    const std::string& hash_string,
-    CdmSessionId* session_id,
-    uint32_t* frame_number,
-    std::string* hash) {
+    const std::string& hash_string, CdmSessionId* session_id,
+    uint32_t* frame_number, std::string* hash) {
  if (session_id == nullptr) {
    LOGE("CdmEngine::ParseDecryptHashString: |session_id| was not provided");
    return PARAMETER_NULL;
@@ -1788,16 +1776,19 @@ CdmResponseType CdmEngine::ParseDecryptHashString(
    tokens.push_back(token);
  }
  if (tokens.size() != 3) {
-    LOGE("CdmEngine::ParseDecryptHashString: |hash_string| has invalid format, "
-         "unexpected number of tokens: %d (%s)",
-         tokens.size(), hash_string.c_str());
+    LOGE(
+        "CdmEngine::ParseDecryptHashString: |hash_string| has invalid format, "
+        "unexpected number of tokens: %d (%s)",
+        tokens.size(), hash_string.c_str());
    return INVALID_DECRYPT_HASH_FORMAT;
  }

  for (size_t i = 0; i < tokens.size(); ++i) {
    if (tokens[i].empty()) {
-      LOGE("CdmEngine::ParseDecryptHashString: |hash_string| has invalid "
-           "format, token %d of length 0: %s", i, hash_string.c_str());
+      LOGE(
+          "CdmEngine::ParseDecryptHashString: |hash_string| has invalid "
+          "format, token %d of length 0: %s",
+          i, hash_string.c_str());
      return INVALID_DECRYPT_HASH_FORMAT;
    }
  }
@@ -1805,8 +1796,10 @@ CdmResponseType CdmEngine::ParseDecryptHashString(
  *session_id = tokens[0];
  std::istringstream iss(tokens[1]);
  if (!(iss >> *frame_number)) {
-    LOGE("CdmEngine::ParseDecryptHashString: error while trying to convert "
-         "frame number to a numeric format: %s", hash_string.c_str());
+    LOGE(
+        "CdmEngine::ParseDecryptHashString: error while trying to convert "
+        "frame number to a numeric format: %s",
+        hash_string.c_str());
    return INVALID_DECRYPT_HASH_FORMAT;
  }

@@ -1820,10 +1813,9 @@ CdmResponseType CdmEngine::ParseDecryptHashString(
  return NO_ERROR;
 }

-CdmResponseType CdmEngine::SetDecryptHash(
-    const CdmSessionId& session_id,
-    uint32_t frame_number,
-    const std::string& hash) {
+CdmResponseType CdmEngine::SetDecryptHash(const CdmSessionId& session_id,
+                                          uint32_t frame_number,
+                                          const std::string& hash) {
  LOGI("CdmEngine::SetDecryptHash: %s", session_id.c_str());
  std::shared_ptr<CdmSession> session;
  if (!session_map_.FindSession(session_id, &session)) {
@@ -1832,9 +1824,8 @@ CdmResponseType CdmEngine::SetDecryptHash(
  return session->SetDecryptHash(frame_number, hash);
 }

-CdmResponseType CdmEngine::GetDecryptHashError(
-    const CdmSessionId& session_id,
-    std::string* error_string) {
+CdmResponseType CdmEngine::GetDecryptHashError(const CdmSessionId& session_id,
+                                               std::string* error_string) {
  LOGI("CdmEngine::GetDecryptHashError: %s", session_id.c_str());
  std::shared_ptr<CdmSession> session;
  if (!session_map_.FindSession(session_id, &session)) {
@@ -1847,8 +1838,8 @@ CdmResponseType CdmEngine::GetDecryptHashError(
 bool CdmEngine::IsKeyLoaded(const KeyId& key_id) {
  CdmSessionList sessions;
  session_map_.GetSessionList(sessions);
-  for (CdmSessionList::iterator iter = sessions.begin();
-       iter != sessions.end(); ++iter) {
+  for (CdmSessionList::iterator iter = sessions.begin(); iter != sessions.end();
+       ++iter) {
    if ((*iter)->IsKeyLoaded(key_id)) {
      return true;
    }
@@ -1872,8 +1863,8 @@ bool CdmEngine::FindSessionForKey(const KeyId& key_id,
  CdmSessionList::iterator session_iter = sessions.end();

  int64_t seconds_remaining = 0;
-  for (CdmSessionList::iterator iter = sessions.begin();
-       iter != sessions.end(); ++iter) {
+  for (CdmSessionList::iterator iter = sessions.begin(); iter != sessions.end();
+       ++iter) {
    CdmSessionId id = (*iter)->session_id();
    if (Properties::GetSessionSharingId(id) == session_sharing_id) {
      if ((*iter)->IsKeyLoaded(key_id)) {
@@ -1927,9 +1918,8 @@ void CdmEngine::OnTimerEvent() {
    session_map_.GetSessionList(sessions);

    while (!sessions.empty()) {
-      is_initial_usage_update =
-          is_initial_usage_update ||
-          sessions.front()->is_initial_usage_update();
+      is_initial_usage_update = is_initial_usage_update ||
+                                sessions.front()->is_initial_usage_update();
      is_usage_update_needed =
          is_usage_update_needed || sessions.front()->is_usage_update_needed();

@@ -1990,8 +1980,7 @@ CdmResponseType CdmEngine::ValidateServiceCertificate(const std::string& cert) {
  return certificate.Init(cert);
 }

-std::string CdmEngine::MapHdcpVersion(
-    CryptoSession::HdcpCapability version) {
+std::string CdmEngine::MapHdcpVersion(CryptoSession::HdcpCapability version) {
  switch (version) {
    case HDCP_NONE:
      return QUERY_VALUE_HDCP_NONE;
@@ -2048,27 +2037,26 @@ void CdmEngine::DeleteAllUsageReportsUponFactoryReset() {
    std::unique_ptr<CryptoSession> crypto_session(
        CryptoSession::MakeCryptoSession(metrics_->GetCryptoMetrics()));
    CdmResponseType status;
-    M_TIME(
-        status = crypto_session->Open(
-            cert_provisioning_requested_security_level_),
-        metrics_->GetCryptoMetrics(),
-        crypto_session_open_,
-        status,
-        cert_provisioning_requested_security_level_);
+    M_TIME(status = crypto_session->Open(
+               cert_provisioning_requested_security_level_),
+           metrics_->GetCryptoMetrics(), crypto_session_open_, status,
+           cert_provisioning_requested_security_level_);
    if (NO_ERROR == status) {
      status = crypto_session->DeleteAllUsageReports();
-      metrics_->GetCryptoMetrics()->crypto_session_delete_all_usage_reports_
-          .Increment(status);
+      metrics_->GetCryptoMetrics()
+          ->crypto_session_delete_all_usage_reports_.Increment(status);
      if (NO_ERROR != status) {
        LOGW(
            "CdmEngine::DeleteAllUsageReportsUponFactoryReset: "
-            "Fails to delete usage reports: %d", status);
+            "Fails to delete usage reports: %d",
+            status);
      }
    } else {
      LOGW(
          "CdmEngine::DeleteAllUsageReportsUponFactoryReset: "
          "Fails to open crypto session: error=%d.\n"
-          "Usage reports are not removed after factory reset.", status);
+          "Usage reports are not removed after factory reset.",
+          status);
    }
  }
 }