Store key set ID with usage info

[ Merge of http://go/wvgerrit/16241 and http://go/wvgerrit/16364 ]

This will allow a usage session to be loaded later by key set ID.
This is needed for EME-style secure stop in the new CE CDM API.

b/25816911

Change-Id: I916340047492fbc0556d0e90bd2eac0f3eafe597

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -2,6 +2,7 @@
 
 #include "cdm_engine.h"
 
+#include <assert.h>
 #include <stdlib.h>
 
 #include <iostream>
@@ -934,6 +935,66 @@ CdmResponseType CdmEngine::ReleaseUsageInfo(
   return status;
 }
 
+CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
+                                            CdmKeyMessage* release_message) {
+  LOGI("CdmEngine::LoadUsageSession");
+  // This method is currently only used by the CE CDM, in which all session IDs
+  // are key set IDs.
+  assert(Properties::AlwaysUseKeySetIds());
+
+  if (key_set_id.empty()) {
+    LOGE("CdmEngine::LoadUsageSession: invalid key set id");
+    return EMPTY_KEYSET_ID_ENG_5;
+  }
+
+  CdmSessionMap::iterator iter = sessions_.find(key_set_id);
+  if (iter == sessions_.end()) {
+    LOGE("CdmEngine::LoadUsageSession: session_id not found = %s ",
+         key_set_id.c_str());
+    return SESSION_NOT_FOUND_11;
+  }
+
+  DeviceFiles handle;
+  if (!handle.Init(iter->second->GetSecurityLevel())) {
+    LOGE("CdmEngine::LoadUsageSession: unable to initialize device files");
+    return LOAD_USAGE_INFO_FILE_ERROR;
+  }
+
+  std::string app_id;
+  iter->second->GetApplicationId(&app_id);
+
+  CdmKeyMessage key_message;
+  CdmKeyResponse key_response;
+  if (!handle.RetrieveUsageInfoByKeySetId(app_id, key_set_id, &key_message,
+                                          &key_response)) {
+    LOGE("CdmEngine::LoadUsageSession: unable to find usage information");
+    return LOAD_USAGE_INFO_MISSING;
+  }
+
+  CdmResponseType status =
+      iter->second->RestoreUsageSession(key_message, key_response);
+  if (KEY_ADDED != status) {
+    LOGE("CdmEngine::LoadUsageSession: usage session error %ld", status);
+    return status;
+  }
+
+  std::string server_url;
+  status = iter->second->GenerateReleaseRequest(release_message, &server_url);
+
+  switch (status) {
+    case KEY_MESSAGE:
+      break;
+    case KEY_CANCELED:                // usage information not present in
+      iter->second->DeleteLicense();  // OEMCrypto, delete and try again
+      break;
+    default:
+      LOGE("CdmEngine::LoadUsageSession: generate release request error: %d",
+           status);
+      break;
+  }
+  return status;
+}
+
 CdmResponseType CdmEngine::Decrypt(const CdmSessionId& session_id,
                                    const CdmDecryptionParameters& parameters) {
   if (parameters.key_id == NULL) {

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -541,7 +541,7 @@ CdmResponseType CdmSession::StoreLicense() {
   std::string app_id;
   GetApplicationId(&app_id);
   if (!file_handle_->StoreUsageInfo(provider_session_token, key_request_,
-                                    key_response_, app_id)) {
+                                    key_response_, app_id, key_set_id_)) {
     LOGE("CdmSession::StoreLicense: Unable to store usage info");
     return STORE_USAGE_INFO_ERROR;
   }

libwvdrmengine/cdm/core/src/device_files.cpp

@@ -355,7 +355,8 @@ bool DeviceFiles::UnreserveLicenseId(const std::string& key_set_id) {
 bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
                                  const CdmKeyMessage& key_request,
                                  const CdmKeyResponse& key_response,
-                                 const std::string& app_id) {
+                                 const std::string& app_id,
+                                 const std::string& key_set_id) {
   if (!initialized_) {
     LOGW("DeviceFiles::StoreUsageInfo: not initialized");
     return false;
@@ -381,6 +382,7 @@ bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
                               provider_session_token.size());
   provider_session->set_license_request(key_request.data(), key_request.size());
   provider_session->set_license(key_response.data(), key_response.size());
+  provider_session->set_key_set_id(key_set_id.data(), key_set_id.size());
 
   file.SerializeToString(&serialized_file);
   return StoreFileWithHash(file_name, serialized_file);
@@ -522,22 +524,48 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& app_id,
     LOGW("DeviceFiles::RetrieveUsageInfo: Unable to parse file");
     return false;
   }
+
   int index = 0;
-  bool found = false;
   for (; index < file.usage_info().sessions_size(); ++index) {
     if (file.usage_info().sessions(index).token() == provider_session_token) {
-      found = true;
-      break;
+      *license_request = file.usage_info().sessions(index).license_request();
+      *license_response = file.usage_info().sessions(index).license();
+      return true;
     }
   }
 
-  if (!found) {
+  return false;
+}
+
+bool DeviceFiles::RetrieveUsageInfoByKeySetId(
+    const std::string& app_id,
+    const std::string& key_set_id,
+    CdmKeyMessage* license_request,
+    CdmKeyResponse* license_response) {
+  if (!initialized_) {
+    LOGW("DeviceFiles::RetrieveUsageInfoByKeySetId: not initialized");
+    return false;
+  }
+  std::string serialized_file;
+  std::string file_name = GetUsageInfoFileName(app_id);
+  if (!RetrieveHashedFile(file_name, &serialized_file)) return false;
+
+  video_widevine_client::sdk::File file;
+  if (!file.ParseFromString(serialized_file)) {
+    LOGW("DeviceFiles::RetrieveUsageInfoByKeySetId: Unable to parse file");
     return false;
   }
 
-  *license_request = file.usage_info().sessions(index).license_request();
-  *license_response = file.usage_info().sessions(index).license();
-  return true;
+  int index = 0;
+  for (; index < file.usage_info().sessions_size(); ++index) {
+    if (file.usage_info().sessions(index).key_set_id() == key_set_id) {
+      *license_request = file.usage_info().sessions(index).license_request();
+      *license_response = file.usage_info().sessions(index).license();
+      return true;
+    }
+  }
+
+  return false;
 }
 
 bool DeviceFiles::StoreFileWithHash(const std::string& name,

libwvdrmengine/cdm/core/src/device_files.proto

@@ -46,6 +46,7 @@ message UsageInfo {
     optional bytes token = 1;
     optional bytes license_request = 2;
     optional bytes license = 3;
+    optional bytes key_set_id = 4;
   }
 
   repeated ProviderSession sessions = 1;