Refactor GenerateKeyRequest to reduce number of parameters

[ Merge of http://go/wvgerrit/16625 and http://go/wvgerrit/16633 ]

Reduce the number of parameters needed by GenerateKeyRequest.
Combining all output values into a single struct.

BUG: 26162546
Change-Id: Ibeb3f4df4a8e877511f8ab2e6c543001a921f285

libwvdrmengine/cdm/core/include/cdm_engine.h

@@ -62,22 +62,17 @@ class CdmEngine {
   // app_parameters: Additional, application-specific parameters that factor
   //                 into the request generation. This is ignored for release
   //                 and renewal requests.
-  // key_request: This must be non-null and point to a CdmKeyMessage. The buffer
+  // key_request: This must be non-null and point to a CdmKeyRequest. The
-  //              will have its contents replaced with the key request.
+  //              message field will be filled with the key request, the
-  // key_request_type: May be null. If it is non-null, it will be filled with
+  //              type field will be filled with the key request type,
-  //                   key request type, whether it is an initial request,
+  //              whether it is an initial request, renewal request,
-  //                   renewal request or release request etc.
+  //              release request, etc. The url field will be filled with
-  // server_url: This must be non-null and point to a string. The string will
+  //              the default URL (if one is known) to send this key
-  //             have its contents replaced with the default URL (if one is
+  //              request to.
-  //             known) to send this key request to.
-  // TODO(kqyang): Consider refactor GenerateKeyRequest to reduce the number of
-  // parameters.
   virtual CdmResponseType GenerateKeyRequest(
       const CdmSessionId& session_id, const CdmKeySetId& key_set_id,
       const InitializationData& init_data, const CdmLicenseType license_type,
-      CdmAppParameterMap& app_parameters, CdmKeyMessage* key_request,
+      CdmAppParameterMap& app_parameters, CdmKeyRequest* key_request);
-      CdmKeyRequestType* key_request_type, std::string* server_url);
-
   // Accept license response and extract key info.
   virtual CdmResponseType AddKey(const CdmSessionId& session_id,
                                  const CdmKeyResponse& key_data,
@@ -89,9 +84,8 @@ class CdmEngine {
   virtual CdmResponseType RemoveKeys(const CdmSessionId& session_id);
 
   // Construct valid renewal request for the current session keys.
-  virtual CdmResponseType GenerateRenewalRequest(const CdmSessionId& session_id,
+  virtual CdmResponseType GenerateRenewalRequest(
-                                                 CdmKeyMessage* key_request,
+      const CdmSessionId& session_id, CdmKeyRequest* key_request);
-                                                 std::string* server_url);
 
   // Accept renewal response and update key info.
   virtual CdmResponseType RenewKey(const CdmSessionId& session_id,

libwvdrmengine/cdm/core/include/cdm_session.h

@@ -57,8 +57,7 @@ class CdmSession {
 
   virtual CdmResponseType GenerateKeyRequest(
       const InitializationData& init_data, CdmLicenseType license_type,
-      const CdmAppParameterMap& app_parameters, CdmKeyMessage* key_request,
+      const CdmAppParameterMap& app_parameters, CdmKeyRequest* key_request);
-      CdmKeyRequestType* key_request_type, std::string* server_url);
 
   // AddKey() - Accept license response and extract key info.
   virtual CdmResponseType AddKey(const CdmKeyResponse& key_response);
@@ -78,8 +77,7 @@ class CdmSession {
   // License renewal
   // GenerateRenewalRequest() - Construct valid renewal request for the current
   // session keys.
-  virtual CdmResponseType GenerateRenewalRequest(CdmKeyMessage* key_request,
+  virtual CdmResponseType GenerateRenewalRequest(CdmKeyRequest* key_request);
-                                                 std::string* server_url);
 
   // RenewKey() - Accept renewal response and update key info.
   virtual CdmResponseType RenewKey(const CdmKeyResponse& key_response);
@@ -87,8 +85,7 @@ class CdmSession {
   // License release
   // GenerateReleaseRequest() - Construct valid release request for the current
   // session keys.
-  virtual CdmResponseType GenerateReleaseRequest(CdmKeyMessage* key_request,
+  virtual CdmResponseType GenerateReleaseRequest(CdmKeyRequest* key_request);
-                                                 std::string* server_url);
 
   // ReleaseKey() - Accept response and release key.
   virtual CdmResponseType ReleaseKey(const CdmKeyResponse& key_response);

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -215,6 +215,7 @@ enum CdmResponseType {
   LOAD_USAGE_INFO_MISSING,
   SESSION_FILE_HANDLE_INIT_ERROR,
   INCORRECT_CRYPTO_MODE,
+  INVALID_PARAMETERS_ENG_5
 };
 
 enum CdmKeyStatus {
@@ -334,6 +335,12 @@ struct CdmDecryptionParameters {
         is_video(true) {}
 };
 
+struct CdmKeyRequest {
+  CdmKeyMessage message;
+  CdmKeyRequestType type;
+  std::string url;
+};
+
 // forward class references
 class KeyMessage;
 class Request;

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -197,8 +197,7 @@ bool CdmEngine::IsOpenSession(const CdmSessionId& session_id) {
 CdmResponseType CdmEngine::GenerateKeyRequest(
     const CdmSessionId& session_id, const CdmKeySetId& key_set_id,
     const InitializationData& init_data, const CdmLicenseType license_type,
-    CdmAppParameterMap& app_parameters, CdmKeyMessage* key_request,
+    CdmAppParameterMap& app_parameters, CdmKeyRequest* key_request) {
-    CdmKeyRequestType* key_request_type, std::string* server_url) {
   LOGI("CdmEngine::GenerateKeyRequest");
 
   CdmSessionId id = session_id;
@@ -237,11 +236,11 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
   }
 
   if (!key_request) {
-    LOGE("CdmEngine::GenerateKeyRequest: no key request destination provided");
+    LOGE("CdmEngine::GenerateKeyRequest: output destination provided");
     return INVALID_PARAMETERS_ENG_2;
   }
 
-  key_request->clear();
+  key_request->message.clear();
 
   if (license_type == kLicenseTypeRelease &&
       !iter->second->license_received()) {
@@ -254,8 +253,7 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
   }
 
   sts = iter->second->GenerateKeyRequest(
-      init_data, license_type, app_parameters, key_request, key_request_type,
+      init_data, license_type, app_parameters, key_request);
-      server_url);
 
   if (KEY_MESSAGE != sts) {
     if (sts == NEED_PROVISIONING) {
@@ -374,8 +372,7 @@ CdmResponseType CdmEngine::RemoveKeys(const CdmSessionId& session_id) {
 }
 
 CdmResponseType CdmEngine::GenerateRenewalRequest(
-    const CdmSessionId& session_id, CdmKeyMessage* key_request,
+    const CdmSessionId& session_id, CdmKeyRequest* key_request) {
-    std::string* server_url) {
   LOGI("CdmEngine::GenerateRenewalRequest");
 
   CdmSessionMap::iterator iter = sessions_.find(session_id);
@@ -386,14 +383,13 @@ CdmResponseType CdmEngine::GenerateRenewalRequest(
   }
 
   if (!key_request) {
-    LOGE("CdmEngine::GenerateRenewalRequest: no key request destination");
+    LOGE("CdmEngine::GenerateRenewalRequest: no request destination");
     return INVALID_PARAMETERS_ENG_4;
   }
 
-  key_request->clear();
+  key_request->message.clear();
 
-  CdmResponseType sts =
+  CdmResponseType sts = iter->second->GenerateRenewalRequest(key_request);
-      iter->second->GenerateRenewalRequest(key_request, server_url);
 
   if (KEY_MESSAGE != sts) {
     LOGE("CdmEngine::GenerateRenewalRequest: key request gen. failed, sts=%d",
@@ -784,18 +780,20 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
     }
   }
 
-  std::string server_url;
-  usage_info->resize(1);
   status =
-      usage_session_->RestoreUsageSession(license_request, license_response);
+      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 =
+  CdmKeyRequest request;
-      usage_session_->GenerateReleaseRequest(&(*usage_info)[0], &server_url);
+  status = usage_session_->GenerateReleaseRequest(&request);
+
+  usage_info->clear();
+  usage_info->push_back(request.message);
 
   if (KEY_MESSAGE != status) {
     LOGE("CdmEngine::GetUsageInfo: generate release request error: %d", status);
@@ -873,8 +871,11 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
     return status;
   }
 
-  status =
+  CdmKeyRequest request;
-      usage_session_->GenerateReleaseRequest(&(*usage_info)[0], &server_url);
+  status = usage_session_->GenerateReleaseRequest(&request);
+
+  usage_info->clear();
+  usage_info->push_back(request.message);
 
   switch (status) {
     case KEY_MESSAGE:
@@ -989,8 +990,9 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
     return status;
   }
 
-  std::string server_url;
+  CdmKeyRequest request;
-  status = iter->second->GenerateReleaseRequest(release_message, &server_url);
+  status = iter->second->GenerateReleaseRequest(&request);
+  *release_message = request.message;
 
   switch (status) {
     case KEY_MESSAGE:

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -168,8 +168,9 @@ CdmResponseType CdmSession::RestoreUsageSession(
 
 CdmResponseType CdmSession::GenerateKeyRequest(
     const InitializationData& init_data, CdmLicenseType license_type,
-    const CdmAppParameterMap& app_parameters, CdmKeyMessage* key_request,
+    const CdmAppParameterMap& app_parameters,
-    CdmKeyRequestType* key_request_type, std::string* server_url) {
+    CdmKeyRequest* key_request) {
+
   if (crypto_session_.get() == NULL) {
     LOGW("CdmSession::GenerateKeyRequest: Invalid crypto session");
     return INVALID_CRYPTO_SESSION_1;
@@ -180,6 +181,11 @@ CdmResponseType CdmSession::GenerateKeyRequest(
     return CRYPTO_SESSION_OPEN_ERROR_1;
   }
 
+  if (!key_request) {
+    LOGE("CdmSession::GenerateKeyRequest: No output destination provided");
+    return INVALID_PARAMETERS_ENG_5;
+  }
+
   switch (license_type) {
     case kLicenseTypeTemporary:
       is_temporary_ = true;
@@ -220,13 +226,12 @@ CdmResponseType CdmSession::GenerateKeyRequest(
   }
 
   if (is_release_) {
-    if (key_request_type) *key_request_type = kKeyRequestTypeRelease;
+    return GenerateReleaseRequest(key_request);
-    return GenerateReleaseRequest(key_request, server_url);
   } else if (license_received_) {  // renewal
-    if (key_request_type) *key_request_type = kKeyRequestTypeRenewal;
+    return GenerateRenewalRequest(key_request);
-    return GenerateRenewalRequest(key_request, server_url);
   } else {
-    if (key_request_type) *key_request_type = kKeyRequestTypeInitial;
+    key_request->type = kKeyRequestTypeInitial;
+
     if (!license_parser_->HasInitData()) {
       if (!init_data.is_supported()) {
         LOGW("CdmSession::GenerateKeyRequest: unsupported init data type (%s)",
@@ -246,14 +251,16 @@ CdmResponseType CdmSession::GenerateKeyRequest(
     app_parameters_ = app_parameters;
     CdmResponseType status = license_parser_->PrepareKeyRequest(
                                  init_data, license_type,
-                                 app_parameters, key_request, server_url);
+                                 app_parameters, &key_request->message,
+                                 &key_request->url);
 
     if (KEY_MESSAGE != status) return status;
 
-    key_request_ = *key_request;
+    key_request_ = key_request->message;
     if (is_offline_) {
       offline_init_data_ = init_data.data();
-      offline_release_server_url_ = *server_url;
+      offline_release_server_url_ = key_request->url;
+
     }
 
     return KEY_MESSAGE;
@@ -391,15 +398,17 @@ CdmResponseType CdmSession::Decrypt(const CdmDecryptionParameters& params) {
 // License renewal
 // GenerateRenewalRequest() - Construct valid renewal request for the current
 // session keys.
-CdmResponseType CdmSession::GenerateRenewalRequest(CdmKeyMessage* key_request,
+CdmResponseType CdmSession::GenerateRenewalRequest(
-                                                   std::string* server_url) {
+    CdmKeyRequest* key_request) {
   CdmResponseType status = license_parser_->PrepareKeyUpdateRequest(
-      true, app_parameters_, key_request, server_url);
+      true, app_parameters_, &key_request->message, &key_request->url);
+
+  key_request->type = kKeyRequestTypeRenewal;
 
   if (KEY_MESSAGE != status) return status;
 
   if (is_offline_) {
-    offline_key_renewal_request_ = *key_request;
+    offline_key_renewal_request_ = key_request->message;
   }
   return KEY_MESSAGE;
 }
@@ -418,11 +427,14 @@ CdmResponseType CdmSession::RenewKey(const CdmKeyResponse& key_response) {
   return KEY_ADDED;
 }
 
-CdmResponseType CdmSession::GenerateReleaseRequest(CdmKeyMessage* key_request,
+CdmResponseType CdmSession::GenerateReleaseRequest(
-                                                   std::string* server_url) {
+    CdmKeyRequest* key_request) {
   is_release_ = true;
   CdmResponseType status = license_parser_->PrepareKeyUpdateRequest(
-      false, app_parameters_, key_request, server_url);
+      false, app_parameters_, &key_request->message,
+      &key_request->url);
+
+  key_request->type = kKeyRequestTypeRelease;
 
   if (KEY_MESSAGE != status) return status;
 

libwvdrmengine/cdm/core/test/cdm_engine_test.cpp

@@ -96,22 +96,29 @@ class WvCdmEngineTest : public testing::Test {
   void GenerateKeyRequest(const std::string& key_id,
                           const std::string& init_data_type_string) {
     CdmAppParameterMap app_parameters;
-    std::string server_url;
     CdmKeySetId key_set_id;
 
     InitializationData init_data(init_data_type_string, key_id);
 
-    CdmKeyRequestType key_request_type;
+    CdmKeyRequest key_request;
+
     EXPECT_EQ(KEY_MESSAGE, cdm_engine_.GenerateKeyRequest(
                                session_id_, key_set_id, init_data,
-                               kLicenseTypeStreaming, app_parameters, &key_msg_,
+                               kLicenseTypeStreaming, app_parameters,
-                               &key_request_type, &server_url));
+                               &key_request));
-    EXPECT_EQ(kKeyRequestTypeInitial, key_request_type);
+
+    key_msg_ = key_request.message;
+    EXPECT_EQ(kKeyRequestTypeInitial, key_request.type);
   }
 
   void GenerateRenewalRequest() {
+    CdmKeyRequest request;
+
     EXPECT_EQ(KEY_MESSAGE, cdm_engine_.GenerateRenewalRequest(
-                               session_id_, &key_msg_, &server_url_));
+        session_id_, &request));
+
+    key_msg_ = request.message;
+    server_url_ = request.url;
   }
 
   std::string GetKeyRequestResponse(const std::string& server_url,

libwvdrmengine/cdm/include/wv_content_decryption_module.h

@@ -45,9 +45,7 @@ class WvContentDecryptionModule : public android::RefBase, public TimerHandler {
                                              CdmAppParameterMap& app_parameters,
                                              CdmClientPropertySet* property_set,
                                              const std::string& origin,
-                                             CdmKeyMessage* key_request,
+                                             CdmKeyRequest* key_request);
-                                             CdmKeyRequestType* key_request_type,
-                                             std::string* server_url);
 
   // Accept license response and extract key info.
   virtual CdmResponseType AddKey(const CdmSessionId& session_id,

libwvdrmengine/cdm/src/wv_content_decryption_module.cpp

@@ -72,8 +72,7 @@ CdmResponseType WvContentDecryptionModule::GenerateKeyRequest(
     const std::string& init_data_type, const CdmInitData& init_data,
     const CdmLicenseType license_type, CdmAppParameterMap& app_parameters,
     CdmClientPropertySet* property_set, const std::string& origin,
-    CdmKeyMessage* key_request, CdmKeyRequestType* key_request_type,
+    CdmKeyRequest* key_request) {
-    std::string* server_url) {
   CdmResponseType sts;
   if (license_type == kLicenseTypeRelease) {
     sts = cdm_engine_->OpenKeySetSession(key_set_id, property_set, origin,
@@ -83,7 +82,7 @@ CdmResponseType WvContentDecryptionModule::GenerateKeyRequest(
   InitializationData initialization_data(init_data_type, init_data);
   sts = cdm_engine_->GenerateKeyRequest(
       session_id, key_set_id, initialization_data, license_type, app_parameters,
-      key_request, key_request_type, server_url);
+      key_request);
 
   switch(license_type) {
     case kLicenseTypeRelease:

libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp

@@ -253,14 +253,14 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
   void GenerateKeyRequest(const std::string& init_data,
                           CdmLicenseType license_type) {
     CdmAppParameterMap app_parameters;
-    std::string server_url;
+    CdmKeyRequest key_request;
-    CdmKeyRequestType key_request_type;
+
     EXPECT_EQ(KEY_MESSAGE, decryptor_.GenerateKeyRequest(
                                session_id_, key_set_id_, "video/mp4", init_data,
                                license_type, app_parameters, NULL, EMPTY_ORIGIN,
-                               &key_msg_, &key_request_type, &server_url));
+                               &key_request));
-    EXPECT_EQ(kKeyRequestTypeInitial, key_request_type);
+    EXPECT_EQ(kKeyRequestTypeInitial, key_request.type);
-    EXPECT_EQ(0u, server_url.size());
+    EXPECT_EQ(0u, key_request.url.size());
   }
 
   void GenerateRenewalRequest(CdmLicenseType license_type,
@@ -269,29 +269,34 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
     // when appropriate.
     std::string init_data;
     CdmAppParameterMap app_parameters;
-    CdmKeyRequestType key_request_type;
+
+    CdmKeyRequest key_request;
+
     EXPECT_EQ(KEY_MESSAGE, decryptor_.GenerateKeyRequest(
                                session_id_, key_set_id_, "video/mp4", init_data,
                                license_type, app_parameters, NULL, EMPTY_ORIGIN,
-                               &key_msg_, &key_request_type, server_url));
+                               &key_request));
-    EXPECT_EQ(kKeyRequestTypeRenewal, key_request_type);
+
+    *server_url = key_request.url;
+
+    EXPECT_EQ(kKeyRequestTypeRenewal, key_request.type);
     // TODO(edwinwong, rfrias): Add tests cases for when license server url
     // is empty on renewal. Need appropriate key id at the server.
-    EXPECT_NE(0u, server_url->size());
+    EXPECT_NE(0u, key_request.url.size());
   }
 
   void GenerateKeyRelease(CdmKeySetId key_set_id) {
     CdmSessionId session_id;
     CdmInitData init_data;
     CdmAppParameterMap app_parameters;
-    std::string server_url;
+    CdmKeyRequest key_request;
-    CdmKeyRequestType key_request_type;
+
     EXPECT_EQ(KEY_MESSAGE, decryptor_.GenerateKeyRequest(
                                session_id, key_set_id, "video/mp4", init_data,
                                kLicenseTypeRelease, app_parameters, NULL,
-                               EMPTY_ORIGIN, &key_msg_, &key_request_type,
+                               EMPTY_ORIGIN, &key_request));
-                               &server_url));
+
-    EXPECT_EQ(kKeyRequestTypeRelease, key_request_type);
+    EXPECT_EQ(kKeyRequestTypeRelease, key_request.type);
   }
 
   void LogResponseError(const std::string& message, int http_status_code) {

libwvdrmengine/cdm/test/request_license_test.cpp

@@ -537,14 +537,14 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
                           CdmAppParameterMap& app_parameters,
                           CdmLicenseType license_type,
                           CdmClientPropertySet* property_set) {
-    std::string server_url;
+    CdmKeyRequest key_request;
     std::string key_set_id;
     EXPECT_EQ(wvcdm::KEY_MESSAGE,
               decryptor_.GenerateKeyRequest(
                   session_id_, key_set_id, "video/mp4", init_data, license_type,
-                  app_parameters, property_set, EMPTY_ORIGIN, &key_msg_, NULL,
+                  app_parameters, property_set, EMPTY_ORIGIN, &key_request));
-                  &server_url));
+    key_msg_ = key_request.message;
-    EXPECT_EQ(0u, server_url.size());
+    EXPECT_EQ(0u, key_request.url.size());
   }
 
   void GenerateRenewalRequest(CdmLicenseType license_type,
@@ -560,15 +560,18 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
     std::string init_data;
     wvcdm::CdmAppParameterMap app_parameters;
     wvcdm::CdmKeyRequestType key_request_type;
+    CdmKeyRequest key_request;
     EXPECT_EQ(wvcdm::KEY_MESSAGE,
               decryptor_.GenerateKeyRequest(
                   session_id_, key_set_id_, "video/mp4", init_data,
-                  license_type, app_parameters, NULL, EMPTY_ORIGIN, &key_msg_,
+                  license_type, app_parameters, NULL, EMPTY_ORIGIN,
-                  &key_request_type, server_url));
+                  &key_request));
-    EXPECT_EQ(kKeyRequestTypeRenewal, key_request_type);
+    key_msg_ = key_request.message;
+    *server_url = key_request.url;
+    EXPECT_EQ(kKeyRequestTypeRenewal, key_request.type);
     // TODO(edwinwong, rfrias): Add tests cases for when license server url
     // is empty on renewal. Need appropriate key id at the server.
-    EXPECT_NE(0u, server_url->size());
+    EXPECT_NE(0u, key_request.url.size());
   }
 
   void GenerateKeyRelease(CdmKeySetId key_set_id) {
@@ -581,15 +584,15 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
     CdmSessionId session_id;
     CdmInitData init_data;
     wvcdm::CdmAppParameterMap app_parameters;
-    wvcdm::CdmKeyRequestType key_request_type;
+    CdmKeyRequest key_request;
-    std::string server_url;
     EXPECT_EQ(wvcdm::KEY_MESSAGE,
               decryptor_.GenerateKeyRequest(
                   session_id, key_set_id, "video/mp4", init_data,
                   kLicenseTypeRelease, app_parameters, property_set,
-                  EMPTY_ORIGIN, &key_msg_, &key_request_type, &server_url));
+                  EMPTY_ORIGIN, &key_request));
-    EXPECT_EQ(kKeyRequestTypeRelease, key_request_type);
+    key_msg_ = key_request.message;
-    if (key_msg) *key_msg = key_msg_;
+    EXPECT_EQ(kKeyRequestTypeRelease, key_request.type);
+    if (key_msg) *key_msg = key_request.message;
   }
 
   void LogResponseError(const std::string& message, int http_status_code) {
@@ -1402,15 +1405,15 @@ TEST_F(WvCdmRequestLicenseTest, StreamingLicenseRenewalProhibited) {
   GenerateKeyRequest(key_id, kLicenseTypeStreaming);
   VerifyKeyRequestResponse(g_license_server, g_client_auth, false);
 
-  std::string license_server;
   std::string init_data;
   wvcdm::CdmAppParameterMap app_parameters;
-  wvcdm::CdmKeyRequestType key_request_type;
+  CdmKeyRequest key_request;
   EXPECT_EQ(wvcdm::LICENSE_RENEWAL_PROHIBITED,
             decryptor_.GenerateKeyRequest(
                 session_id_, key_set_id_, "video/mp4", init_data,
-                kLicenseTypeStreaming, app_parameters, NULL, EMPTY_ORIGIN,
+                kLicenseTypeStreaming, app_parameters, NULL,
-                &key_msg_, &key_request_type, &license_server));
+                EMPTY_ORIGIN, &key_request));
+  key_msg_ = key_request.message;
   decryptor_.CloseSession(session_id_);
 }
 

libwvdrmengine/include/WVErrors.h

@@ -186,6 +186,7 @@ enum {
   kSessionFileHandleInitError = ERROR_DRM_VENDOR_MIN + 172,
   kIncorrectCryptoMode = ERROR_DRM_VENDOR_MIN + 173,
   kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 173,
+  kInvalidParametersEng5 = ERROR_DRM_VENDOR_MIN + 174,
 
   // Used by crypto test mode
   kErrorTestMode = ERROR_DRM_VENDOR_MAX,

libwvdrmengine/include/mapErrors-inl.h

@@ -163,6 +163,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
       return kInvalidParametersEng3;
     case wvcdm::INVALID_PARAMETERS_ENG_4:
       return kInvalidParametersEng4;
+    case wvcdm::INVALID_PARAMETERS_ENG_5:
+      return kInvalidParametersEng5;
     case wvcdm::INVALID_PARAMETERS_LIC_1:
       return kInvalidParametersLic1;
     case wvcdm::INVALID_PARAMETERS_LIC_2:

libwvdrmengine/mediadrm/src/WVDrmPlugin.cpp

@@ -225,20 +225,19 @@ status_t WVDrmPlugin::getKeyRequest(
     cdmParameters[cdmKey] = cdmValue;
   }
 
-  CdmKeyMessage keyRequest;
+  CdmKeyRequest keyRequest;
-  CdmKeyRequestType cdmKeyRequestType;
-  string cdmDefaultUrl;
   CdmResponseType res = mCDM->GenerateKeyRequest(
       cdmSessionId, cdmKeySetId, cdmInitDataType, processedInitData,
       cdmLicenseType, cdmParameters, &mPropertySet, determineOrigin(),
-      &keyRequest, &cdmKeyRequestType, &cdmDefaultUrl);
+      &keyRequest);
-  *keyRequestType = ConvertFromCdmKeyRequestType(cdmKeyRequestType);
+
+  *keyRequestType = ConvertFromCdmKeyRequestType(keyRequest.type);
 
   if (isCdmResponseTypeSuccess(res)) {
     defaultUrl.clear();
-    defaultUrl.setTo(cdmDefaultUrl.data(), cdmDefaultUrl.size());
+    defaultUrl.setTo(keyRequest.url.data(), keyRequest.url.size());
 
-    request = ToVector(keyRequest);
+    request = ToVector(keyRequest.message);
   }
 
   if (keyType == kKeyType_Release) {

libwvdrmengine/mediadrm/test/WVDrmPlugin_test.cpp

@@ -44,12 +44,12 @@ class MockCDM : public WvContentDecryptionModule {
 
   MOCK_METHOD1(CloseSession, CdmResponseType(const CdmSessionId&));
 
-  MOCK_METHOD11(GenerateKeyRequest,
+  MOCK_METHOD9(GenerateKeyRequest,
                 CdmResponseType(const CdmSessionId&, const CdmKeySetId&,
                                 const std::string&, const CdmInitData&,
                                 const CdmLicenseType, CdmAppParameterMap&,
                                 CdmClientPropertySet*, const std::string&,
-                                CdmKeyMessage*, CdmKeyRequestType*, string*));
+                                CdmKeyRequest*));
 
   MOCK_METHOD3(AddKey, CdmResponseType(const CdmSessionId&,
                                        const CdmKeyResponse&,
@@ -319,29 +319,41 @@ TEST_F(WVDrmPluginTest, GeneratesKeyRequests) {
       const char* mimeType = testSets[i].mimeType;
       const CdmInitData& initData = testSets[i].initDataOut;
 
+      CdmKeyRequest initialRequest = {
+        cdmRequest,
+        kKeyRequestTypeInitial,
+        kDefaultUrl
+      };
+
+      CdmKeyRequest renewalRequest = {
+        cdmRequest,
+        kKeyRequestTypeRenewal,
+        kDefaultUrl
+      };
+
+      CdmKeyRequest releaseRequest = {
+        cdmRequest,
+        kKeyRequestTypeRelease,
+        kDefaultUrl
+      };
+
       EXPECT_CALL(*cdm, GenerateKeyRequest(cdmSessionId, "", mimeType, initData,
                                           kLicenseTypeOffline, cdmParameters, _,
-                                          _, _, _, _))
+                                          _, _))
-          .WillOnce(DoAll(SetArgPointee<8>(cdmRequest),
+          .WillOnce(DoAll(SetArgPointee<8>(initialRequest),
-                          SetArgPointee<9>(kKeyRequestTypeInitial),
-                          SetArgPointee<10>(kDefaultUrl),
                           Return(wvcdm::KEY_MESSAGE)));
 
       EXPECT_CALL(*cdm, GenerateKeyRequest(cdmSessionId, "", mimeType, initData,
                                           kLicenseTypeStreaming, cdmParameters,
-                                          _, _, _, _, _))
+                                          _, _, _))
-          .WillOnce(DoAll(SetArgPointee<8>(cdmRequest),
+          .WillOnce(DoAll(SetArgPointee<8>(renewalRequest),
-                          SetArgPointee<9>(kKeyRequestTypeRenewal),
-                          SetArgPointee<10>(kDefaultUrl),
                           Return(wvcdm::KEY_MESSAGE)));
 
       EXPECT_CALL(*cdm, GenerateKeyRequest("", cdmKeySetId, mimeType, initData,
                                           kLicenseTypeRelease, cdmParameters,
-                                          NotNull(), StrEq(EMPTY_ORIGIN), _, _,
+                                          NotNull(), StrEq(EMPTY_ORIGIN), _))
-                                          _))
+
-          .WillOnce(DoAll(SetArgPointee<8>(cdmRequest),
+          .WillOnce(DoAll(SetArgPointee<8>(releaseRequest),
-                          SetArgPointee<9>(kKeyRequestTypeRelease),
-                          SetArgPointee<10>(kDefaultUrl),
                           Return(wvcdm::KEY_MESSAGE)));
     }
   }