Remove dependencies from frameworks C++ containers.

Replace AString, KeyedVector, List, String8 and Vector
with stl containers. Remove corresponding frameworks
libraries.

Test: Play Movies & TV (streaming and pinning)
Test: Netflix
Test: unit tests

bug: 34677927
Change-Id: I125f45054987d69bbca59c1ffdcbe8add38c3c13

libwvdrmengine/mediadrm/include_hidl/WVDrmPlugin.h

@@ -13,8 +13,6 @@
 #include "cdm_client_property_set.h"
 #include "cdm_identifier.h"
 #include "OEMCryptoCENC.h"
-#include "utils/String8.h"
-#include "utils/Vector.h"
 #include "wv_cdm_event_listener.h"
 #include "wv_content_decryption_module.h"
 #include "WVGenericCryptoInterface.h"
@@ -42,8 +40,6 @@ using ::android::hardware::Return;
 using ::android::sp;
 
 using android::status_t;
-using android::String8;
-using android::Vector;
 using std::map;
 using wvcdm::CdmIdentifier;
 using wvcdm::CdmKeyStatusMap;
@@ -350,20 +346,17 @@ struct WVDrmPlugin : public IDrmPlugin, IDrmPluginListener,
                          std::string& stringValue) const;
 
   status_t queryProperty(const std::string& property,
-                         String8& string8_value) const;
+                         std::vector<uint8_t>& vector_value) const;
 
-  status_t queryProperty(const std::string& property,
-                         Vector<uint8_t>& vector_value) const;
-
-  status_t mapAndNotifyOfCdmResponseType(const Vector<uint8_t>& sessionId,
+  status_t mapAndNotifyOfCdmResponseType(const std::vector<uint8_t>& sessionId,
                                          CdmResponseType res);
 
-  status_t mapAndNotifyOfOEMCryptoResult(const Vector<uint8_t>& sessionId,
+  status_t mapAndNotifyOfOEMCryptoResult(const std::vector<uint8_t>& sessionId,
                                          OEMCryptoResult res);
 
   status_t mapOEMCryptoResult(OEMCryptoResult res);
 
-  bool initDataResemblesPSSH(const Vector<uint8_t>& initData);
+  bool initDataResemblesPSSH(const std::vector<uint8_t>& initData);
 
   status_t unprovision(const CdmIdentifier& identifier);
 };

libwvdrmengine/mediadrm/include_hidl/WVGenericCryptoInterface.h

@@ -0,0 +1,95 @@
+//
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+
+#ifndef WV_GENERIC_CRYPTO_INTERFACE_H_
+#define WV_GENERIC_CRYPTO_INTERFACE_H_
+
+#include <stdint.h>
+#include <vector>
+
+#include "OEMCryptoCENC.h"
+#include "media/stagefright/foundation/ABase.h"
+
+namespace wvdrm {
+
+class WVGenericCryptoInterface {
+ public:
+  WVGenericCryptoInterface() {}
+  virtual ~WVGenericCryptoInterface() {}
+
+  virtual OEMCryptoResult selectKey(const OEMCrypto_SESSION session,
+                                    const uint8_t* key_id,
+                                    size_t key_id_length) {
+    return OEMCrypto_SelectKey(session, key_id, key_id_length);
+  }
+
+  virtual OEMCryptoResult encrypt(OEMCrypto_SESSION session,
+                                  const uint8_t* in_buffer,
+                                  size_t buffer_length, const uint8_t* iv,
+                                  OEMCrypto_Algorithm algorithm,
+                                  uint8_t* out_buffer) {
+    return OEMCrypto_Generic_Encrypt(session, in_buffer, buffer_length, iv,
+                                     algorithm, out_buffer);
+  }
+
+  virtual OEMCryptoResult decrypt(OEMCrypto_SESSION session,
+                                  const uint8_t* in_buffer,
+                                  size_t buffer_length, const uint8_t* iv,
+                                  OEMCrypto_Algorithm algorithm,
+                                  uint8_t* out_buffer) {
+    return OEMCrypto_Generic_Decrypt(session, in_buffer, buffer_length, iv,
+                                     algorithm, out_buffer);
+  }
+
+  virtual OEMCryptoResult sign(OEMCrypto_SESSION session,
+                               const uint8_t* in_buffer, size_t buffer_length,
+                               OEMCrypto_Algorithm algorithm,
+                               uint8_t* signature, size_t* signature_length) {
+    return OEMCrypto_Generic_Sign(session, in_buffer, buffer_length, algorithm,
+                                  signature, signature_length);
+  }
+
+  virtual OEMCryptoResult verify(OEMCrypto_SESSION session,
+                                 const uint8_t* in_buffer, size_t buffer_length,
+                                 OEMCrypto_Algorithm algorithm,
+                                 const uint8_t* signature,
+                                 size_t signature_length) {
+    return OEMCrypto_Generic_Verify(session, in_buffer, buffer_length,
+                                    algorithm, signature, signature_length);
+  }
+
+  virtual OEMCryptoResult signRSA(const uint8_t* wrapped_rsa_key,
+                                  size_t wrapped_rsa_key_length,
+                                  const uint8_t* message,
+                                  size_t message_length,
+                                  std::vector<uint8_t>& signature,
+                                  RSA_Padding_Scheme padding_scheme);
+
+
+  virtual OEMCryptoResult loadDeviceRSAKey(OEMCrypto_SESSION session,
+                                           const uint8_t* wrapped_rsa_key,
+                                           size_t wrapped_rsa_key_length) {
+    return OEMCrypto_LoadDeviceRSAKey(session, wrapped_rsa_key,
+                                      wrapped_rsa_key_length);
+  }
+
+  virtual OEMCryptoResult generateRSASignature(
+      OEMCrypto_SESSION session,
+      const uint8_t* message,
+      size_t message_length,
+      uint8_t* signature,
+      size_t* signature_length,
+      RSA_Padding_Scheme padding_scheme) {
+  return OEMCrypto_GenerateRSASignature(session, message, message_length,
+                                        signature, signature_length,
+                                        padding_scheme);
+}
+
+ private:
+  DISALLOW_EVIL_CONSTRUCTORS(WVGenericCryptoInterface);
+};
+
+} // namespace wvdrm
+
+#endif // WV_GENERIC_CRYPTO_INTERFACE_H_