Implement OEMCrypto_GetNumberOfOpenSessions

Merged from Widevine CDM repo:
https://widevine-internal-review.googlesource.com/#/c/13560/

Change-Id: Ie19bf3e57d0c4b1621b95bd5912a751ccfbaaa7b

libwvdrmengine/cdm/core/include/crypto_session.h

@@ -101,6 +101,7 @@ class CryptoSession {
   virtual bool GetHdcpCapabilities(OemCryptoHdcpVersion* current,
                                    OemCryptoHdcpVersion* max);
   virtual bool GetRandom(size_t data_length, uint8_t* random_data);
+  virtual bool GetNumberOfOpenSessions(size_t* count);
   virtual bool GetMaxNumberOfSessions(size_t* max);
 
  private:

libwvdrmengine/cdm/core/include/wv_cdm_constants.h

@@ -49,6 +49,8 @@ static const std::string QUERY_KEY_MAX_HDCP_LEVEL = "MaxHdcpLevel";
                                                 // maximum supported HDCP level
 static const std::string QUERY_KEY_USAGE_SUPPORT = "UsageSupport";
                                         // whether usage reporting is supported
+static const std::string QUERY_KEY_NUMBER_OF_OPEN_SESSIONS =
+    "NumberOfOpenSessions";
 static const std::string QUERY_KEY_MAX_NUMBER_OF_SESSIONS =
     "MaxNumberOfSessions";
 

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -438,6 +438,12 @@ CdmResponseType CdmEngine::QueryStatus(CdmQueryMap* key_info) {
         supports_usage_reporting ? QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
   }
 
+  size_t number_of_open_sessions;
+  success = crypto_session.GetNumberOfOpenSessions(&number_of_open_sessions);
+  if (success) {
+    (*key_info)[QUERY_KEY_NUMBER_OF_OPEN_SESSIONS] = number_of_open_sessions;
+  }
+
   size_t maximum_number_of_sessions;
   success = crypto_session.GetMaxNumberOfSessions(&maximum_number_of_sessions);
   if (success) {

libwvdrmengine/cdm/core/src/crypto_session.cpp

@@ -985,6 +985,24 @@ bool CryptoSession::GetRandom(size_t data_length, uint8_t* random_data) {
   return true;
 }
 
+bool CryptoSession::GetNumberOfOpenSessions(size_t* count) {
+  LOGV("GetNumberOfOpenSessions");
+  if (!initialized_) return false;
+  if (count == NULL) {
+    LOGE("CryptoSession::GetNumberOfOpenSessions: |count| cannot be NULL");
+    return false;
+  }
+
+  size_t sessions_count;
+  OEMCryptoResult status = OEMCrypto_GetNumberOfOpenSessions(&sessions_count);
+  if (OEMCrypto_SUCCESS != status) {
+    LOGW("OEMCrypto_GetNumberOfOpenSessions fails with %d", status);
+    return false;
+  }
+  *count = sessions_count;
+  return true;
+}
+
 bool CryptoSession::GetMaxNumberOfSessions(size_t* max) {
   LOGV("GetMaxNumberOfSessions");
   if (!initialized_) return false;

libwvdrmengine/oemcrypto/mock/src/oemcrypto_engine_mock.h

@@ -237,6 +237,8 @@ class CryptoEngine {
 
   SessionContext* FindSession(SessionId sid);
 
+  size_t GetNumberOfOpenSessions() { return sessions_.size(); }
+
   void set_current_session_(SessionContext* current) {
     current_session_ = current;
   }

libwvdrmengine/oemcrypto/mock/src/oemcrypto_mock.cpp

@@ -1024,6 +1024,16 @@ bool OEMCrypto_SupportsUsageTable() {
   return supports_usage;
 }
 
+extern "C"
+OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(size_t* count) {
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(%p)\n", count);
+  }
+  if (count == NULL) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  *count = crypto_engine->GetNumberOfOpenSessions();
+  return OEMCrypto_SUCCESS;
+}
+
 extern "C"
 OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(size_t* maximum) {
   if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {

libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp

@@ -1740,22 +1740,30 @@ TEST_F(OEMCryptoClientTest, TwoSessionsOpenClose) {
 }
 
 TEST_F(OEMCryptoClientTest, MaxSessionsOpenClose) {
+  size_t sessions_count;
+  ASSERT_EQ(OEMCrypto_SUCCESS,
+            OEMCrypto_GetNumberOfOpenSessions(&sessions_count));
+  ASSERT_EQ(0, sessions_count);
   size_t max_sessions;
   ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_GetMaxNumberOfSessions(&max_sessions));
   ASSERT_GT(max_sessions, 0);
-  vector<Session> s(max_sessions);
+
-  for (int i = 0; i < s.size(); i++) {
+  vector<OEMCrypto_SESSION> sessions;
-    s[i].open();
+  for (int i = 0; i < max_sessions; i++) {
-    ASSERT_EQ(OEMCrypto_SUCCESS, s[i].getStatus());
+    OEMCrypto_SESSION session_id;
-    ASSERT_TRUE(s[i].isOpen());
+    ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_OpenSession(&session_id));
+    ASSERT_EQ(OEMCrypto_SUCCESS,
+              OEMCrypto_GetNumberOfOpenSessions(&sessions_count));
+    ASSERT_EQ(i + 1, sessions_count);
+    sessions.push_back(session_id);
   }
-  for (int i = 0; i < s.size(); i++) {
+  for (int i = 0; i < sessions.size(); i++) {
-    s[i].close();
+    ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_CloseSession(sessions[i]));
-    ASSERT_EQ(OEMCrypto_SUCCESS, s[i].getStatus());
+    ASSERT_EQ(OEMCrypto_SUCCESS,
-    ASSERT_FALSE(s[i].isOpen());
+              OEMCrypto_GetNumberOfOpenSessions(&sessions_count));
+    ASSERT_EQ(sessions.size() - i - 1, sessions_count);
   }
 }
-// TODO(kqyang): Add more tests exercising multiple sessions.
 
 TEST_F(OEMCryptoClientTest, GenerateNonce) {
   Session s;