Regular update

Plugin:
1. Process ECM v3 and send fingerprinting/service_blocking events
2. Rmove unused function Ctr128Add
3. Add support for ECM v3

OEMCrypto:
1. Update API description of OEMCrypto_LoadCasECMKeys
2. Fix android build files for ODK
3. Load content keys to shared memory
4. Move KCB check to LoadCasKeys call
5. Support even/odd content keys to share entitlement key

plugin/src/widevine_cas_session.cpp

@@ -3,10 +3,13 @@
 // License Agreement.
 #include "widevine_cas_session.h"
 
+#include <cas_events.h>
+
 #include <cstring>
 #include <memory>
 
 #include "log.h"
+#include "media_cas.pb.h"
 
 namespace wvcas {
 
@@ -25,7 +28,8 @@ WidevineCasSession::~WidevineCasSession() {
 }
 
 CasStatus WidevineCasSession::initialize(
-    std::shared_ptr<CryptoSession> crypto_session, uint32_t* session_id) {
+    std::shared_ptr<CryptoSession> crypto_session,
+    CasEventListener* event_listener, uint32_t* session_id) {
   if (crypto_session == nullptr || session_id == nullptr) {
     LOGE("WidevineCasSession::initialize: missing input parameters");
     return CasStatus(CasStatusCode::kInvalidParameter,
@@ -34,6 +38,7 @@ CasStatus WidevineCasSession::initialize(
   crypto_session_ = std::move(crypto_session);
   crypto_session_->CreateEntitledKeySession(&key_session_id_);
   *session_id = key_session_id_;
+  event_listener_ = event_listener;
   return CasStatusCode::kNoError;
 }
 
@@ -49,7 +54,7 @@ CasStatus WidevineCasSession::processEcm(const CasEcm& ecm,
   if (ecm != current_ecm_) {
     LOGD("WidevineCasSession::processEcm: received new ecm");
     std::unique_ptr<const EcmParser> ecm_parser = getEcmParser(ecm);
-    if (!ecm_parser) {
+    if (ecm_parser == nullptr) {
       return CasStatus(CasStatusCode::kInvalidParameter, "invalid ecm");
     }
 
@@ -61,6 +66,46 @@ CasStatus WidevineCasSession::processEcm(const CasEcm& ecm,
       return CasStatus(CasStatusCode::kAccessDeniedByParentalControl, message);
     }
 
+    std::vector<uint8_t> message;
+    if (!ecm_parser->fingerprinting().control().empty()) {
+      message.push_back(static_cast<uint8_t>(
+          SessionFingerprintingFieldType::FINGERPRINTING_CONTROL));
+      const std::string control = ecm_parser->fingerprinting().control();
+      message.push_back((control.size() >> 8) & 0xff);
+      message.push_back(control.size() & 0xff);
+      message.insert(message.end(), control.begin(), control.end());
+    }
+    if (message != last_fingerprinting_message_) {
+      last_fingerprinting_message_ = message;
+      if (event_listener_ == nullptr) {
+        LOGW("event_listener is null. Fingerprinting info ignored!");
+      } else {
+        event_listener_->OnSessionFingerprintingUpdated(key_session_id_,
+                                                        message);
+      }
+    }
+
+    message.clear();
+    for (int i = 0; i < ecm_parser->service_blocking().device_groups_size();
+         ++i) {
+      message.push_back(static_cast<uint8_t>(
+          SessionServiceBlockingFieldType::SERVICE_BLOCKING_DEVICE_GROUP));
+      const std::string device_group =
+          ecm_parser->service_blocking().device_groups(i);
+      message.push_back((device_group.size() >> 8) & 0xff);
+      message.push_back(device_group.size() & 0xff);
+      message.insert(message.end(), device_group.begin(), device_group.end());
+    }
+    if (message != last_service_blocking_message_) {
+      last_service_blocking_message_ = message;
+      if (event_listener_ == nullptr) {
+        LOGW("event_listener is null. Service blocking info ignored!");
+      } else {
+        event_listener_->OnSessionServiceBlockingUpdated(key_session_id_,
+                                                         message);
+      }
+    }
+
     bool load_even = false;
     bool load_odd = false;
 
@@ -118,11 +163,7 @@ CasStatus WidevineCasSession::processEcm(const CasEcm& ecm,
 
 std::unique_ptr<const EcmParser> WidevineCasSession::getEcmParser(
     const CasEcm& ecm) const {
-  std::unique_ptr<const EcmParser> new_ecm_parser;
-  if (!EcmParser::create(ecm, &new_ecm_parser)) {
-    return std::unique_ptr<const EcmParser>();
-  }
-  return new_ecm_parser;
+  return EcmParser::Create(ecm);
 }
 
 const char* WidevineCasSession::securityLevel() {