Allow Secure Stops to be queried and deleted by application ID

This CL changes the WVDrmPlugin so that an application can segregate
its secure stops from those of other applications by setting an
application ID.

This CL is a merge of the following Widevine CLs:
https://widevine-internal-review.googlesource.com/#/c/11565/
Add getSecureStop by ssid

https://widevine-internal-review.googlesource.com/#/c/11572
Add getSecureStop by SSID and releaseAllSecureStops by app id.

https://widevine-internal-review.googlesource.com/#/c/11564/
Store Usage Info by App Id (device_file stubs)

https://widevine-internal-review.googlesource.com/#/c/11563/
Add application id to StoreUsageInfo.

https://widevine-internal-review.googlesource.com/#/c/11561/
Added Application ID to PropertySet for secure stop.

bug: 18053197
bug: 18076411
Change-Id: I5444baf67ba1b960dee2dc958bced8de82ab70a3

libwvdrmengine/cdm/core/include/cdm_client_property_set.h

@@ -19,6 +19,7 @@ class CdmClientPropertySet {
   virtual bool is_session_sharing_enabled() const = 0;
   virtual uint32_t session_sharing_id() const = 0;
   virtual void set_session_sharing_id(uint32_t id) = 0;
+  virtual const std::string& app_id() const = 0;
 };
 
 }  // namespace wvcdm

libwvdrmengine/cdm/core/include/cdm_engine.h

@@ -93,7 +93,16 @@ class CdmEngine {
   virtual CdmResponseType Unprovision(CdmSecurityLevel security_level);
 
   // Usage related methods for streaming licenses
-  virtual CdmResponseType GetUsageInfo(CdmUsageInfo* usage_info);
+  // Retrieve a random usage info from the list of all usage infos for this app
+  // id.
+  virtual CdmResponseType GetUsageInfo(const std::string& app_id,
+                                       CdmUsageInfo* usage_info);
+  // Retrieve the usage info for the specified pst.
+  // Returns UNKNOWN_ERROR if no usage info was found.
+  virtual CdmResponseType GetUsageInfo(const std::string& app_id,
+                                       const CdmSecureStopId& ssid,
+                                       CdmUsageInfo* usage_info);
+  virtual CdmResponseType ReleaseAllUsageInfo(const std::string& app_id);
   virtual CdmResponseType ReleaseUsageInfo(
       const CdmUsageInfoReleaseMessage& message);
 
@@ -120,7 +129,8 @@ class CdmEngine {
  private:
   // private methods
   bool ValidateKeySystem(const CdmKeySystem& key_system);
-  CdmResponseType GetUsageInfo(SecurityLevel requested_security_level,
+  CdmResponseType GetUsageInfo(const std::string& app_id,
+                               SecurityLevel requested_security_level,
                                CdmUsageInfo* usage_info);
 
   void OnKeyReleaseEvent(const CdmKeySetId& key_set_id);

libwvdrmengine/cdm/core/include/cdm_session.h

@@ -83,9 +83,11 @@ class CdmSession {
   virtual void OnTimerEvent(bool update_usage);
   virtual void OnKeyReleaseEvent(const CdmKeySetId& key_set_id);
 
+  virtual void GetApplicationId(std::string* app_id);
   virtual SecurityLevel GetRequestedSecurityLevel();
   virtual CdmSecurityLevel GetSecurityLevel();
 
+  virtual CdmResponseType DeleteUsageInformation(const std::string& app_id);
   virtual CdmResponseType UpdateUsageInformation();
 
   virtual bool is_initial_usage_update() { return is_initial_usage_update_; }
@@ -120,6 +122,7 @@ class CdmSession {
   bool is_offline_;
   bool is_release_;
   CdmSecurityLevel security_level_;
+  std::string app_id_;
 
   // decryption and usage flags
   bool is_initial_decryption_;

libwvdrmengine/cdm/core/include/device_files.h

@@ -62,11 +62,22 @@ class DeviceFiles {
 
   virtual bool StoreUsageInfo(const std::string& provider_session_token,
                               const CdmKeyMessage& key_request,
-                              const CdmKeyResponse& key_response);
+                              const CdmKeyResponse& key_response,
-  virtual bool DeleteUsageInfo(const std::string& provider_session_token);
+                              const std::string& app_id);
-  virtual bool DeleteUsageInfo();
+  virtual bool DeleteUsageInfo(const std::string& app_id,
+                               const std::string& provider_session_token);
+  virtual bool DeleteAllUsageInfoForApp(const std::string& app_id);
+  // Retrieve one usage info from the file.  Subsequent calls will retrieve
+  // subsequent entries in the table for this app_id.
   virtual bool RetrieveUsageInfo(
+      const std::string& app_id,
       std::vector<std::pair<CdmKeyMessage, CdmKeyResponse> >* usage_info);
+  // Retrieve the usage info entry specified by |provider_session_token|.
+  // Returns false if the entry could not be found.
+  virtual bool RetrieveUsageInfo(const std::string& app_id,
+                                 const std::string& provider_session_token,
+                                 CdmKeyMessage* license_request,
+                                 CdmKeyResponse* license_response);
 
  private:
   bool StoreFile(const char* name, const std::string& serialized_file);
@@ -80,7 +91,7 @@ class DeviceFiles {
   // For testing only:
   static std::string GetCertificateFileName();
   static std::string GetLicenseFileNameExtension();
-  static std::string GetUsageInfoFileName();
+  static std::string GetUsageInfoFileName(const std::string& app_id);
   void SetTestFile(File* file);
 #if defined(UNIT_TEST)
   FRIEND_TEST(DeviceFilesSecurityLevelTest, SecurityLevel);

libwvdrmengine/cdm/core/include/properties.h

@@ -53,6 +53,8 @@ class Properties {
   static bool GetFactoryKeyboxPath(std::string* keybox);
   static bool GetOEMCryptoPath(std::string* library_name);
   static bool GetSecurityLevelDirectories(std::vector<std::string>* dirs);
+  static bool GetApplicationId(const CdmSessionId& session_id,
+                               std::string* app_id);
   static bool GetSecurityLevel(const CdmSessionId& session_id,
                                std::string* security_level);
   static bool GetServiceCertificate(const CdmSessionId& session_id,

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -15,6 +15,7 @@ typedef std::string CdmInitData;
 typedef std::string CdmKeyMessage;
 typedef std::string CdmKeyResponse;
 typedef std::string KeyId;
+typedef std::string CdmSecureStopId;
 typedef std::string CdmSessionId;
 typedef std::string CdmKeySetId;
 typedef std::string RequestId;

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -43,7 +43,11 @@ class UsagePropertySet : public CdmClientPropertySet {
   virtual void set_session_sharing_id(uint32_t id) {
     id;  // noop to suppress warning
   }
+  virtual const std::string& app_id() const { return app_id_; }
+  void set_app_id(const std::string& appId) { app_id_ = appId; }
+
  private:
+  std::string app_id_;
   std::string security_level_;
   const std::string empty_;
 };
@@ -582,29 +586,95 @@ CdmResponseType CdmEngine::Unprovision(CdmSecurityLevel security_level) {
   return status;
 }
 
-CdmResponseType CdmEngine::GetUsageInfo(CdmUsageInfo* usage_info) {
+CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
+                                        const CdmSecureStopId& ssid,
+                                        CdmUsageInfo* usage_info) {
+  if (NULL == usage_property_set_.get()) {
+    usage_property_set_.reset(new UsagePropertySet());
+  }
+  usage_property_set_->set_security_level(kLevelDefault);
+  usage_property_set_->set_app_id(app_id);
+  usage_session_.reset(new CdmSession(usage_property_set_.get()));
+  CdmResponseType status = usage_session_->Init();
+  if (NO_ERROR != status) {
+    LOGE("CdmEngine::GetUsageInfo: session init error");
+    return status;
+  }
+  DeviceFiles handle;
+  if (!handle.Init(usage_session_->GetSecurityLevel())) {
+    LOGE("CdmEngine::GetUsageInfo: device file init error");
+    return UNKNOWN_ERROR;
+  }
+
+  CdmKeyMessage license_request;
+  CdmKeyResponse license_response;
+  if (!handle.RetrieveUsageInfo(app_id, ssid, &license_request,
+                                &license_response)) {
+    usage_property_set_->set_security_level(kLevel3);
+    usage_property_set_->set_app_id(app_id);
+    usage_session_.reset(new CdmSession(usage_property_set_.get()));
+    status = usage_session_->Init();
+    if (NO_ERROR != status) {
+      LOGE("CdmEngine::GetUsageInfo: session init error");
+      return status;
+    }
+    if (!handle.Reset(usage_session_->GetSecurityLevel())) {
+      LOGE("CdmEngine::GetUsageInfo: device file init error");
+      return UNKNOWN_ERROR;
+    }
+    if (!handle.RetrieveUsageInfo(app_id, ssid, &license_request,
+                                  &license_response)) {
+      // No entry found for that ssid.
+      return UNKNOWN_ERROR;
+    }
+  }
+
+  std::string server_url;
+  usage_info->resize(1);
+  status =
+      usage_session_->RestoreUsageSession(license_request, license_response);
+  if (KEY_ADDED != status) {
+    LOGE("CdmEngine::GetUsageInfo: restore usage session error %d", status);
+    usage_info->clear();
+    return status;
+  }
+
+  status =
+      usage_session_->GenerateReleaseRequest(&(*usage_info)[0], &server_url);
+
+  if (KEY_MESSAGE != status) {
+    LOGE("CdmEngine::GetUsageInfo: generate release request error: %d", status);
+    usage_info->clear();
+    return status;
+  }
+  return KEY_MESSAGE;
+}
+
+CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
+                                        CdmUsageInfo* usage_info) {
   // Return a random usage report from a random security level
   SecurityLevel security_level = ((rand() % 2) == 0) ? kLevelDefault : kLevel3;
-  CdmResponseType status = GetUsageInfo(security_level, usage_info);
+  CdmResponseType status = GetUsageInfo(app_id, security_level, usage_info);
 
   if (KEY_MESSAGE == status && !usage_info->empty())
     return status;
 
   security_level = (kLevel3 == security_level) ? kLevelDefault : kLevel3;
-  status = GetUsageInfo(security_level, usage_info);
+  status = GetUsageInfo(app_id, security_level, usage_info);
   if (NEED_PROVISIONING == status)
     return NO_ERROR;  // Valid scenario that one of the security
                       // levels has not been provisioned
   return status;
 }
 
-CdmResponseType CdmEngine::GetUsageInfo(
+CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
-    SecurityLevel requested_security_level,
+                                        SecurityLevel requested_security_level,
-    CdmUsageInfo* usage_info) {
+                                        CdmUsageInfo* usage_info) {
   if (NULL == usage_property_set_.get()) {
     usage_property_set_.reset(new UsagePropertySet());
   }
   usage_property_set_->set_security_level(requested_security_level);
+  usage_property_set_->set_app_id(app_id);
 
   usage_session_.reset(new CdmSession(usage_property_set_.get()));
 
@@ -617,11 +687,11 @@ CdmResponseType CdmEngine::GetUsageInfo(
   DeviceFiles handle;
   if (!handle.Init(usage_session_->GetSecurityLevel())) {
     LOGE("CdmEngine::GetUsageInfo: unable to initialize device files");
-    return status;
+    return UNKNOWN_ERROR;
   }
 
   std::vector<std::pair<CdmKeyMessage, CdmKeyResponse> > license_info;
-  if (!handle.RetrieveUsageInfo(&license_info)) {
+  if (!handle.RetrieveUsageInfo(app_id, &license_info)) {
     LOGE("CdmEngine::GetUsageInfo: unable to read usage information");
     return UNKNOWN_ERROR;
   }
@@ -655,6 +725,23 @@ CdmResponseType CdmEngine::GetUsageInfo(
   return KEY_MESSAGE;
 }
 
+CdmResponseType CdmEngine::ReleaseAllUsageInfo(const std::string& app_id) {
+  CdmResponseType status = NO_ERROR;
+  DeviceFiles handle[kSecurityLevelUnknown - kSecurityLevelL1];
+  for (int i = 0, j = kSecurityLevelL1; j < kSecurityLevelUnknown; ++i, ++j) {
+    if (handle[i].Init(static_cast<CdmSecurityLevel>(j))) {
+      if (!handle[i].DeleteAllUsageInfoForApp(app_id)) {
+        LOGE("CdmEngine::ReleaseAllUsageInfo: failed to delete L%d secure stops", j);
+        status = UNKNOWN_ERROR;
+      }
+    } else {
+      LOGE("CdmEngine::ReleaseAllUsageInfo: failed to initialize L%d device files", j);
+      status = UNKNOWN_ERROR;
+    }
+  }
+  return status;
+}
+
 CdmResponseType CdmEngine::ReleaseUsageInfo(
     const CdmUsageInfoReleaseMessage& message) {
   if (NULL == usage_session_.get()) {

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -81,6 +81,7 @@ void CdmSession::Create(
   }
   security_level_ = GetRequestedSecurityLevel() == kLevel3
                         ? kSecurityLevelL3 : GetSecurityLevel();
+  app_id_.clear();
 }
 
 CdmSession::~CdmSession() { Properties::RemoveSessionPropertySet(session_id_); }
@@ -503,8 +504,10 @@ CdmResponseType CdmSession::StoreLicense() {
     return UNKNOWN_ERROR;
   }
 
+  std::string app_id;
+  GetApplicationId(&app_id);
   if (!file_handle_->StoreUsageInfo(provider_session_token, key_request_,
-                                    key_response_)) {
+                                    key_response_, app_id)) {
     LOGE("CdmSession::StoreLicense: Unable to store usage info");
     return UNKNOWN_ERROR;
   }
@@ -532,11 +535,14 @@ bool CdmSession::DeleteLicense() {
     return false;
   }
 
-  if (is_offline_)
+  if (is_offline_) {
     return file_handle_->DeleteLicense(key_set_id_);
-  else
+  } else {
+    std::string app_id;
+    GetApplicationId(&app_id);
     return file_handle_->DeleteUsageInfo(
-               license_parser_->provider_session_token());
+        app_id, license_parser_->provider_session_token());
+  }
 }
 
 bool CdmSession::AttachEventListener(WvCdmEventListener* listener) {
@@ -579,6 +585,12 @@ void CdmSession::OnKeyReleaseEvent(const CdmKeySetId& key_set_id) {
   }
 }
 
+void CdmSession::GetApplicationId(std::string* app_id) {
+  if (app_id && !Properties::GetApplicationId(session_id_, app_id)) {
+    *app_id = "";
+  }
+}
+
 SecurityLevel CdmSession::GetRequestedSecurityLevel() {
   std::string security_level;
   if (Properties::GetSecurityLevel(session_id_, &security_level) &&
@@ -596,6 +608,20 @@ CdmSecurityLevel CdmSession::GetSecurityLevel() {
   return crypto_session_.get()->GetSecurityLevel();
 }
 
+CdmResponseType CdmSession::DeleteUsageInformation(const std::string& app_id) {
+  if (!file_handle_->Reset(security_level_)) {
+    LOGE("CdmSession::StoreLicense: Unable to initialize device files");
+    return UNKNOWN_ERROR;
+  }
+
+  if (file_handle_->DeleteAllUsageInfoForApp(app_id)) {
+    return NO_ERROR;
+  } else {
+    LOGE("CdmSession::DeleteUsageInformation: failed");
+    return UNKNOWN_ERROR;
+  }
+}
+
 CdmResponseType CdmSession::UpdateUsageInformation() {
   return crypto_session_->UpdateUsageInformation();
 }

libwvdrmengine/cdm/core/src/device_files.cpp

@@ -8,6 +8,7 @@
 # define SHA256_DIGEST_LENGTH CC_SHA256_DIGEST_LENGTH
 #else
 # include <openssl/sha.h>
+#include <openssl/md5.h>
 #endif
 
 #include <cstring>
@@ -31,7 +32,8 @@ using video_widevine_client::sdk::UsageInfo_ProviderSession;
 namespace {
 
 const char kCertificateFileName[] = "cert.bin";
-const char kUsageInfoFileName[] = "usage.bin";
+const char kUsageInfoFileNamePrefix[] = "usage";
+const char kUsageInfoFileNameExt[] = ".bin";
 const char kLicenseFileNameExt[] = ".lic";
 const char kWildcard[] = "*";
 const char kDirectoryDelimiter = '/';
@@ -329,7 +331,8 @@ bool DeviceFiles::LicenseExists(const std::string& key_set_id) {
 
 bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
                                  const CdmKeyMessage& key_request,
-                                 const CdmKeyResponse& key_response) {
+                                 const CdmKeyResponse& key_response,
+                                 const std::string& app_id) {
   if (!initialized_) {
     LOGW("DeviceFiles::StoreUsageInfo: not initialized");
     return false;
@@ -337,7 +340,8 @@ bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
 
   std::string serialized_file;
   video_widevine_client::sdk::File file;
-  if (!RetrieveFile(kUsageInfoFileName, &serialized_file)) {
+  std::string file_name = GetUsageInfoFileName(app_id);
+  if (!RetrieveFile(file_name.c_str(), &serialized_file)) {
     file.set_type(video_widevine_client::sdk::File::USAGE_INFO);
     file.set_version(video_widevine_client::sdk::File::VERSION_1);
   } else {
@@ -358,17 +362,19 @@ bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
                                 key_response.size());
 
   file.SerializeToString(&serialized_file);
-  return StoreFile(kUsageInfoFileName, serialized_file);
+  return StoreFile(file_name.c_str(), serialized_file);
 }
 
-bool DeviceFiles::DeleteUsageInfo(const std::string& provider_session_token) {
+bool DeviceFiles::DeleteUsageInfo(const std::string& app_id,
+                                  const std::string& provider_session_token) {
   if (!initialized_) {
     LOGW("DeviceFiles::DeleteUsageInfo: not initialized");
     return false;
   }
 
   std::string serialized_file;
-  if (!RetrieveFile(kUsageInfoFileName, &serialized_file)) return false;
+  std::string file_name = GetUsageInfoFileName(app_id);
+  if (!RetrieveFile(file_name.c_str(), &serialized_file)) return false;
 
   video_widevine_client::sdk::File file;
   if (!file.ParseFromString(serialized_file)) {
@@ -400,27 +406,29 @@ bool DeviceFiles::DeleteUsageInfo(const std::string& provider_session_token) {
   sessions->RemoveLast();
 
   file.SerializeToString(&serialized_file);
-  return StoreFile(kUsageInfoFileName, serialized_file);
+  return StoreFile(file_name.c_str(), serialized_file);
 }
 
-bool DeviceFiles::DeleteUsageInfo() {
+bool DeviceFiles::DeleteAllUsageInfoForApp(const std::string& app_id) {
   if (!initialized_) {
-    LOGW("DeviceFiles::DeleteUsageInfo: not initialized");
+    LOGW("DeviceFiles::DeleteAllUsageInfoForApp: not initialized");
     return false;
   }
 
   std::string path;
   if (!Properties::GetDeviceFilesBasePath(security_level_, &path)) {
-    LOGW("DeviceFiles::DeleteUsageInfo: Unable to get base path");
+    LOGW("DeviceFiles::DeleteAllUsageInfoForApp: Unable to get base path");
     return false;
   }
-  path.append(kUsageInfoFileName);
+  std::string file_name = GetUsageInfoFileName(app_id);
+  path.append(file_name);
 
   return file_->Remove(path);
 }
 
-bool DeviceFiles::RetrieveUsageInfo(std::vector<
+bool DeviceFiles::RetrieveUsageInfo(
-    std::pair<CdmKeyMessage, CdmKeyResponse> >* usage_info) {
+    const std::string &app_id,
+    std::vector<std::pair<CdmKeyMessage, CdmKeyResponse> >* usage_info) {
   if (!initialized_) {
     LOGW("DeviceFiles::RetrieveUsageInfo: not initialized");
     return false;
@@ -433,13 +441,14 @@ bool DeviceFiles::RetrieveUsageInfo(std::vector<
   }
 
   std::string serialized_file;
-  if (!RetrieveFile(kUsageInfoFileName, &serialized_file)) {
+  std::string file_name = GetUsageInfoFileName(app_id);
+  if (!RetrieveFile(file_name.c_str(), &serialized_file)) {
     std::string path;
     if (!Properties::GetDeviceFilesBasePath(security_level_, &path)) {
       return false;
     }
 
-    path += kUsageInfoFileName;
+    path += file_name;
 
     if (!file_->Exists(path) || 0 == file_->FileSize(path)) {
       usage_info->resize(0);
@@ -465,6 +474,42 @@ bool DeviceFiles::RetrieveUsageInfo(std::vector<
   return true;
 }
 
+bool DeviceFiles::RetrieveUsageInfo(const std::string& app_id,
+                                    const std::string& provider_session_token,
+                                    CdmKeyMessage* license_request,
+                                    CdmKeyResponse* license_response) {
+  if (!initialized_) {
+    LOGW("DeviceFiles::RetrieveUsageInfo: not initialized");
+    return false;
+  }
+  std::string serialized_file;
+  std::string file_name = GetUsageInfoFileName(app_id);
+  if (!RetrieveFile(file_name.c_str(), &serialized_file)) return false;
+
+  video_widevine_client::sdk::File file;
+  if (!file.ParseFromString(serialized_file)) {
+    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().compare(
+            provider_session_token) == 0) {
+      found = true;
+      break;
+    }
+  }
+
+  if (!found) {
+    return false;
+  }
+
+  *license_request = file.usage_info().sessions(index).license_request();
+  *license_response = file.usage_info().sessions(index).license();
+  return true;
+}
+
 bool DeviceFiles::StoreFile(const char* name,
                             const std::string& serialized_file) {
   if (!file_.get()) {
@@ -671,8 +716,15 @@ std::string DeviceFiles::GetLicenseFileNameExtension() {
   return kLicenseFileNameExt;
 }
 
-std::string DeviceFiles::GetUsageInfoFileName() {
+std::string DeviceFiles::GetUsageInfoFileName(const std::string& app_id) {
-  return kUsageInfoFileName;
+  if (app_id == "") return std::string(kUsageInfoFileNamePrefix)
+                        + std::string(kUsageInfoFileNameExt);
+  std::vector<uint8_t> hash(MD5_DIGEST_LENGTH);
+  const unsigned char* input =
+      reinterpret_cast<const unsigned char*>(app_id.data());
+  MD5(input, app_id.size(), &hash[0]);
+  return std::string(kUsageInfoFileNamePrefix) + wvcdm::Base64SafeEncode(hash) +
+         std::string(kUsageInfoFileNameExt);
 }
 
 void DeviceFiles::SetTestFile(File* file) {

libwvdrmengine/cdm/core/src/properties.cpp

@@ -60,6 +60,17 @@ const CdmClientPropertySet* Properties::GetCdmClientPropertySet(
   return NULL;
 }
 
+bool Properties::GetApplicationId(const CdmSessionId& session_id,
+                                  std::string* app_id) {
+  const CdmClientPropertySet* property_set =
+      GetCdmClientPropertySet(session_id);
+  if (NULL == property_set) {
+    return false;
+  }
+  *app_id = property_set->app_id();
+  return true;
+}
+
 bool Properties::GetSecurityLevel(const CdmSessionId& session_id,
                                   std::string* security_level) {
   const CdmClientPropertySet* property_set =

libwvdrmengine/cdm/core/test/device_files_unittest.cpp

@@ -1747,7 +1747,8 @@ TEST_F(DeviceFilesTest, DeleteLicense) {
 
 TEST_P(DeviceFilesUsageInfoTest, Read) {
   MockFile file;
-  std::string path = device_base_path_ + DeviceFiles::GetUsageInfoFileName();
+  std::string app_id;  // TODO(fredgc): expand tests.
+  std::string path = device_base_path_ + DeviceFiles::GetUsageInfoFileName(app_id);
 
   int index = GetParam();
   std::string data;
@@ -1777,7 +1778,7 @@ TEST_P(DeviceFilesUsageInfoTest, Read) {
   device_files.SetTestFile(&file);
 
   std::vector<std::pair<CdmKeyMessage, CdmKeyResponse> > license_info;
-  ASSERT_TRUE(device_files.RetrieveUsageInfo(&license_info));
+  ASSERT_TRUE(device_files.RetrieveUsageInfo(app_id, &license_info));
   if (index >= 0) {
     EXPECT_EQ(index, license_info.size());
     for (size_t i = 0; i < license_info.size(); ++i) {
@@ -1799,10 +1800,11 @@ TEST_P(DeviceFilesUsageInfoTest, Read) {
 
 TEST_P(DeviceFilesUsageInfoTest, Store) {
   MockFile file;
+  std::string app_id; // TODO(fredgc): expand tests.
   std::string pst(GenerateRandomData(kProviderSessionTokenLen));
   std::string license_request(GenerateRandomData(kLicenseRequestLen));
   std::string license(GenerateRandomData(kLicenseLen));
-  std::string path = device_base_path_ + DeviceFiles::GetUsageInfoFileName();
+  std::string path = device_base_path_ + DeviceFiles::GetUsageInfoFileName(app_id);
 
   int index = GetParam();
   std::string data;
@@ -1836,12 +1838,13 @@ TEST_P(DeviceFilesUsageInfoTest, Store) {
   EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
   device_files.SetTestFile(&file);
 
-  ASSERT_TRUE(device_files.StoreUsageInfo(pst, license_request, license));
+  ASSERT_TRUE(device_files.StoreUsageInfo(pst, license_request, license, app_id));
 }
 
 TEST_P(DeviceFilesUsageInfoTest, Delete) {
   MockFile file;
-  std::string path = device_base_path_ + DeviceFiles::GetUsageInfoFileName();
+  std::string app_id; // TODO(fredgc): expand tests.
+  std::string path = device_base_path_ + DeviceFiles::GetUsageInfoFileName(app_id);
 
   int index = GetParam();
   if (index < 0) return;
@@ -1886,9 +1889,9 @@ TEST_P(DeviceFilesUsageInfoTest, Delete) {
   device_files.SetTestFile(&file);
 
   if (index >= 1) {
-    ASSERT_TRUE(device_files.DeleteUsageInfo(pst));
+    ASSERT_TRUE(device_files.DeleteUsageInfo(app_id, pst));
   } else {
-    ASSERT_FALSE(device_files.DeleteUsageInfo(pst));
+    ASSERT_FALSE(device_files.DeleteUsageInfo(app_id, pst));
   }
 }
 

libwvdrmengine/cdm/include/wv_content_decryption_module.h

@@ -85,7 +85,12 @@ class WvContentDecryptionModule : public TimerHandler {
   virtual CdmResponseType Unprovision(CdmSecurityLevel level);
 
   // Secure stop related methods
-  virtual CdmResponseType GetUsageInfo(CdmUsageInfo* usage_info);
+  virtual CdmResponseType GetUsageInfo(const std::string& app_id,
+                                       CdmUsageInfo* usage_info);
+  virtual CdmResponseType GetUsageInfo(const std::string& app_id,
+                                       const CdmSecureStopId& ssid,
+                                       CdmUsageInfo* usage_info);
+  virtual CdmResponseType ReleaseAllUsageInfo(const std::string& app_id);
   virtual CdmResponseType ReleaseUsageInfo(
       const CdmUsageInfoReleaseMessage& message);
 

libwvdrmengine/cdm/src/wv_content_decryption_module.cpp

@@ -159,8 +159,20 @@ CdmResponseType WvContentDecryptionModule::Unprovision(
 }
 
 CdmResponseType WvContentDecryptionModule::GetUsageInfo(
+    const std::string& app_id, CdmUsageInfo* usage_info) {
+  return cdm_engine_->GetUsageInfo(app_id, usage_info);
+}
+
+CdmResponseType WvContentDecryptionModule::GetUsageInfo(
+    const std::string& app_id,
+    const CdmSecureStopId& ssid,
     CdmUsageInfo* usage_info) {
-  return cdm_engine_->GetUsageInfo(usage_info);
+  return cdm_engine_->GetUsageInfo(app_id, ssid, usage_info);
+}
+
+CdmResponseType WvContentDecryptionModule::ReleaseAllUsageInfo(
+    const std::string& app_id) {
+  return cdm_engine_->ReleaseAllUsageInfo(app_id);
 }
 
 CdmResponseType WvContentDecryptionModule::ReleaseUsageInfo(

libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp

@@ -1022,7 +1022,8 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
   uint32_t num_usage_info = 0;
   CdmUsageInfo usage_info;
   CdmUsageInfoReleaseMessage release_msg;
-  CdmResponseType status = decryptor_.GetUsageInfo(&usage_info);
+  std::string app_id;
+  CdmResponseType status = decryptor_.GetUsageInfo(app_id, &usage_info);
   EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
   while (usage_info.size() > 0) {
     for (size_t i = 0; i < usage_info.size(); ++i) {
@@ -1034,7 +1035,7 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
           GetUsageInfoResponse(g_license_server, g_client_auth, usage_info[i]);
       EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg));
     }
-    status = decryptor_.GetUsageInfo(&usage_info);
+    status = decryptor_.GetUsageInfo(app_id, &usage_info);
     switch (status) {
       case KEY_MESSAGE:
         EXPECT_FALSE(usage_info.empty());

libwvdrmengine/cdm/test/request_license_test.cpp

@@ -393,6 +393,7 @@ class TestWvCdmClientPropertySet : public CdmClientPropertySet {
         session_sharing_id_(0) {}
   virtual ~TestWvCdmClientPropertySet() {}
 
+  virtual const std::string& app_id() const { return app_id_; }
   virtual const std::string& security_level() const { return security_level_; }
   virtual const std::string& service_certificate() const {
     return service_certificate_;
@@ -403,6 +404,7 @@ class TestWvCdmClientPropertySet : public CdmClientPropertySet {
   }
   virtual uint32_t session_sharing_id() const { return session_sharing_id_; }
 
+  void set_app_id(const std::string& app_id) { app_id_ = app_id; }
   void set_security_level(const std::string& security_level) {
     if (!security_level.compare(QUERY_VALUE_SECURITY_LEVEL_L1) ||
         !security_level.compare(QUERY_VALUE_SECURITY_LEVEL_L3)) {
@@ -421,6 +423,7 @@ class TestWvCdmClientPropertySet : public CdmClientPropertySet {
   void set_session_sharing_id(uint32_t id) { session_sharing_id_ = id; }
 
  private:
+  std::string app_id_;
   std::string security_level_;
   std::string service_certificate_;
   bool use_privacy_mode_;
@@ -830,6 +833,14 @@ TEST_F(WvCdmRequestLicenseTest, PropertySetTest) {
   EXPECT_TRUE(security_level.empty() ||
               !security_level.compare(QUERY_VALUE_SECURITY_LEVEL_L3));
 
+  std::string app_id = "not empty";
+  EXPECT_TRUE(Properties::GetApplicationId(session_id_Ln, &app_id));
+  EXPECT_STREQ("", app_id.c_str());
+
+  property_set_Ln.set_app_id("com.unittest.mock.app.id");
+  EXPECT_TRUE(Properties::GetApplicationId(session_id_Ln, &app_id));
+  EXPECT_STREQ("com.unittest.mock.app.id", app_id.c_str());
+
   decryptor_.CloseSession(session_id_L1);
   decryptor_.CloseSession(session_id_L3);
   decryptor_.CloseSession(session_id_Ln);
@@ -1202,7 +1213,7 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) {
   EXPECT_TRUE(handle.Init(security_level));
   File file;
   handle.SetTestFile(&file);
-  EXPECT_TRUE(handle.DeleteUsageInfo());
+  EXPECT_TRUE(handle.DeleteAllUsageInfoForApp(""));  // default app_id.
 
   for (size_t i = 0; i < usage_info_data->usage_info; ++i) {
     SubSampleInfo* data = usage_info_data->sub_sample + i;
@@ -1236,7 +1247,8 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) {
   uint32_t num_usage_info = 0;
   CdmUsageInfo usage_info;
   CdmUsageInfoReleaseMessage release_msg;
-  CdmResponseType status = decryptor_.GetUsageInfo(&usage_info);
+  CdmResponseType status =
+      decryptor_.GetUsageInfo(property_set->app_id(), &usage_info);
   EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
   while (usage_info.size() > 0) {
     for (size_t i = 0; i < usage_info.size(); ++i) {
@@ -1244,7 +1256,7 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) {
           GetUsageInfoResponse(g_license_server, g_client_auth, usage_info[i]);
       EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg));
     }
-    status = decryptor_.GetUsageInfo(&usage_info);
+    status = decryptor_.GetUsageInfo(property_set->app_id(), &usage_info);
     switch (status) {
       case KEY_MESSAGE: EXPECT_FALSE(usage_info.empty()); break;
       case NO_ERROR: EXPECT_TRUE(usage_info.empty()); break;

libwvdrmengine/mediadrm/include/WVDrmPlugin.h

@@ -85,8 +85,13 @@ class WVDrmPlugin : public android::DrmPlugin,
 
   virtual status_t unprovisionDevice();
 
+  virtual status_t getSecureStop(const Vector<uint8_t>& ssid,
+                                 Vector<uint8_t>& secureStop);
+
   virtual status_t getSecureStops(List<Vector<uint8_t> >& secureStops);
 
+  virtual status_t releaseAllSecureStops();
+
   virtual status_t releaseSecureStops(const Vector<uint8_t>& ssRelease);
 
   virtual status_t getPropertyString(const String8& name, String8& value) const;
@@ -219,6 +224,14 @@ class WVDrmPlugin : public android::DrmPlugin,
       mSessionSharingId = id;
     }
 
+    virtual const std::string& app_id() const {
+      return mAppId;
+    }
+
+    void set_app_id(const std::string& appId) {
+      mAppId = appId;
+    }
+
    private:
     DISALLOW_EVIL_CONSTRUCTORS(WVClientPropertySet);
 
@@ -227,6 +240,7 @@ class WVDrmPlugin : public android::DrmPlugin,
     std::string mServiceCertificate;
     bool mShareKeys;
     uint32_t mSessionSharingId;
+    std::string mAppId;
   } mPropertySet;
 
   WvContentDecryptionModule* mCDM;

libwvdrmengine/mediadrm/src/WVDrmPlugin.cpp

@@ -23,7 +23,6 @@ namespace {
   static const char* const kResetSecurityLevel = "";
   static const char* const kEnable = "enable";
   static const char* const kDisable = "disable";
-
   static const std::string kPsshTag = "pssh";
 }
 
@@ -394,9 +393,30 @@ status_t WVDrmPlugin::unprovisionDevice() {
   }
 }
 
+status_t WVDrmPlugin::getSecureStop(const Vector<uint8_t>& ssid,
+                                    Vector<uint8_t>& secureStop) {
+  CdmUsageInfo cdmUsageInfo;
+  CdmSecureStopId cdmSsid(ssid.begin(), ssid.end());
+  CdmResponseType res = mCDM->GetUsageInfo(
+      mPropertySet.app_id(), cdmSsid, &cdmUsageInfo);
+  if (isCdmResponseTypeSuccess(res)) {
+    secureStop.clear();
+    for (CdmUsageInfo::const_iterator iter = cdmUsageInfo.begin();
+         iter != cdmUsageInfo.end();
+         ++iter) {
+      const string& cdmStop = *iter;
+
+      secureStop.appendArray(reinterpret_cast<const uint8_t*>(cdmStop.data()),
+                       cdmStop.size());
+    }
+  }
+  return mapCdmResponseType(res);
+}
+
 status_t WVDrmPlugin::getSecureStops(List<Vector<uint8_t> >& secureStops) {
   CdmUsageInfo cdmUsageInfo;
-  CdmResponseType res = mCDM->GetUsageInfo(&cdmUsageInfo);
+  CdmResponseType res =
+      mCDM->GetUsageInfo(mPropertySet.app_id(), &cdmUsageInfo);
   if (isCdmResponseTypeSuccess(res)) {
     secureStops.clear();
     for (CdmUsageInfo::const_iterator iter = cdmUsageInfo.begin();
@@ -414,6 +434,11 @@ status_t WVDrmPlugin::getSecureStops(List<Vector<uint8_t> >& secureStops) {
   return mapCdmResponseType(res);
 }
 
+status_t WVDrmPlugin::releaseAllSecureStops() {
+  CdmResponseType res = mCDM->ReleaseAllUsageInfo(mPropertySet.app_id());
+  return mapCdmResponseType(res);
+}
+
 status_t WVDrmPlugin::releaseSecureStops(const Vector<uint8_t>& ssRelease) {
   CdmUsageInfoReleaseMessage cdmMessage(ssRelease.begin(), ssRelease.end());
   CdmResponseType res = mCDM->ReleaseUsageInfo(cdmMessage);
@@ -628,6 +653,18 @@ status_t WVDrmPlugin::setPropertyString(const String8& name,
       ALOGE("App tried to change key sharing while sessions are open.");
       return kErrorSessionIsOpen;
     }
+  } else if (name == "appId") {
+    size_t sessionCount = 0;
+    {
+      Mutex::Autolock lock(mCryptoSessionsMutex);
+      sessionCount = mCryptoSessions.size();
+    }
+    if (sessionCount == 0) {
+      mPropertySet.set_app_id(value.string());
+    } else {
+      ALOGE("App tried to set the application id while sessions are opened.");
+      return kErrorSessionIsOpen;
+    }
   } else {
     ALOGE("App set unknown string property %s", name.string());
     return android::ERROR_DRM_CANNOT_HANDLE;

libwvdrmengine/mediadrm/test/Android.mk

@@ -12,6 +12,7 @@ LOCAL_C_INCLUDES := \
   frameworks/native/include \
   vendor/widevine/libwvdrmengine/cdm/core/include \
   vendor/widevine/libwvdrmengine/cdm/include \
+  vendor/widevine/libwvdrmengine/include \
   vendor/widevine/libwvdrmengine/mediadrm/include \
   vendor/widevine/libwvdrmengine/oemcrypto/include \
   vendor/widevine/libwvdrmengine/test/gmock/include \

libwvdrmengine/mediadrm/test/WVDrmPlugin_test.cpp

@@ -16,6 +16,7 @@
 #include "wv_cdm_types.h"
 #include "wv_content_decryption_module.h"
 #include "WVDrmPlugin.h"
+#include "WVErrors.h"
 
 using namespace android;
 using namespace std;
@@ -65,10 +66,17 @@ class MockCDM : public WvContentDecryptionModule {
   MOCK_METHOD3(HandleProvisioningResponse,
       CdmResponseType(CdmProvisioningResponse&, std::string*, std::string*));
 
-  MOCK_METHOD1(GetUsageInfo, CdmResponseType(CdmUsageInfo*));
+  MOCK_METHOD2(GetUsageInfo, CdmResponseType(const std::string&,
+                                             CdmUsageInfo*));
+
+  MOCK_METHOD3(GetUsageInfo, CdmResponseType(const std::string&,
+                                             const CdmSecureStopId&,
+                                             CdmUsageInfo*));
 
   MOCK_METHOD1(Unprovision, CdmResponseType(CdmSecurityLevel));
 
+  MOCK_METHOD1(ReleaseAllUsageInfo, CdmResponseType(const std::string&));
+
   MOCK_METHOD1(ReleaseUsageInfo,
       CdmResponseType(const CdmUsageInfoReleaseMessage&));
 
@@ -599,6 +607,8 @@ TEST_F(WVDrmPluginTest, GetsSecureStops) {
   StrictMock<MockCDM> cdm;
   StrictMock<MockCrypto> crypto;
   WVDrmPlugin plugin(&cdm, &crypto);
+  const char* app_id = "my_app_id";
+  plugin.setPropertyString(String8("appId"), String8(app_id));
 
   static const uint32_t kStopSize = 53;
   static const uint32_t kStopCount = 7;
@@ -614,8 +624,8 @@ TEST_F(WVDrmPluginTest, GetsSecureStops) {
     cdmStops.push_back(string(stopsRaw[i], stopsRaw[i] + kStopSize));
   }
 
-  EXPECT_CALL(cdm, GetUsageInfo(_))
+  EXPECT_CALL(cdm, GetUsageInfo(StrEq(app_id), _))
-      .WillOnce(DoAll(SetArgPointee<0>(cdmStops),
+      .WillOnce(DoAll(SetArgPointee<1>(cdmStops),
                       Return(wvcdm::NO_ERROR)));
 
   List<Vector<uint8_t> > stops;
@@ -637,6 +647,21 @@ TEST_F(WVDrmPluginTest, GetsSecureStops) {
   EXPECT_EQ(stops.end(), iter);
 }
 
+TEST_F(WVDrmPluginTest, ReleasesAllSecureStops) {
+  StrictMock<MockCDM> cdm;
+  StrictMock<MockCrypto> crypto;
+  WVDrmPlugin plugin(&cdm, &crypto);
+
+  status_t res = plugin.setPropertyString(String8("appId"), String8(""));
+  ASSERT_EQ(OK, res);
+
+  EXPECT_CALL(cdm, ReleaseAllUsageInfo(StrEq("")))
+      .Times(1);
+
+  res = plugin.releaseAllSecureStops();
+  ASSERT_EQ(OK, res);
+}
+
 TEST_F(WVDrmPluginTest, ReleasesSecureStops) {
   StrictMock<MockCDM> cdm;
   StrictMock<MockCrypto> crypto;
@@ -1309,6 +1334,59 @@ TEST_F(WVDrmPluginTest, ProvidesExpectedDefaultPropertiesToCdm) {
   EXPECT_EQ(0u, propertySet->service_certificate().size());
   EXPECT_FALSE(propertySet->is_session_sharing_enabled());
   EXPECT_EQ(0u, propertySet->session_sharing_id());
+  EXPECT_STREQ("", propertySet->app_id().c_str());
+}
+TEST_F(WVDrmPluginTest, CanSetAppId) {
+  StrictMock<MockCDM> cdm;
+  StrictMock<MockCrypto> crypto;
+  WVDrmPlugin plugin(&cdm, &crypto);
+
+  const CdmClientPropertySet* propertySet = NULL;
+
+  // Provide expected mock behavior
+  {
+    // Provide expected behavior in response to OpenSession and store the
+    // property set
+    EXPECT_CALL(cdm, OpenSession(_, _, _))
+        .WillRepeatedly(DoAll(SetArgPointee<2>(cdmSessionId),
+                        SaveArg<1>(&propertySet),
+                        Return(wvcdm::NO_ERROR)));
+
+    // Provide expected behavior when plugin requests session control info
+    EXPECT_CALL(cdm, QueryKeyControlInfo(cdmSessionId, _))
+        .WillRepeatedly(Invoke(setSessionIdOnMap<4>));
+
+    // Let gMock know these calls will happen but we aren't interested in them.
+    EXPECT_CALL(cdm, AttachEventListener(_, _))
+        .Times(AtLeast(0));
+
+    EXPECT_CALL(cdm, DetachEventListener(_, _))
+        .Times(AtLeast(0));
+
+    EXPECT_CALL(cdm, CloseSession(_))
+        .Times(AtLeast(0));
+  }
+
+  status_t res;
+
+  // Test setting an empty string
+  res = plugin.setPropertyString(String8("appId"), String8(""));
+  ASSERT_EQ(OK, res);
+
+  // Test setting an application id before a session is opened.
+  const String8 kAppId("com.unittest.mock.app.id");
+  res = plugin.setPropertyString(String8("appId"), kAppId);
+  ASSERT_EQ(OK, res);
+
+  plugin.openSession(sessionId);
+  ASSERT_THAT(propertySet, NotNull());
+
+  // Verify application id is set correctly.
+  EXPECT_STREQ(kAppId, propertySet->app_id().c_str());
+
+  // Test setting application id while session is opened, this should fail.
+  res = plugin.setPropertyString(String8("appId"), kAppId);
+  ASSERT_EQ(kErrorSessionIsOpen, res);
 }
 
 TEST_F(WVDrmPluginTest, CanSetSecurityLevel) {