Use new Base64 encode functions.

[ Merge of http://go/wvgerrit/119806 ]

This change replaces all calls for base64 encoding which first converts
a string to a vector.  The new base64 encoding function allow for
encoding binary data contained within strings.

Bug: 181732604
Test: Android unittests
Change-Id: Ibfe79dba99e6a2ee2f2a96e85b62fbd22519aea7

libwvdrmengine/cdm/core/src/certificate_provisioning.cpp

@@ -318,9 +318,7 @@ CdmResponseType CertificateProvisioning::GetProvisioningRequestInternal(
 
   if (!wvcdm::Properties::provisioning_messages_are_binary()) {
     // Return request as web-safe base64 string
-    std::vector<uint8_t> request_vector(serialized_request.begin(),
-                                        serialized_request.end());
-    *request = Base64SafeEncodeNoPad(request_vector);
+    *request = Base64SafeEncodeNoPad(serialized_request);
   } else {
     *request = std::move(serialized_request);
   }

libwvdrmengine/cdm/core/src/device_files.cpp

@@ -1771,9 +1771,7 @@ std::string DeviceFiles::GetUsageInfoFileName(const std::string& app_id) {
 }
 
 std::string DeviceFiles::GetFileNameSafeHash(const std::string& input) {
-  std::string hash = Md5Hash(input);
-  return wvcdm::Base64SafeEncode(
-      std::vector<uint8_t>(hash.begin(), hash.end()));
+  return wvcdm::Base64SafeEncode(Md5Hash(input));
 }
 
 }  // namespace wvcdm

libwvdrmengine/cdm/core/test/cdm_engine_test.cpp

@@ -107,9 +107,7 @@ class WvCdmEnginePreProvTest : public WvCdmTestBaseWithEngine {
     license_request.GetDrmMessage(http_response, *response);
 
     LOGV("response: size = %zu, string =\n%s\n", response->size(),
-         Base64SafeEncode(
-             std::vector<uint8_t>(response->begin(), response->end()))
-             .c_str());
+         Base64SafeEncode(*response).c_str());
     return true;
   }
 

libwvdrmengine/cdm/core/test/fake_provisioning_server.cpp

@@ -352,11 +352,11 @@ bool FakeProvisioningServer::MakeResponse(
   // CDM.
   std::string response_data;
   signed_response.SerializeToString(&response_data);
-  std::vector<uint8_t> response_data_v(response_data.begin(),
-                                       response_data.end());
-  static const std::string json_start = "{ \"signedResponse\": \"";
-  static const std::string json_end = "\" }";
-  *json_response = json_start + Base64SafeEncode(response_data_v) + json_end;
+  static const std::string kJsonStart = "{ \"signedResponse\": \"";
+  static const std::string kJsonEnd = "\" }";
+  *json_response = kJsonStart;
+  json_response->append(Base64SafeEncode(response_data));
+  json_response->append(kJsonEnd);
   return true;
 }
 

libwvdrmengine/cdm/core/test/initialization_data_unittest.cpp

@@ -341,11 +341,8 @@ class VectorOfStrings {
 std::string GenerateHlsUriData(const std::string& provider,
                                const std::string& content_id,
                                const std::vector<std::string>& key_ids) {
-  std::string json = GenerateJsonInitData(provider, content_id, key_ids);
-  std::vector<uint8_t> json_init_data(
-      reinterpret_cast<const uint8_t*>(json.data()),
-      reinterpret_cast<const uint8_t*>(json.data() + json.size()));
-  return kHlsTestUriDataFormat + Base64Encode(json_init_data);
+  const std::string json = GenerateJsonInitData(provider, content_id, key_ids);
+  return kHlsTestUriDataFormat + Base64Encode(json);
 }
 
 std::string CreateHlsAttributeList(const std::string& method,
@@ -786,19 +783,16 @@ INSTANTIATE_TEST_CASE_P(
             .AddKeyId(kHlsTestKeyId1)));
 
 TEST_F(HlsInitDataConstructionTest, InvalidUriDataFormat) {
-  std::string json =
+  const std::string json =
       GenerateJsonInitData(kHlsTestProvider, kHlsTestContentId,
                            VectorOfStrings(kHlsTestKeyId1).Generate());
-  std::vector<uint8_t> json_init_data(
-      reinterpret_cast<const uint8_t*>(json.data()),
-      reinterpret_cast<const uint8_t*>(json.data() + json.size()));
   std::string value;
   EXPECT_FALSE(InitializationData::ConstructWidevineInitData(
-      kHlsMethodAes128, Base64Encode(json_init_data), &value));
+      kHlsMethodAes128, Base64Encode(json), &value));
 }
 
 TEST_F(HlsInitDataConstructionTest, InvalidUriBase64Encode) {
-  std::string json =
+  const std::string json =
       GenerateJsonInitData(kHlsTestProvider, kHlsTestContentId,
                            VectorOfStrings(kHlsTestKeyId1).Generate());
   std::string value;

libwvdrmengine/cdm/core/test/test_base.cpp

@@ -291,7 +291,6 @@ WvCdmTestBase::WvCdmTestBase()
 
 void WvCdmTestBase::Provision() {
   CdmProvisioningRequest prov_request;
-  CdmProvisioningRequest binary_prov_request;
   std::string provisioning_server_url;
   CdmCertificateType cert_type = kCertificateWidevine;
   std::string cert_authority;
@@ -331,9 +330,7 @@ void WvCdmTestBase::Provision() {
     ASSERT_EQ(NO_ERROR, result);
 
     if (binary_provisioning_) {
-      binary_prov_request = prov_request;
-      prov_request = std::string(Base64SafeEncodeNoPad(std::vector<uint8_t>(
-          binary_prov_request.begin(), binary_prov_request.end())));
+      prov_request = Base64SafeEncodeNoPad(prov_request);
     }
 
     LOGV("Provisioning request: req = %s", prov_request.c_str());

libwvdrmengine/cdm/test/request_license_test.cpp

@@ -8,6 +8,7 @@
 #include <chrono>
 #include <sstream>
 #include <thread>
+#include <utility>
 
 #include <android-base/properties.h>
 #include <gmock/gmock.h>
@@ -2564,9 +2565,9 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningRevocationTest) {
     signed_response.SerializeToString(&response);
 
     if (!wvcdm::Properties::provisioning_messages_are_binary()) {
-      std::vector<uint8_t> response_vec(response.begin(), response.end());
+      const std::string binary_response = std::move(response);
       response = "\"signedResponse\": \"";
-      response.append(wvcdm::Base64SafeEncode(response_vec));
+      response.append(wvcdm::Base64SafeEncode(binary_response));
       response.append("\"");
     }
 

libwvdrmengine/mediadrm/test/WVDrmPlugin_test.cpp

@@ -3224,10 +3224,10 @@ TEST_F(WVDrmPluginTest, CanSetDecryptHashProperties) {
   // "<sessionId>,<frameNumber>,<base64encodedHash>"
   static const std::string frameNumber = ",1";
   uint32_t hash = 0xbeef;  // crc32 hash
-  std::vector<uint8_t> hashVector(
+  const std::vector<uint8_t> hashVector(
       reinterpret_cast<uint8_t*>(&hash),
       reinterpret_cast<uint8_t*>(&hash) + sizeof(uint32_t));
-  std::string base64EncodedHash = Base64Encode(hashVector);
+  const std::string base64EncodedHash = Base64Encode(hashVector);
   std::string computedHash(sessionId.begin(), sessionId.end());
   computedHash.append(frameNumber.c_str());
   computedHash.append(base64EncodedHash.c_str());