Merge "Return error codes when storing or retrieving licenses"

libwvdrmengine/cdm/core/include/device_files.h

@@ -30,6 +30,26 @@ class DeviceFiles {
     kLicenseStateUnknown,
   } LicenseState;
 
+  enum ResponseType {
+    kNoError = 0,
+    kObjectNotInitialized = 1,
+    kParameterNull = 2,
+    kBasePathUnavailable = 3,
+    kFileNotFound = 4,
+    kFileOpenFailed = 5,
+    kFileWriteError = 6,
+    kFileReadError = 7,
+    kInvalidFileSize = 8,
+    kHashComputationFailed = 9,
+    kFileHashMismatch = 10,
+    kFileParseError1 = 11,
+    kFileParseError2 = 12,
+    kUnknownLicenseState = 13,
+    kIncorrectFileType = 14,
+    kIncorrectFileVersion = 15,
+    kLicenseNotPresent = 16,
+  };
+
   struct CdmUsageData {
     std::string provider_session_token;
     CdmKeyMessage license_request;
@@ -69,7 +89,8 @@ class DeviceFiles {
                             int64_t grace_period_end_time,
                             const CdmAppParameterMap& app_parameters,
                             const CdmUsageEntry& usage_entry,
-                            uint32_t usage_entry_number);
+                            uint32_t usage_entry_number,
+                            ResponseType* result);
   virtual bool RetrieveLicense(
       const std::string& key_set_id, LicenseState* state,
       CdmInitData* pssh_data, CdmKeyMessage* key_request,
@@ -77,7 +98,8 @@ class DeviceFiles {
       CdmKeyResponse* key_renewal_response, std::string* release_server_url,
       int64_t* playback_start_time, int64_t* last_playback_time,
       int64_t* grace_period_end_time, CdmAppParameterMap* app_parameters,
-      CdmUsageEntry* usage_entry, uint32_t* usage_entry_number);
+      CdmUsageEntry* usage_entry, uint32_t* usage_entry_number,
+      ResponseType* result);
   virtual bool DeleteLicense(const std::string& key_set_id);
   virtual bool ListLicenses(std::vector<std::string>* key_set_ids);
   virtual bool DeleteAllFiles();
@@ -197,11 +219,11 @@ class DeviceFiles {
 
   // Helpers that wrap the File interface and automatically handle hashing, as
   // well as adding the device files base path to to the file name.
-  bool StoreFileWithHash(const std::string& name,
+  ResponseType StoreFileWithHash(const std::string& name,
                                  const std::string& serialized_file);
-  bool StoreFileRaw(const std::string& name,
+  ResponseType StoreFileRaw(const std::string& name,
                             const std::string& serialized_file);
-  bool RetrieveHashedFile(const std::string& name,
+  ResponseType RetrieveHashedFile(const std::string& name,
                                   video_widevine_client::sdk::File* file);
   bool FileExists(const std::string& name);
   bool ListFiles(std::vector<std::string>* names);

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -208,17 +208,19 @@ CdmResponseType CdmSession::RestoreOfflineSession(
   int64_t playback_start_time;
   int64_t last_playback_time;
   int64_t grace_period_end_time;
+  DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
 
   if (!file_handle_->RetrieveLicense(
           key_set_id, &license_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_)) {
+          &app_parameters_, &usage_entry_, &usage_entry_number_,
+          &sub_error_code)) {
     LOGE(
         "CdmSession::RestoreOfflineSession: failed to retrieve license. "
-        "key set id = %s",
+        "sub error: %d, key set id = %s",
-        key_set_id.c_str());
+        sub_error_code, key_set_id.c_str());
     return GET_LICENSE_ERROR;
   }
 
@@ -863,13 +865,14 @@ CdmResponseType CdmSession::StoreLicense() {
 }
 
 bool CdmSession::StoreLicense(DeviceFiles::LicenseState state) {
+  DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
   return file_handle_->StoreLicense(
       key_set_id_, state, offline_init_data_, key_request_, key_response_,
       offline_key_renewal_request_, offline_key_renewal_response_,
       offline_release_server_url_, policy_engine_->GetPlaybackStartTime(),
       policy_engine_->GetLastPlaybackTime(),
       policy_engine_->GetGracePeriodEndTime(), app_parameters_, usage_entry_,
-      usage_entry_number_);
+      usage_entry_number_, &sub_error_code);
 }
 
 CdmResponseType CdmSession::RemoveKeys() {

libwvdrmengine/cdm/core/src/device_files.cpp

@@ -49,6 +49,13 @@ using video_widevine_client::sdk::
 using video_widevine::SignedDrmDeviceCertificate;
 using video_widevine::DrmDeviceCertificate;
 
+#define RETURN_FALSE_IF_NULL(PARAM) \
+if (PARAM == nullptr) { \
+  LOGE("|PARAM| not provided"); \
+  *result = kParameterNull; \
+  return false; \
+}
+
 namespace {
 
 const char kCertificateFileName[] = "cert.bin";
@@ -121,7 +128,8 @@ bool DeviceFiles::StoreCertificate(const std::string& certificate,
   std::string serialized_file;
   file.SerializeToString(&serialized_file);
 
-  return StoreFileWithHash(GetCertificateFileName(), serialized_file);
+  return
+      StoreFileWithHash(GetCertificateFileName(), serialized_file) == kNoError;
 }
 
 bool DeviceFiles::RetrieveCertificate(std::string* certificate,
@@ -134,7 +142,8 @@ bool DeviceFiles::RetrieveCertificate(std::string* certificate,
   }
 
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(GetCertificateFileName(), &file)) {
+  if (RetrieveHashedFile(GetCertificateFileName(), &file) != kNoError) {
+    LOGW("DeviceFiles::RetrieveCertificate: unable to retrieve file");
     return false;
   }
 
@@ -223,9 +232,18 @@ bool DeviceFiles::StoreLicense(
     int64_t last_playback_time, int64_t grace_period_end_time,
     const CdmAppParameterMap& app_parameters,
     const CdmUsageEntry& usage_entry,
-    const uint32_t usage_entry_number) {
+    const uint32_t usage_entry_number,
+    ResponseType* result) {
+  if (result == nullptr) {
+    LOGE("DeviceFiles::StoreLicense: |result| not provided");
+    return false;
+  }
+
+  *result = kNoError;
+
   if (!initialized_) {
     LOGW("DeviceFiles::StoreLicense: not initialized");
+    *result = kObjectNotInitialized;
     return false;
   }
 
@@ -245,6 +263,7 @@ bool DeviceFiles::StoreLicense(
       break;
     default:
       LOGW("DeviceFiles::StoreLicense: Unknown license state: %u", state);
+      *result = kUnknownLicenseState;
       return false;
       break;
   }
@@ -271,7 +290,9 @@ bool DeviceFiles::StoreLicense(
   file.SerializeToString(&serialized_file);
 
   reserved_license_ids_.erase(key_set_id);
-  return StoreFileWithHash(key_set_id + kLicenseFileNameExt, serialized_file);
+  *result =
+      StoreFileWithHash(key_set_id + kLicenseFileNameExt, serialized_file);
+  return *result == kNoError;
 }
 
 bool DeviceFiles::RetrieveLicense(
@@ -281,29 +302,54 @@ bool DeviceFiles::RetrieveLicense(
     std::string* release_server_url, int64_t* playback_start_time,
     int64_t* last_playback_time, int64_t* grace_period_end_time,
     CdmAppParameterMap* app_parameters, CdmUsageEntry* usage_entry,
-    uint32_t* usage_entry_number) {
+    uint32_t* usage_entry_number, ResponseType* result) {
-  if (!initialized_) {
+  if (result == nullptr) {
-    LOGW("DeviceFiles::RetrieveLicense: not initialized");
+    LOGE("DeviceFiles::RetrieveLicense: |result| not provided");
     return false;
   }
 
+  if (!initialized_) {
+    LOGW("DeviceFiles::RetrieveLicense: not initialized");
+    *result = kObjectNotInitialized;
+    return false;
+  }
+
+  RETURN_FALSE_IF_NULL(state);
+  RETURN_FALSE_IF_NULL(pssh_data);
+  RETURN_FALSE_IF_NULL(license_request);
+  RETURN_FALSE_IF_NULL(license_message);
+  RETURN_FALSE_IF_NULL(license_renewal_request);
+  RETURN_FALSE_IF_NULL(license_renewal);
+  RETURN_FALSE_IF_NULL(release_server_url);
+  RETURN_FALSE_IF_NULL(playback_start_time);
+  RETURN_FALSE_IF_NULL(last_playback_time);
+  RETURN_FALSE_IF_NULL(grace_period_end_time);
+  RETURN_FALSE_IF_NULL(app_parameters);
+  RETURN_FALSE_IF_NULL(usage_entry);
+  RETURN_FALSE_IF_NULL(usage_entry_number);
+
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(key_set_id + kLicenseFileNameExt, &file)) {
+  *result = RetrieveHashedFile(key_set_id + kLicenseFileNameExt, &file);
+  if (*result != kNoError) {
+    LOGW("DeviceFiles::RetrieveLicense: unable to retrieve file: %d", *result);
     return false;
   }
 
   if (file.type() != video_widevine_client::sdk::File::LICENSE) {
     LOGW("DeviceFiles::RetrieveLicense: Incorrect file type");
+    *result = kIncorrectFileType;
     return false;
   }
 
   if (file.version() != video_widevine_client::sdk::File::VERSION_1) {
     LOGW("DeviceFiles::RetrieveLicense: Incorrect file version");
+    *result = kIncorrectFileVersion;
     return false;
   }
 
   if (!file.has_license()) {
     LOGW("DeviceFiles::RetrieveLicense: License not present");
+    *result = kLicenseNotPresent;
     return false;
   }
 
@@ -444,8 +490,8 @@ bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
     file.set_type(video_widevine_client::sdk::File::USAGE_INFO);
     file.set_version(video_widevine_client::sdk::File::VERSION_1);
   } else {
-    if (!RetrieveHashedFile(usage_info_file_name, &file)) {
+    if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
-      LOGW("DeviceFiles::StoreUsageInfo: Unable to parse file");
+      LOGW("DeviceFiles::StoreUsageInfo: Unable to retrieve file");
       return false;
     }
   }
@@ -463,7 +509,7 @@ bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
 
   std::string serialized_file;
   file.SerializeToString(&serialized_file);
-  return StoreFileWithHash(usage_info_file_name, serialized_file);
+  return StoreFileWithHash(usage_info_file_name, serialized_file) == kNoError;
 }
 
 bool DeviceFiles::ListUsageIds(
@@ -489,8 +535,8 @@ bool DeviceFiles::ListUsageIds(
   }
 
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(file_name, &file)) {
+  if (RetrieveHashedFile(file_name, &file) != kNoError) {
-    LOGW("DeviceFiles::ListUsageRecords: Unable to parse file");
+    LOGW("DeviceFiles::ListUsageRecords: Unable to retrieve file");
     return false;
   }
 
@@ -531,8 +577,8 @@ bool DeviceFiles::GetProviderSessionToken(const std::string& app_id,
   }
 
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(file_name, &file)) {
+  if (RetrieveHashedFile(file_name, &file) != kNoError) {
-    LOGW("DeviceFiles::GetProviderSessionToken: unable to parse file");
+    LOGW("DeviceFiles::GetProviderSessionToken: unable to retrieve file");
     return false;
   }
 
@@ -553,7 +599,10 @@ bool DeviceFiles::DeleteUsageInfo(const std::string& usage_info_file_name,
     return false;
   }
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(usage_info_file_name, &file)) return false;
+  if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
+    LOGW("DeviceFiles::DeleteUsageInfo: Unable to retrieve file");
+    return false;
+  }
 
   UsageInfo* usage_info = file.mutable_usage_info();
   int index = 0;
@@ -582,7 +631,7 @@ bool DeviceFiles::DeleteUsageInfo(const std::string& usage_info_file_name,
 
   std::string serialized_file;
   file.SerializeToString(&serialized_file);
-  return StoreFileWithHash(usage_info_file_name, serialized_file);
+  return StoreFileWithHash(usage_info_file_name, serialized_file) == kNoError;
 }
 
 bool DeviceFiles::DeleteAllUsageInfoForApp(
@@ -601,7 +650,7 @@ bool DeviceFiles::DeleteAllUsageInfoForApp(
   if (!FileExists(usage_info_file_name)) return true;
 
   video_widevine_client::sdk::File file;
-  if (RetrieveHashedFile(usage_info_file_name, &file)) {
+  if (RetrieveHashedFile(usage_info_file_name, &file) == kNoError) {
     for (int i = 0; i < file.usage_info().sessions_size(); ++i) {
       provider_session_tokens->push_back(file.usage_info().sessions(i).token());
     }
@@ -642,8 +691,8 @@ bool DeviceFiles::RetrieveUsageInfo(
   }
 
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(usage_info_file_name, &file)) {
+  if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
-    LOGW("DeviceFiles::RetrieveUsageInfo: Unable to parse file");
+    LOGW("DeviceFiles::RetrieveUsageInfo: Unable to retrieve file");
     return false;
   }
 
@@ -669,7 +718,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
   }
 
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(usage_info_file_name, &file)) {
+  if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
+    LOGW("DeviceFiles::RetrieveUsageInfo: unable to retrieve file");
     return false;
   }
 
@@ -702,7 +752,8 @@ bool DeviceFiles::RetrieveUsageInfoByKeySetId(
   }
 
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(usage_info_file_name, &file)) {
+  if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
+    LOGW("DeviceFiles::RetrieveUsageInfoByKeySetId: unable to retrieve file");
     return false;
   }
 
@@ -751,7 +802,7 @@ bool DeviceFiles::StoreUsageInfo(const std::string& usage_info_file_name,
 
   std::string serialized_file;
   file.SerializeToString(&serialized_file);
-  return StoreFileWithHash(usage_info_file_name, serialized_file);
+  return StoreFileWithHash(usage_info_file_name, serialized_file) == kNoError;
 }
 
 bool DeviceFiles::UpdateUsageInfo(const std::string& usage_info_file_name,
@@ -769,8 +820,8 @@ bool DeviceFiles::UpdateUsageInfo(const std::string& usage_info_file_name,
   }
 
 
-  if (!RetrieveHashedFile(usage_info_file_name, &file)) {
+  if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
-    LOGW("DeviceFiles::UpdateUsageInfo: Unable to parse file");
+    LOGW("DeviceFiles::UpdateUsageInfo: Unable to retrieve file");
     return false;
   }
 
@@ -788,7 +839,8 @@ bool DeviceFiles::UpdateUsageInfo(const std::string& usage_info_file_name,
 
       std::string serialized_file;
       file.SerializeToString(&serialized_file);
-      return StoreFileWithHash(usage_info_file_name, serialized_file);
+      return
+          StoreFileWithHash(usage_info_file_name, serialized_file) == kNoError;
     }
   }
 
@@ -814,7 +866,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
   }
 
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(usage_info_file_name, &file)) {
+  if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
+    LOGW("DeviceFiles::RetrieveUsageInfo: unable to retrieve file");
     return false;
   }
 
@@ -848,7 +901,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
   }
 
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(usage_info_file_name, &file)) {
+  if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
+    LOGW("DeviceFiles::RetrieveUsageInfo: unable to retrieve file");
     return false;
   }
 
@@ -942,7 +996,7 @@ bool DeviceFiles::StoreHlsAttributes(
   file.SerializeToString(&serialized_file);
 
   return StoreFileWithHash(key_set_id + kHlsAttributesFileNameExt,
-                           serialized_file);
+                           serialized_file) == kNoError;
 }
 
 bool DeviceFiles::RetrieveHlsAttributes(
@@ -954,7 +1008,9 @@ bool DeviceFiles::RetrieveHlsAttributes(
   }
 
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(key_set_id + kHlsAttributesFileNameExt, &file)) {
+  if (RetrieveHashedFile(key_set_id + kHlsAttributesFileNameExt, &file) !=
+      kNoError) {
+    LOGW("DeviceFiles::RetrieveHlsAttributes: unable to retrieve file");
     return false;
   }
 
@@ -1045,7 +1101,8 @@ bool DeviceFiles::StoreUsageTableInfo(
   std::string serialized_file;
   file.SerializeToString(&serialized_file);
 
-  return StoreFileWithHash(GetUsageTableFileName(), serialized_file);
+  return
+      StoreFileWithHash(GetUsageTableFileName(), serialized_file) == kNoError;
 }
 
 bool DeviceFiles::RetrieveUsageTableInfo(
@@ -1068,7 +1125,8 @@ bool DeviceFiles::RetrieveUsageTableInfo(
   }
 
   video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(GetUsageTableFileName(), &file)) {
+  if (RetrieveHashedFile(GetUsageTableFileName(), &file) != kNoError) {
+    LOGW("DeviceFiles::RetrieveUsageTableInfo: unable to retrieve file");
     return false;
   }
 
@@ -1122,13 +1180,14 @@ bool DeviceFiles::DeleteUsageTableInfo() {
   return RemoveFile(GetUsageTableFileName());
 }
 
-bool DeviceFiles::StoreFileWithHash(const std::string& name,
+DeviceFiles::ResponseType DeviceFiles::StoreFileWithHash(
+    const std::string& name,
     const std::string& serialized_file) {
   // calculate SHA hash
   std::string hash;
   if (!Hash(serialized_file, &hash)) {
     LOGW("DeviceFiles::StoreFileWithHash: Hash computation failed");
-    return false;
+    return kHashComputationFailed;
   }
 
   // Fill in hashed file data
@@ -1142,12 +1201,13 @@ bool DeviceFiles::StoreFileWithHash(const std::string& name,
   return StoreFileRaw(name, serialized_hash_file);
 }
 
-bool DeviceFiles::StoreFileRaw(const std::string& name,
+DeviceFiles::ResponseType DeviceFiles::StoreFileRaw(
+    const std::string& name,
     const std::string& serialized_file) {
   std::string path;
   if (!Properties::GetDeviceFilesBasePath(security_level_, &path)) {
     LOGW("DeviceFiles::StoreFileRaw: Unable to get base path");
-    return false;
+    return kBasePathUnavailable;
   }
 
   path += name;
@@ -1156,7 +1216,7 @@ bool DeviceFiles::StoreFileRaw(const std::string& name,
       file_system_->Open(path, FileSystem::kCreate | FileSystem::kTruncate);
   if (!file) {
     LOGW("DeviceFiles::StoreFileRaw: File open failed: %s", path.c_str());
-    return false;
+    return kFileOpenFailed;
   }
 
   ssize_t bytes = file->Write(serialized_file.data(), serialized_file.size());
@@ -1166,35 +1226,35 @@ bool DeviceFiles::StoreFileRaw(const std::string& name,
         "DeviceFiles::StoreFileRaw: write failed: (actual: %d, "
         "expected: %d)",
         bytes, serialized_file.size());
-    return false;
+    return kFileWriteError;
   }
 
   LOGV("DeviceFiles::StoreFileRaw: success: %s (%db)", path.c_str(),
        serialized_file.size());
-  return true;
+  return kNoError;
 }
 
-bool DeviceFiles::RetrieveHashedFile(
+DeviceFiles::ResponseType DeviceFiles::RetrieveHashedFile(
     const std::string& name,
     video_widevine_client::sdk::File* deserialized_file) {
   std::string serialized_file;
 
   if (!deserialized_file) {
     LOGW("DeviceFiles::RetrieveHashedFile: Unspecified file parameter");
-    return false;
+    return kParameterNull;
   }
 
   std::string path;
   if (!Properties::GetDeviceFilesBasePath(security_level_, &path)) {
     LOGW("DeviceFiles::RetrieveHashedFile: Unable to get base path");
-    return false;
+    return kBasePathUnavailable;
   }
 
   path += name;
 
   if (!file_system_->Exists(path)) {
     LOGW("DeviceFiles::RetrieveHashedFile: %s does not exist", path.c_str());
-    return false;
+    return kFileNotFound;
   }
 
   ssize_t bytes = file_system_->FileSize(path);
@@ -1204,12 +1264,12 @@ bool DeviceFiles::RetrieveHashedFile(
     // Remove the corrupted file so the caller will not get the same error
     // when trying to access the file repeatedly, causing the system to stall.
     file_system_->Remove(path);
-    return false;
+    return kInvalidFileSize;
   }
 
   auto file = file_system_->Open(path, FileSystem::kReadOnly);
   if (!file) {
-    return false;
+    return kFileOpenFailed;
   }
 
   std::string serialized_hash_file;
@@ -1217,11 +1277,11 @@ bool DeviceFiles::RetrieveHashedFile(
   bytes = file->Read(&serialized_hash_file[0], serialized_hash_file.size());
 
   if (bytes != static_cast<ssize_t>(serialized_hash_file.size())) {
-    LOGW("DeviceFiles::RetrieveHashedFile: read failed");
+    LOGW("DeviceFiles::RetrieveHashedFile: read failed: %d", bytes);
     // Remove the corrupted file so the caller will not get the same error
     // when trying to access the file repeatedly, causing the system to stall.
     file_system_->Remove(path);
-    return false;
+    return kFileReadError;
   }
 
   LOGV("DeviceFiles::RetrieveHashedFile: success: %s (%db)", path.c_str(),
@@ -1233,13 +1293,13 @@ bool DeviceFiles::RetrieveHashedFile(
     // Remove the corrupted file so the caller will not get the same error
     // when trying to access the file repeatedly, causing the system to stall.
     file_system_->Remove(path);
-    return false;
+    return kFileParseError1;
   }
 
   std::string hash;
   if (!Hash(hash_file.file(), &hash)) {
     LOGW("DeviceFiles::RetrieveHashedFile: Hash computation failed");
-    return false;
+    return kHashComputationFailed;
   }
 
   if (hash != hash_file.hash()) {
@@ -1247,7 +1307,7 @@ bool DeviceFiles::RetrieveHashedFile(
     // Remove the corrupted file so the caller will not get the same error
     // when trying to access the file repeatedly, causing the system to stall.
     file_system_->Remove(path);
-    return false;
+    return kFileHashMismatch;
   }
 
   if (!deserialized_file->ParseFromString(hash_file.file())) {
@@ -1255,9 +1315,9 @@ bool DeviceFiles::RetrieveHashedFile(
     // Remove the corrupted file so the caller will not get the same error
     // when trying to access the file repeatedly, causing the system to stall.
     file_system_->Remove(path);
-    return false;
+    return kFileParseError2;
   }
-  return true;
+  return kNoError;
 }
 
 bool DeviceFiles::FileExists(const std::string& name) {

libwvdrmengine/cdm/core/src/usage_table_header.cpp

@@ -367,13 +367,15 @@ CdmResponseType UsageTableHeader::GetEntry(uint32_t usage_entry_number,
       std::string key_renewal_response, release_server_url;
       int64_t playback_start_time, last_playback_time, grace_period_end_time;
       CdmAppParameterMap app_parameters;
+      DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
       if (!handle->RetrieveLicense(
               usage_entry_info_[usage_entry_number].key_set_id, &license_state,
               &init_data, &key_request, &key_response, &key_renewal_request,
               &key_renewal_response, &release_server_url, &playback_start_time,
               &last_playback_time, &grace_period_end_time, &app_parameters,
-              usage_entry, &entry_number)) {
+              usage_entry, &entry_number, &sub_error_code)) {
-        LOGE("UsageTableHeader::GetEntry: Failed to retrieve license");
+        LOGE("UsageTableHeader::GetEntry: Failed to retrieve license, %d",
+             sub_error_code);
         return USAGE_GET_ENTRY_RETRIEVE_LICENSE_FAILED;
       }
       break;
@@ -424,13 +426,15 @@ CdmResponseType UsageTableHeader::StoreEntry(uint32_t usage_entry_number,
       int64_t playback_start_time, last_playback_time, grace_period_end_time;
       CdmAppParameterMap app_parameters;
       CdmUsageEntry entry;
+      DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
       if (!handle->RetrieveLicense(
               usage_entry_info_[usage_entry_number].key_set_id, &license_state,
               &init_data, &key_request, &key_response, &key_renewal_request,
               &key_renewal_response, &release_server_url, &playback_start_time,
               &last_playback_time, &grace_period_end_time, &app_parameters,
-              &entry, &entry_number)) {
+              &entry, &entry_number, &sub_error_code)) {
-        LOGE("UsageTableHeader::StoreEntry: Failed to retrieve license");
+        LOGE("UsageTableHeader::StoreEntry: Failed to retrieve license, %d",
+             sub_error_code);
         return USAGE_STORE_ENTRY_RETRIEVE_LICENSE_FAILED;
       }
       if (!handle->StoreLicense(
@@ -438,8 +442,9 @@ CdmResponseType UsageTableHeader::StoreEntry(uint32_t usage_entry_number,
               init_data, key_request, key_response, key_renewal_request,
               key_renewal_response, release_server_url, playback_start_time,
               last_playback_time, grace_period_end_time, app_parameters,
-              usage_entry, usage_entry_number)) {
+              usage_entry, usage_entry_number, &sub_error_code)) {
-        LOGE("UsageTableHeader::StoreEntry: Failed to store license");
+        LOGE("UsageTableHeader::StoreEntry: Failed to store license, %d",
+             sub_error_code);
         return USAGE_STORE_LICENSE_FAILED;
       }
       break;
@@ -555,15 +560,16 @@ bool UsageTableHeader::UpgradeLicensesFromUsageTable(
     CdmAppParameterMap app_parameters;
     CdmUsageEntry usage_entry;
     uint32_t usage_entry_number;
+    DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
     if (!handle->RetrieveLicense(
             key_set_ids[i], &license_state, &init_data, &key_request,
             &key_response, &key_renewal_request, &key_renewal_response,
             &release_server_url, &playback_start_time, &last_playback_time,
             &grace_period_end_time, &app_parameters, &usage_entry,
-            &usage_entry_number)) {
+            &usage_entry_number, &sub_error_code)) {
       LOGW(
           "UsageTableHeader::UpgradeLicensesFromUsageTable: Failed to "
-          "retrieve license");
+          "retrieve license, %d", sub_error_code);
       continue;
     }
 
@@ -613,10 +619,10 @@ bool UsageTableHeader::UpgradeLicensesFromUsageTable(
             key_set_ids[i], license_state, init_data, key_request, key_response,
             key_renewal_request, key_renewal_response, release_server_url,
             playback_start_time, last_playback_time, grace_period_end_time,
-            app_parameters, usage_entry, usage_entry_number)) {
+            app_parameters, usage_entry, usage_entry_number, &sub_error_code)) {
       LOGE(
           "UsageTableHeader::UpgradeLicensesFromUsageTable: Failed to store "
-          "license");
+          "license, %d", sub_error_code);
       continue;
     }
   }

libwvdrmengine/cdm/core/test/device_files_unittest.cpp

@@ -2295,6 +2295,7 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
       .WillOnce(ReturnArg<1>());
   EXPECT_CALL(*file, Read(_, _)).Times(0);
 
+  DeviceFiles::ResponseType sub_error_code;
   DeviceFiles device_files(&file_system);
   EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
   EXPECT_TRUE(device_files.StoreLicense(
@@ -2310,7 +2311,8 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
       license_test_data[license_num].last_playback_time,
       license_test_data[license_num].grace_period_end_time, app_parameters,
       license_test_data[license_num].usage_entry,
-      license_test_data[license_num].usage_entry_number));
+      license_test_data[license_num].usage_entry_number, &sub_error_code));
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 }
 
 INSTANTIATE_TEST_CASE_P(StoreLicense, DeviceFilesStoreTest, ::testing::Bool());
@@ -2344,6 +2346,7 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
     EXPECT_CALL(*file, Read(_, _)).Times(0);
   }
 
+  DeviceFiles::ResponseType sub_error_code;
   DeviceFiles device_files(&file_system);
   EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
   for (size_t i = 0; i < kNumberOfLicenses; i++) {
@@ -2361,7 +2364,8 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
         license_test_data[i].last_playback_time,
         license_test_data[i].grace_period_end_time, app_parameters,
         license_test_data[i].usage_entry,
-        license_test_data[i].usage_entry_number));
+        license_test_data[i].usage_entry_number, &sub_error_code));
+    EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
   }
 }
 
@@ -2405,6 +2409,7 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
   CdmAppParameterMap app_parameters;
   std::string usage_entry;
   uint32_t usage_entry_number;
+  DeviceFiles::ResponseType sub_error_code;
 
   for (size_t i = 0; i < kNumberOfLicenses; i++) {
     DeviceFiles::LicenseState license_state;
@@ -2413,7 +2418,7 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
         &key_request, &key_response, &key_renewal_request,
         &key_renewal_response, &release_server_url, &playback_start_time,
         &last_playback_time, &grace_period_end_time, &app_parameters,
-        &usage_entry, &usage_entry_number));
+        &usage_entry, &usage_entry_number, &sub_error_code));
     EXPECT_EQ(license_test_data[i].license_state, license_state);
     EXPECT_EQ(license_test_data[i].pssh_data, pssh_data);
     EXPECT_EQ(license_test_data[i].key_request, key_request);
@@ -2426,6 +2431,7 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
               grace_period_end_time);
     EXPECT_EQ(license_test_data[i].usage_entry, usage_entry);
     EXPECT_EQ(license_test_data[i].usage_entry_number, usage_entry_number);
+    EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
     std::map<std::string, std::string>::iterator itr;
     for (itr = app_parameters.begin(); itr != app_parameters.end(); ++itr) {
@@ -2475,13 +2481,14 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
   CdmAppParameterMap app_parameters;
   std::string usage_entry;
   uint32_t usage_entry_number;
+  DeviceFiles::ResponseType sub_error_code;
 
   EXPECT_TRUE(device_files.RetrieveLicense(
       test_data->key_set_id, &license_state, &pssh_data, &key_request,
       &key_response, &key_renewal_request, &key_renewal_response,
       &release_server_url, &playback_start_time, &last_playback_time,
       &grace_period_end_time, &app_parameters, &usage_entry,
-      &usage_entry_number));
+      &usage_entry_number, &sub_error_code));
   EXPECT_EQ(test_data->license_state, license_state);
   EXPECT_EQ(test_data->pssh_data, pssh_data);
   EXPECT_EQ(test_data->key_request, key_request);
@@ -2494,6 +2501,7 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
   EXPECT_EQ(0u, app_parameters.size());
   EXPECT_EQ(test_data->usage_entry, usage_entry);
   EXPECT_EQ(test_data->usage_entry_number, usage_entry_number);
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 }
 
 TEST_F(DeviceFilesTest, UpdateLicenseState) {
@@ -2515,6 +2523,7 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
                              Eq(license_update_test_data[i].file_data.size())))
         .WillOnce(ReturnArg<1>());
     EXPECT_CALL(*file, Read(_, _)).Times(0);
+    DeviceFiles::ResponseType sub_error_code;
     EXPECT_TRUE(device_files.StoreLicense(
         license_update_test_data[0].key_set_id,
         license_update_test_data[i].license_state,
@@ -2529,7 +2538,8 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
         license_update_test_data[0].grace_period_end_time,
         GetAppParameters(license_test_data[0].app_parameters),
         license_update_test_data[0].usage_entry,
-        license_update_test_data[0].usage_entry_number));
+        license_update_test_data[0].usage_entry_number, &sub_error_code));
+    EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
   }
 }
 
@@ -2572,13 +2582,14 @@ TEST_F(DeviceFilesTest, DeleteLicense) {
   CdmAppParameterMap app_parameters;
   std::string usage_entry;
   uint32_t usage_entry_number;
+  DeviceFiles::ResponseType sub_error_code;
 
   EXPECT_TRUE(device_files.RetrieveLicense(
       license_test_data[0].key_set_id, &license_state, &pssh_data, &key_request,
       &key_response, &key_renewal_request, &key_renewal_response,
       &release_server_url, &playback_start_time, &last_playback_time,
       &grace_period_end_time, &app_parameters, &usage_entry,
-      &usage_entry_number));
+      &usage_entry_number, &sub_error_code));
   EXPECT_EQ(license_test_data[0].license_state, license_state);
   EXPECT_EQ(license_test_data[0].pssh_data, pssh_data);
   EXPECT_EQ(license_test_data[0].key_request, key_request);
@@ -2597,6 +2608,7 @@ TEST_F(DeviceFilesTest, DeleteLicense) {
   }
   EXPECT_EQ(license_test_data[0].usage_entry, usage_entry);
   EXPECT_EQ(license_test_data[0].usage_entry_number, usage_entry_number);
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
   EXPECT_TRUE(device_files.DeleteLicense(license_test_data[0].key_set_id));
   EXPECT_FALSE(device_files.LicenseExists(license_test_data[0].key_set_id));

libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp

@@ -1370,6 +1370,7 @@ TEST_F(UsageTableHeaderTest,
   uint32_t usage_entry_number_to_be_deleted =
       usage_entry_info_vector.size() - 3;  // kUsageEntryInfoOfflineLicense1
   metrics::CryptoMetrics metrics;
+  DeviceFiles::ResponseType sub_error_code;
 
   EXPECT_TRUE(device_files_->StoreLicense(
       usage_entry_info_vector[usage_entry_info_vector.size() - 1].key_set_id,
@@ -1377,7 +1378,8 @@ TEST_F(UsageTableHeaderTest,
       kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
       kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
       kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
-      usage_entry_info_vector.size() - 2));
+      usage_entry_info_vector.size() - 2, &sub_error_code));
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
   EXPECT_TRUE(device_files_->StoreLicense(
       usage_entry_info_vector[usage_entry_info_vector.size() - 2].key_set_id,
@@ -1385,7 +1387,8 @@ TEST_F(UsageTableHeaderTest,
       kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
       kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
       kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
-      usage_entry_info_vector.size() - 3));
+      usage_entry_info_vector.size() - 3, &sub_error_code));
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
   EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
   EXPECT_CALL(
@@ -1576,13 +1579,15 @@ TEST_F(UsageTableHeaderTest,
       usage_entry_info_vector.size() - 1;  // kUsageEntryInfoOfflineLicense3
   metrics::CryptoMetrics metrics;
 
+  DeviceFiles::ResponseType sub_error_code;
   EXPECT_TRUE(device_files_->StoreLicense(
       usage_entry_info_vector[last_usage_entry_number].key_set_id,
       kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
       kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
       kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
       kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
-      last_usage_entry_number));
+      last_usage_entry_number, &sub_error_code));
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
   EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_,
@@ -1722,13 +1727,15 @@ TEST_F(UsageTableHeaderTest,
       usage_entry_info_vector.size() - 3;  // kUsageEntryInfoOfflineLicense3
   metrics::CryptoMetrics metrics;
 
+  DeviceFiles::ResponseType sub_error_code;
   EXPECT_TRUE(device_files_->StoreLicense(
       usage_entry_info_vector[last_valid_usage_entry_number].key_set_id,
       kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
       kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
       kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
       kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
-      last_valid_usage_entry_number));
+      last_valid_usage_entry_number, &sub_error_code));
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
   EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
       .Times(2)
@@ -1878,13 +1885,15 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
       usage_entry_info_vector.size() - 1;  // kUsageEntryInfoOfflineLicense3
   metrics::CryptoMetrics metrics;
 
+  DeviceFiles::ResponseType sub_error_code;
   EXPECT_TRUE(device_files_->StoreLicense(
       usage_entry_info_vector[last_usage_entry_number].key_set_id,
       kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
       kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
       kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
       kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
-      last_usage_entry_number));
+      last_usage_entry_number, &sub_error_code));
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
   EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
       .Times(2)
@@ -1945,7 +1954,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
       &key_request, &key_response, &key_renewal_request, &key_renewal_response,
       &release_server_url, &playback_start_time, &last_playback_time,
       &grace_period_end_time, &app_parameters, &usage_entry,
-      &usage_entry_number));
+      &usage_entry_number, &sub_error_code));
   EXPECT_EQ(kActiveLicenseState, license_state);
   EXPECT_EQ(kPsshData, pssh_data);
   EXPECT_EQ(kKeyRequest, key_request);
@@ -1959,6 +1968,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
   EXPECT_EQ(kEmptyAppParameters.size(), app_parameters.size());
   EXPECT_EQ(kAnotherUsageEntry, usage_entry);
   EXPECT_EQ(usage_entry_number_to_be_deleted, usage_entry_number);
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 }
 
 // Initial Test state:
@@ -2098,13 +2108,15 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
       usage_entry_info_vector.size() - 3;  // kUsageEntryInfoOfflineLicense3
   metrics::CryptoMetrics metrics;
 
+  DeviceFiles::ResponseType sub_error_code;
   EXPECT_TRUE(device_files_->StoreLicense(
       usage_entry_info_vector[last_valid_usage_entry_number].key_set_id,
       kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
       kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
       kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
       kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
-      last_valid_usage_entry_number));
+      last_valid_usage_entry_number, &sub_error_code));
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
   EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
       .Times(2)
@@ -2166,7 +2178,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
       &key_request, &key_response, &key_renewal_request, &key_renewal_response,
       &release_server_url, &playback_start_time, &last_playback_time,
       &grace_period_end_time, &app_parameters, &usage_entry,
-      &usage_entry_number));
+      &usage_entry_number, &sub_error_code));
   EXPECT_EQ(kActiveLicenseState, license_state);
   EXPECT_EQ(kPsshData, pssh_data);
   EXPECT_EQ(kKeyRequest, key_request);
@@ -2180,6 +2192,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
   EXPECT_EQ(kEmptyAppParameters.size(), app_parameters.size());
   EXPECT_EQ(kAnotherUsageEntry, usage_entry);
   EXPECT_EQ(usage_entry_number_to_be_deleted, usage_entry_number);
+  EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 }
 
 // Initial Test state: