Initial import of Widevine Common Encryption DRM engine

Builds libwvmdrmengine.so, which is loaded by the new
MediaDrm APIs to support playback of Widevine/CENC
protected content.

Change-Id: I6f57dd37083dfd96c402cb9dd137c7d74edc8f1c

libwvdrmengine/cdm/core/include/buffer_reader.h

@@ -0,0 +1,68 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef CDM_BASE_BUFFER_READER_H_
+#define CDM_BASE_BUFFER_READER_H_
+
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// Annotate a function indicating the caller must examine the return value.
+// Use like:
+//   int foo() WARN_UNUSED_RESULT;
+// To explicitly ignore a result, see |ignore_result()| in <base/basictypes.h>.
+#if defined(COMPILER_GCC)
+#define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+#else
+#define WARN_UNUSED_RESULT
+#endif
+
+class BufferReader {
+ public:
+  BufferReader(const uint8_t* buf, size_t size)
+    : buf_(buf), size_(size), pos_(0) {}
+
+  bool HasBytes(int count) { return (pos() + count <= size()); }
+
+  // Read a value from the stream, performing endian correction,
+  // and advance the stream pointer.
+  bool Read1(uint8_t* v)  WARN_UNUSED_RESULT;
+  bool Read2(uint16_t* v) WARN_UNUSED_RESULT;
+  bool Read2s(int16_t* v) WARN_UNUSED_RESULT;
+  bool Read4(uint32_t* v) WARN_UNUSED_RESULT;
+  bool Read4s(int32_t* v) WARN_UNUSED_RESULT;
+  bool Read8(uint64_t* v) WARN_UNUSED_RESULT;
+  bool Read8s(int64_t* v) WARN_UNUSED_RESULT;
+
+  bool ReadString(std::string* str, int count) WARN_UNUSED_RESULT;
+  bool ReadVec(std::vector<uint8_t>* t, int count) WARN_UNUSED_RESULT;
+
+  // These variants read a 4-byte integer of the corresponding signedness and
+  // store it in the 8-byte return type.
+  bool Read4Into8(uint64_t* v) WARN_UNUSED_RESULT;
+  bool Read4sInto8s(int64_t* v) WARN_UNUSED_RESULT;
+
+  // Advance the stream by this many bytes.
+  bool SkipBytes(int nbytes) WARN_UNUSED_RESULT;
+
+  const uint8_t* data() const { return buf_; }
+  size_t size() const { return size_; }
+  size_t pos() const { return pos_; }
+
+ protected:
+  const uint8_t* buf_;
+  size_t size_;
+  size_t pos_;
+
+  template<typename T> bool Read(T* t) WARN_UNUSED_RESULT;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(BufferReader);
+};
+
+}  // namespace wvcdm
+
+#endif  // CDM_BASE_BUFFER_READER_H_

libwvdrmengine/cdm/core/include/cdm_engine.h

@@ -0,0 +1,123 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef CDM_BASE_CDM_ENGINE_H_
+#define CDM_BASE_CDM_ENGINE_H_
+
+#include "timer.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class CdmSession;
+class WvCdmEventListener;
+
+typedef std::map<CdmSessionId, CdmSession*> CdmSessionMap;
+
+class CdmEngine : public TimerHandler {
+ public:
+  CdmEngine() {}
+  ~CdmEngine();
+
+  // Session related methods
+  CdmResponseType OpenSession(const CdmKeySystem& key_system,
+                              CdmSessionId* session_id);
+  CdmResponseType CloseSession(CdmSessionId& session_id);
+
+  // License related methods
+  // Construct a valid license request
+  CdmResponseType GenerateKeyRequest(const CdmSessionId& session_id,
+                                     bool is_key_system_present,
+                                     const CdmKeySystem& key_system,
+                                     const CdmInitData& init_data,
+                                     const CdmLicenseType license_type,
+                                     CdmNameValueMap& app_parameters,
+                                     CdmKeyMessage* key_request);
+
+  // Accept license response and extract key info.
+  CdmResponseType AddKey(const CdmSessionId& session_id,
+                         bool is_key_system_init_data_present,
+                         const CdmKeySystem& key_system,
+                         const CdmInitData& init_data,
+                         const CdmKeyResponse& key_data);
+
+  // Cancel session and unload keys.
+  CdmResponseType CancelKeyRequest(const CdmSessionId& session_id,
+                                   bool is_key_system_present,
+                                   const CdmKeySystem& key_system);
+
+  // Construct valid renewal request for the current session keys.
+  CdmResponseType GenerateRenewalRequest(const CdmSessionId& session_id,
+                                         bool is_key_system_init_data_present,
+                                         const CdmKeySystem& key_system,
+                                         const CdmInitData& init_data,
+                                         CdmKeyMessage* key_request);
+
+  // Accept renewal response and update key info.
+  CdmResponseType RenewKey(const CdmSessionId& session_id,
+                           bool is_key_system_init_data_present,
+                           const CdmKeySystem& key_system,
+                           const CdmInitData& init_data,
+                           const CdmKeyResponse& key_data);
+
+  // Query license information
+  CdmResponseType QueryKeyStatus(const CdmSessionId& session_id,
+                                 CdmNameValueMap* key_info);
+
+
+  // Provisioning related methods
+  CdmResponseType GetProvisioningRequest(CdmProvisioningRequest* request,
+                                         std::string* default_url);
+
+  CdmResponseType HandleProvisioningResponse(CdmProvisioningResponse& response);
+
+  // Secure stop related methods
+  CdmResponseType GetSecureStops(CdmSecureStops* secure_stops);
+  CdmResponseType ReleaseSecureStops(const CdmSecureStopReleaseMessage& message);
+
+  // Decryption and key related methods
+  // Accept encrypted buffer and return decrypted data.
+  CdmResponseType Decrypt(const CdmSessionId& session_id,
+                          bool is_encrypted,
+                          const KeyId& key_id,
+                          const uint8_t* encrypted_buffer,
+                          size_t encrypted_size,
+                          const std::vector<uint8_t>& iv,
+                          size_t block_offset,
+                          void* decrypted_buffer);
+
+  // Is the key known to any session?
+  bool IsKeyValid(const KeyId& key_id);
+
+  // Event listener related methods
+  bool AttachEventListener(CdmSessionId& session_id,
+                           WvCdmEventListener* listener);
+  bool DetachEventListener(CdmSessionId& session_id,
+                           WvCdmEventListener* listener);
+ private:
+  // private methods
+  bool ValidateKeySystem(const CdmKeySystem& key_system);
+  // Cancel all sessions
+  bool CancelSessions();
+  // Parse a blob of multiple concatenated PSSH atoms to extract the first
+  // widevine pssh
+  // TODO(gmorgan): This should be done by the user of this class.
+  bool ExtractWidevinePssh(const CdmInitData& init_data,
+                           CdmInitData* output);
+
+  // timer related methods to drive policy decisions
+  void EnablePolicyTimer();
+  void DisablePolicyTimer();
+  virtual void OnTimerEvent();
+
+  // instance variables
+  CdmSessionMap sessions_;
+
+  // policy timer
+  Timer policy_timer_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CdmEngine);
+};
+
+}  // namespace wvcdm
+
+#endif  // CDM_BASE_CDM_ENGINE_H_

libwvdrmengine/cdm/core/include/cdm_session.h

@@ -0,0 +1,100 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef CDM_BASE_CDM_SESSION_H_
+#define CDM_BASE_CDM_SESSION_H_
+
+#include <set>
+
+#include "crypto_session.h"
+#include "license.h"
+#include "policy_engine.h"
+#include "wv_cdm_event_listener.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// TODO(kqyang): Do we need it? CdmKey not defined yet
+// typedef std::map<KeyId, CdmKey*> CdmSessionKeys;
+
+class CdmSession {
+ public:
+  CdmSession() : state_(INITIAL), session_id_(GenerateSessionId()) {}
+  ~CdmSession() {}
+
+  bool Init();
+
+  bool DestroySession();
+
+  void set_key_system(const CdmKeySystem& ksystem) { key_system_ = ksystem; }
+  const CdmKeySystem& key_system() { return key_system_; }
+
+  const CdmSessionId& session_id() { return session_id_; }
+
+  bool VerifySession(const CdmKeySystem& key_system,
+                     const CdmInitData& init_data);
+
+  CdmResponseType GenerateKeyRequest(const CdmInitData& init_data,
+                                     CdmKeyMessage* key_request);
+
+  // AddKey() - Accept license response and extract key info.
+  CdmResponseType AddKey(const CdmKeyResponse& key_response);
+
+  // CancelKeyRequest() - Cancel session.
+  CdmResponseType CancelKeyRequest();
+
+  // Decrypt() - Accept encrypted buffer and return decrypted data.
+  CdmResponseType Decrypt(const uint8_t* encrypted_buffer,
+                          size_t encrypted_size,
+                          size_t block_offset,
+                          const std::string& iv,
+                          const KeyId& key_id,
+                          uint8_t* decrypted_buffer);
+
+  // License renewal
+  // GenerateRenewalRequest() - Construct valid renewal request for the current
+  // session keys.
+  CdmResponseType GenerateRenewalRequest(CdmKeyMessage* key_request);
+
+  // RenewKey() - Accept renewal response and update key info.
+  CdmResponseType RenewKey(const CdmKeyResponse& key_response);
+
+  bool IsKeyValid(const KeyId& key_id);
+
+  bool AttachEventListener(WvCdmEventListener* listener);
+  bool DetachEventListener(WvCdmEventListener* listener);
+
+  void OnTimerEvent();
+
+ private:
+
+  // Generate unique ID for each new session.
+  CdmSessionId GenerateSessionId();
+
+  typedef enum {
+    INITIAL,
+    LICENSE_REQUESTED,
+    LICENSE_RESPONSE_DONE,
+    RENEWAL_ENABLED,
+    RENEWAL_REQUESTED,
+    LICENSE_EXPIRED
+  } CdmSessionState;
+
+  // instance variables
+  CdmSessionState state_;
+  const CdmSessionId session_id_;
+  CdmKeySystem key_system_;
+  CdmLicense license_parser_;
+  CryptoSession* crypto_session_;
+  PolicyEngine policy_engine_;
+
+  std::set<WvCdmEventListener*> listeners_;
+
+  // TODO(kqyang): CdmKey not defined yet
+  // CdmSessionKeys session_keys_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CdmSession);
+};
+
+}  // namespace wvcdm
+
+#endif  // CDM_BASE_CDM_SESSION_H_

libwvdrmengine/cdm/core/include/clock.h

@@ -0,0 +1,19 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Clock - Platform independent interface for a time library
+//
+#ifndef CDM_BASE_CLOCK_H_
+#define CDM_BASE_CLOCK_H_
+
+#include <stdint.h>
+
+namespace wvcdm {
+
+// Provides time related information. The implementation is platform dependent.
+
+// Provides the number of seconds since an epoch (00:00 hours, Jan 1, 1970 UTC)
+int64_t GetCurrentTime();
+
+};  // namespace wvcdm
+
+#endif  // CDM_BASE_CLOCK_H_

libwvdrmengine/cdm/core/include/crypto_engine.h

@@ -0,0 +1,61 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+//
+// OEMCrypto Client - wrapper class for C-style OEMCrypto interface
+//
+#ifndef CDM_BASE_CRYPTO_ENGINE_H_
+#define CDM_BASE_CRYPTO_ENGINE_H_
+
+#include "crypto_session.h"
+#include "lock.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+typedef std::map<CdmSessionId,CryptoSession*> CryptoSessionMap;
+
+class CryptoEngine {
+
+  friend class CryptoSession;
+
+ private:
+
+  CryptoEngine();
+  ~CryptoEngine();
+
+ public:
+
+  // get an instance of Crypto engine
+  static CryptoEngine* GetInstance();
+
+  bool Init();
+  bool Terminate();
+  bool ValidateKeybox();
+
+  CryptoSession* CreateSession(const CdmSessionId& session_id);
+  CryptoSession* FindSession(const CdmSessionId& session_id);
+  bool DestroySession(const CdmSessionId& session_id);
+  bool DestroySessions();
+
+  bool GetToken(std::string* token);
+
+private:
+
+  void DeleteInstance();
+  static CryptoEngine* CreateSingleton();
+
+  CryptoSession* FindSessionInternal(const CdmSessionId& session_id);
+
+  static CryptoEngine* crypto_engine_;
+  static Lock crypto_engine_lock_;
+
+  bool initialized_;
+  mutable Lock crypto_lock_;
+  mutable Lock sessions_lock_;
+  CryptoSessionMap sessions_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CryptoEngine);
+};
+
+}; // namespace wvcdm
+
+#endif  // CDM_BASE_CRYPTO_ENGINE_H_

libwvdrmengine/cdm/core/include/crypto_key.h

@@ -0,0 +1,44 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+//
+// OEMCrypto Client - wrapper class for C-style OEMCrypto interface
+//
+#ifndef CDM_BASE_CRYPTO_KEY_H_
+#define CDM_BASE_CRYPTO_KEY_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class CryptoKey {
+public:
+  CryptoKey() {};
+  ~CryptoKey() {};
+
+  const std::string& key_id() const { return key_id_; }
+  const std::string& key_data() const { return key_data_; }
+  const std::string& key_data_iv() const { return key_data_iv_; }
+  const std::string& key_control() const { return key_control_; }
+  const std::string& key_control_iv() const { return key_control_iv_; }
+  void set_key_id(const std::string& key_id) { key_id_ = key_id; }
+  void set_key_data(const std::string& key_data) { key_data_ = key_data; }
+  void set_key_data_iv(const std::string& iv) { key_data_iv_ = iv; }
+  void set_key_control(const std::string& ctl) { key_control_ = ctl; }
+  void set_key_control_iv(const std::string& ctl_iv) {
+    key_control_iv_ = ctl_iv;
+  }
+
+  bool HasKeyControl() const { return key_control_.size() >= 16; }
+
+private:
+  std::string key_id_;
+  std::string key_data_iv_;
+  std::string key_data_;
+  std::string key_control_;
+  std::string key_control_iv_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CryptoKey);
+};
+
+}; // namespace wvcdm
+
+#endif  // CDM_BASE_CRYPTO_KEY_H_

libwvdrmengine/cdm/core/include/crypto_session.h

@@ -0,0 +1,81 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+//
+// OEMCrypto Client - wrapper class for C-style OEMCrypto interface
+//
+#ifndef CDM_BASE_CRYPTO_SESSSION_H_
+#define CDM_BASE_CRYPTO_SESSSION_H_
+
+#include <string>
+#include <map>
+
+#include "crypto_key.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+typedef std::map<CryptoKeyId,CryptoKey*> CryptoKeyMap;
+
+// TODO(gmorgan): fill out input and output descriptors
+typedef void* InputDescriptor;
+typedef void* OutputDescriptor;
+
+class CryptoSession {
+ public:
+  CryptoSession();
+  explicit CryptoSession(const std::string& sname);
+  ~CryptoSession();
+
+  bool Open();
+  void Close();
+
+  bool IsValid() { return valid_; }
+  bool IsOpen() { return open_; }
+  bool SuccessStatus();
+  CryptoResult session_status() { return session_status_; }
+  CryptoSessionId oec_session_id() { return oec_session_id_; }
+  CdmSessionId cdm_session_id() { return cdm_session_id_; }
+
+  // Key request/response
+  void GenerateRequestId(std::string& req_id_str);
+  bool PrepareRequest(const std::string& key_deriv_message,
+                      std::string* signature);
+  bool PrepareRenewalRequest(const std::string& message,
+                             std::string* signature);
+  bool LoadKeys(const std::string& message,
+                const std::string& signature,
+                const std::string& mac_key_iv,
+                const std::string& mac_key,
+                int num_keys,
+                const CryptoKey* key_array);
+  bool RefreshKeys(const std::string& message,
+                   const std::string& signature,
+                   int num_keys,
+                   const CryptoKey* key_array);
+  bool GenerateNonce(uint32_t* nonce);
+
+  // Media data path
+  bool SelectKey(const std::string& key_id);
+  bool Decrypt(const InputDescriptor input, OutputDescriptor output);
+
+ private:
+
+  void GenerateMacContext(const std::string& input_context,
+                          std::string* deriv_context);
+  void GenerateEncryptContext(const std::string& input_context,
+                              std::string* deriv_context);
+  size_t GetOffset(std::string message, std::string field);
+
+  bool valid_;
+  bool open_;
+  CdmSessionId cdm_session_id_;
+  CryptoSessionId oec_session_id_;
+  CryptoResult session_status_;
+
+  CryptoKeyMap keys_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CryptoSession);
+};
+
+}; // namespace wvcdm
+
+#endif  // CDM_BASE_CRYPTO_SESSSION_H_

libwvdrmengine/cdm/core/include/license.h

@@ -0,0 +1,41 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef CDM_BASE_LICENSE_H_
+#define CDM_BASE_LICENSE_H_
+
+#include "license_protocol.pb.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+using video_widevine_server::sdk::LicenseIdentification;
+
+class CryptoSession;
+
+class CdmLicense {
+
+ public:
+
+  CdmLicense();
+  ~CdmLicense();
+
+  bool Init(const std::string& token, CryptoSession* session);
+
+  bool PrepareKeyRequest(const CdmInitData& init_data,
+                         CdmKeyMessage* signed_request);
+  bool PrepareKeyRenewalRequest(CdmKeyMessage* signed_request);
+  bool HandleKeyResponse(const CdmKeyResponse& license_response);
+  bool HandleKeyRenewalResponse(const CdmKeyResponse& license_response);
+
+private:
+
+  LicenseIdentification license_id_;
+  CryptoSession* session_;
+  std::string token_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CdmLicense);
+};
+
+}  // namespace wvcdm
+
+#endif  // CDM_BASE_LICENSE_H_

libwvdrmengine/cdm/core/include/lock.h

@@ -0,0 +1,54 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Lock - Platform independent interface for a Mutex class
+//
+#ifndef CDM_BASE_LOCK_H_
+#define CDM_BASE_LOCK_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// Simple lock class. The implementation is platform dependent.
+//
+// The lock must be unlocked by the thread that locked it.
+// The lock is also not recursive (ie. cannot be taken multiple times).
+class Lock {
+ public:
+  Lock();
+  ~Lock();
+
+  void Acquire();
+  void Release();
+
+  // Acquires a lock if not held and returns true.
+  // Returns false if the lock is held by another thread.
+  bool Try();
+
+  friend class AutoLock;
+
+ private:
+  class Impl;
+  Impl *impl_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(Lock);
+};
+
+// Manages the lock automatically. It will be locked when AutoLock
+// is constructed and release when AutoLock goes out of scope
+class AutoLock {
+ public:
+  explicit AutoLock(Lock& lock);
+  explicit AutoLock(Lock* lock);
+  ~AutoLock();
+
+ private:
+  class Impl;
+  Impl *impl_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(AutoLock);
+};
+
+};  // namespace wvcdm
+
+#endif  // CDM_BASE_LOCK_H_

libwvdrmengine/cdm/core/include/log.h

@@ -0,0 +1,31 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Log - Platform independent interface for a Logging class
+//
+#ifndef CDM_BASE_LOG_H_
+#define CDM_BASE_LOG_H_
+
+namespace wvcdm {
+
+// Simple logging class. The implementation is platform dependent.
+
+typedef enum {
+  LOG_ERROR,
+  LOG_WARN,
+  LOG_INFO,
+  LOG_DEBUG,
+  LOG_VERBOSE
+} LogPriority;
+
+void log_write(LogPriority priority, const char *fmt, ...);
+
+// Log APIs
+#define LOGE(...) ((void)log_write(wvcdm::LOG_ERROR, __VA_ARGS__))
+#define LOGW(...) ((void)log_write(wvcdm::LOG_WARN, __VA_ARGS__))
+#define LOGI(...) ((void)log_write(wvcdm::LOG_INFO, __VA_ARGS__))
+#define LOGD(...) ((void)log_write(wvcdm::LOG_DEBUG, __VA_ARGS__))
+#define LOGV(...) ((void)log_write(wvcdm::LOG_VERBOSE, __VA_ARGS__))
+
+};  // namespace wvcdm
+
+#endif  // CDM_BASE_LOG_H_

libwvdrmengine/cdm/core/include/policy_engine.h

@@ -0,0 +1,83 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef CDM_BASE_POLICY_ENGINE_H_
+#define CDM_BASE_POLICY_ENGINE_H_
+
+#include <string>
+
+#include "license_protocol.pb.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// This acts as an oracle that basically says "Yes(true) you may still decrypt
+// or no(false) you may not decrypt this data anymore."
+class PolicyEngine {
+ public:
+  PolicyEngine();
+  ~PolicyEngine();
+
+  // |current_time| is used to check if license has to be renewed or expired.
+  void OnTimerEvent(int64_t current_time, bool event_occurred, CdmEventType& event);
+
+  // SetLicense is used in handling the initial license response. It stores
+  // an exact copy of the policy information stored in the license.
+  // The license state transitions to kLicenseStateCanPlay if the license
+  // permits playback.
+  void SetLicense(const video_widevine_server::sdk::License& license);
+
+  // UpdateLicense is used in handling a license response for a renewal request.
+  // The response may only contain any policy fields that have changed. In this
+  // case an exact copy is not what we want to happen. We also will receive an
+  // updated license_start_time from the server. The license will transition to
+  // kLicenseStateCanPlay if the license permits playback.
+  void UpdateLicense(const video_widevine_server::sdk::License& license);
+
+  const video_widevine_server::sdk::LicenseIdentification& license_id() {
+    return license_id_;
+  }
+
+ private:
+  typedef enum {
+    kLicenseStateInitial,
+    kLicenseStateCanPlay,
+    kLicenseStateCannotPlay,
+    kLicenseStateNeedRenewal,
+    kLicenseStateWaitingLicenseUpdate,
+    kLicenseStateExpired
+  } LicenseState;
+
+  bool IsLicenseDurationExpired(int64_t current_time);
+  bool IsRenewalDelayExpired(int64_t current_time);
+  bool IsRenewalRecoveryDurationExpired(int64_t current_time);
+  bool IsRenewalRetryIntervalExpired(int64_t current_time);
+
+  void UpdateRenewalRequest(int64_t current_time);
+
+  LicenseState license_state_;
+
+  // This is the current policy information for this license. This gets updated
+  // as license renewals occur.
+  video_widevine_server::sdk::License::Policy policy_;
+
+  // This is the license id field from server response. This data gets passed
+  // back to the server in each renewal request. When we get a renewal response
+  // from the license server we will get an updated id field.
+  video_widevine_server::sdk::LicenseIdentification license_id_;
+
+  // This is the license start time that gets sent from the server in each
+  // license request or renewal.
+  int64_t license_start_time_;
+
+  // This is used as a reference point for policy management. This value
+  // represents an offset from license_start_time_. This is used to calculate
+  // the time where renewal retries should occur.
+  int64_t next_renewal_time_;
+  int64_t policy_max_duration_seconds_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(PolicyEngine);
+};
+}  // wvcdm
+
+#endif  // CDM_BASE_POLICY_ENGINE_H_
+

libwvdrmengine/cdm/core/include/string_conversions.h

@@ -0,0 +1,25 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef CDM_BASE_STRING_CONVERSIONS_H_
+#define CDM_BASE_STRING_CONVERSIONS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace wvcdm {
+
+std::vector<uint8_t> a2b_hex(const std::string& b);
+std::string a2bs_hex(const std::string& b);
+std::string b2a_hex(const std::vector<uint8_t>& b);
+std::string b2a_hex(const std::string& b);
+std::string Base64SafeEncode(const std::vector<uint8_t>& bin_input);
+std::vector<uint8_t> Base64SafeDecode(const std::string& bin_input);
+std::string HexEncode(const uint8_t* bytes, unsigned size);
+std::string IntToString(int value);
+std::string UintToString(unsigned int value);
+
+};  // namespace wvcdm
+
+#endif  // CDM_BASE_STRING_CONVERSIONS_H_

libwvdrmengine/cdm/core/include/timer.h

@@ -0,0 +1,50 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Timer - Platform independent interface for a Timer class
+//
+#ifndef CDM_BASE_TIMER_H_
+#define CDM_BASE_TIMER_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// Timer Handler class.
+//
+// Derive from this class if you wish to receive events when the timer
+// expires. Provide the handler when setting up a new Timer.
+
+class TimerHandler {
+ public:
+  TimerHandler() {};
+  virtual ~TimerHandler() {};
+
+  virtual void OnTimerEvent() = 0;
+};
+
+// Timer class. The implementation is platform dependent.
+//
+// This class provides a simple recurring timer API. The class receiving
+// timer expiry events should derive from TimerHandler.
+// Specify the receiver class and the periodicty of timer events when
+// the timer is initiated by calling Start.
+
+class Timer {
+ public:
+  Timer();
+  ~Timer();
+
+  void Start(TimerHandler *handler, uint32_t time_in_secs);
+  void Stop();
+  bool IsRunning();
+
+ private:
+  class Impl;
+  Impl *impl_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(Timer);
+};
+
+};  // namespace wvcdm
+
+#endif  // CDM_BASE_TIMER_H_

libwvdrmengine/cdm/core/include/wv_cdm_constants.h

@@ -0,0 +1,18 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef CDM_BASE_WV_CDM_CONSTANTS_H_
+#define CDM_BASE_WV_CDM_CONSTANTS_H_
+
+namespace wvcdm {
+static const size_t KEY_CONTROL_SIZE = 16;
+// TODO(kqyang): Key ID size is not fixed in spec, but conventionally we
+// always use 16 bytes key id. We'll need to update oemcrypto to support
+// variable size key id.
+static const size_t KEY_ID_SIZE = 16;
+static const size_t KEY_IV_SIZE = 16;
+static const size_t KEY_PAD_SIZE = 16;
+static const size_t KEY_SIZE = 16;
+static const size_t MAC_KEY_SIZE = 32;
+}  // namespace wvcdm
+
+#endif  // CDM_BASE_WV_CDM_CONSTANTS_H_

libwvdrmengine/cdm/core/include/wv_cdm_event_listener.h

@@ -0,0 +1,28 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef CDM_BASE_WV_CDM_EVENT_LISTENER_H_
+#define CDM_BASE_WV_CDM_EVENT_LISTENER_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// Listener for events from the Content Decryption Module.
+// The caller of the CDM API must provide an implementation for onEvent
+// and signal its intent by using the Attach/DetachEventListener methods
+// in the WvContentDecryptionModule class.
+class WvCdmEventListener {
+ public:
+  WvCdmEventListener() {}
+  virtual ~WvCdmEventListener() {}
+
+  virtual void onEvent(const CdmSessionId& session_id,
+                       CdmEventType cdm_event) = 0;
+
+ private:
+  CORE_DISALLOW_COPY_AND_ASSIGN(WvCdmEventListener);
+};
+
+}  // namespace wvcdm
+
+#endif  // CDM_BASE_WV_CDM_EVENT_LISTENER_H_

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -0,0 +1,60 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef CDM_BASE_WV_CDM_TYPES_H_
+#define CDM_BASE_WV_CDM_TYPES_H_
+
+#include <map>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace wvcdm {
+
+typedef std::string CdmKeySystem;
+typedef std::string CdmInitData;
+typedef std::string CdmKeyMessage;
+typedef std::string CdmKeyResponse;
+typedef std::string KeyId;
+typedef std::string CdmSessionId;
+typedef std::string RequestId;
+typedef uint32_t CryptoResult;
+typedef uint32_t CryptoSessionId;
+typedef std::string CryptoKeyId;
+typedef std::map<std::string, std::string> CdmNameValueMap;
+typedef std::vector<std::string> CdmSecureStops;
+typedef std::vector<uint8_t> CdmSecureStopReleaseMessage;
+typedef std::string CdmProvisioningRequest;
+typedef std::string CdmProvisioningResponse;
+
+enum CdmResponseType {
+  NO_ERROR,
+  UNKNOWN_ERROR,
+  KEY_ADDED,
+  KEY_ERROR,
+  KEY_MESSAGE,
+  NEED_KEY,
+  KEY_CANCELED,
+};
+
+#define CORE_DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);               \
+  void operator=(const TypeName&)
+
+enum CdmEventType {
+  LICENSE_EXPIRED_EVENT,
+  LICENSE_RENEWAL_NEEDED_EVENT
+};
+
+enum CdmLicenseType {
+  kLicenseTypeOffline,
+  kLicenseTypeStreaming
+};
+
+// forward class references
+class KeyMessage;
+class Request;
+class Key;
+
+}  // namespace wvcdm
+
+#endif  // CDM_BASE_WV_CDM_TYPES_H_