Source release v3.0.0-0-g8d3792b-ce + third_party

Change-Id: I399e71ddfffcd436171d1c60283c63ab4658e0b1

core/include/max_res_engine.h

@@ -0,0 +1,105 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_MAX_RES_ENGINE_H_
+#define WVCDM_CORE_MAX_RES_ENGINE_H_
+
+#include <map>
+
+#include "crypto_session.h"
+#include "license_protocol.pb.h"
+#include "lock.h"
+#include "scoped_ptr.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class Clock;
+class MaxResEngineTest;
+
+// Similar to the Policy Engine, 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 MaxResEngine {
+ public:
+  explicit MaxResEngine(CryptoSession* crypto_session);
+  virtual ~MaxResEngine();
+
+  // The value returned is computed during the last call to SetLicense/
+  // SetResolution/OnTimerEvent and may be out of sync depending on the amount
+  // of time elapsed. The current decryption status is not calculated when this
+  // function is called to avoid overhead in the decryption path.
+  virtual bool CanDecrypt(const KeyId& key_id);
+
+  // SetLicense is used in handling the initial license response. It stores
+  // an exact copy of the key constraints from the license.
+  virtual void SetLicense(const video_widevine_server::sdk::License& license);
+
+  // SetResolution is called when the current output resolution is updated by
+  // the decoder. The max-res engine will recalculate the current resolution
+  // constraints, (if any) which may affect the results for CanDecrypt().
+  virtual void SetResolution(uint32_t width, uint32_t height);
+
+  // OnTimerEvent is called when a timer fires. The max-res engine may check the
+  // current HDCP level using the crypto session, which may affect the results
+  // for CanDecrypt().
+  virtual void OnTimerEvent();
+
+ private:
+  typedef ::video_widevine_server::sdk::License::KeyContainer KeyContainer;
+  typedef ::video_widevine_server::sdk::License::KeyContainer::OutputProtection
+      OutputProtection;
+  typedef ::video_widevine_server::sdk::License::KeyContainer::
+      VideoResolutionConstraint VideoResolutionConstraint;
+  typedef ::google::protobuf::RepeatedPtrField<VideoResolutionConstraint>
+      ConstraintList;
+
+  class KeyStatus {
+   public:
+    explicit KeyStatus(const ConstraintList& constraints);
+    KeyStatus(const ConstraintList& constraints,
+              const OutputProtection::HDCP& default_hdcp_level);
+
+    bool can_decrypt() const { return can_decrypt_; }
+
+    void Update(uint32_t res,
+                CryptoSession::HdcpCapability current_hdcp_level);
+
+   private:
+    void Init(const ConstraintList& constraints);
+
+    VideoResolutionConstraint* GetConstraintForRes(uint32_t res);
+
+    static CryptoSession::HdcpCapability ProtobufHdcpToOemCryptoHdcp(
+        const OutputProtection::HDCP& input);
+
+    bool can_decrypt_;
+
+    CryptoSession::HdcpCapability default_hdcp_level_;
+    ConstraintList constraints_;
+  };
+
+  typedef std::map<wvcdm::KeyId,
+                   wvcdm::MaxResEngine::KeyStatus*>::const_iterator KeyIterator;
+
+  void Init(CryptoSession* crypto_session, Clock* clock);
+
+  void DeleteAllKeys();
+
+  Lock status_lock_;
+  std::map<KeyId, KeyStatus*> keys_;
+  uint32_t current_resolution_;
+  int64_t next_check_time_;
+
+  scoped_ptr<Clock> clock_;
+  CryptoSession* crypto_session_;
+
+  // For testing
+  friend class MaxResEngineTest;
+  MaxResEngine(CryptoSession* crypto_session, Clock* clock);
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(MaxResEngine);
+};
+
+}  // wvcdm
+
+#endif  // WVCDM_CORE_MAX_RES_ENGINE_H_