Fix media_cas_proxy_sdk build issue.

Add example binary for testing building the SDK after 'git clone' from our repo.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=227583629

common/drm_root_certificate.h

@@ -0,0 +1,106 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2013 Google LLC.
+//
+// This software is licensed under the terms defined in the Widevine Master
+// License Agreement. For a copy of this agreement, please contact
+// widevine-licensing@google.com.
+////////////////////////////////////////////////////////////////////////////////
+//
+// Description:
+//   Root device certificate holder class which deserializes, validates,
+//   and extracts the root certificate public key.
+
+#ifndef COMMON_DRM_ROOT_CERTIFICATE_H_
+#define COMMON_DRM_ROOT_CERTIFICATE_H_
+
+// common_typos_disable. Successful / successfull.
+
+#include <memory>
+#include <string>
+
+#include "base/macros.h"
+#include "common/status.h"
+
+#include "common/certificate_type.h"
+
+namespace widevine {
+
+class DrmCertificate;
+class RsaKeyFactory;
+class RsaPublicKey;
+class SignedDrmCertificate;
+class VerifiedCertSignatureCache;
+
+// Root certificate and certificate chain verifier with internal caching.
+// This object is thread-safe.
+class DrmRootCertificate {
+ public:
+  virtual ~DrmRootCertificate();
+
+  // Creates a DrmRootCertificate object given a certificate type.
+  // |cert| may not be nullptr, and it points to a
+  // std::unique_ptr<DrmRootCertificate> which will be used to return a newly
+  // created const DrmRootCertificate* if successful. The caller assumes
+  // ownership of the new DrmRootCertificate. This method returns
+  // Status::OK on success, or appropriate error status otherwise.
+  static Status CreateByType(CertificateType cert_type,
+                             std::unique_ptr<DrmRootCertificate>* cert);
+
+  // Variant on the method above to make CLIF happy until b/110539622 is fixed.
+  static std::unique_ptr<DrmRootCertificate> CreateByType(
+      CertificateType cert_type, Status* status);
+
+  // Creates a DrmRootCertificate object given a certificate type std::string, which
+  // must be one of "prod", "qa", or "test".
+  // |cert| may not be nullptr, and it points to a
+  // std::unique_ptr<DrmRootCertificate> which will be used to return a newly
+  // created const DrmRootCertificate* if successful. The caller assumes
+  // ownership of the new DrmRootCertificate. This method returns
+  // Status::OK on success, or appropriate error status otherwise.
+  static Status CreateByTypeString(const std::string& cert_type_string,
+                                   std::unique_ptr<DrmRootCertificate>* cert);
+
+  // |certificate| will contgain the DRM certificate upon successful return.
+  // May be null.
+  // Returns Status::OK if successful, or an appropriate error code otherwise.
+  virtual Status VerifyCertificate(const std::string& serialized_certificate,
+                                   SignedDrmCertificate* signed_certificate,
+                                   DrmCertificate* certificate) const;
+
+  // Returns the hex-encoded SHA-256 digest for this certificate.
+  virtual std::string GetDigest() const;
+
+  const CertificateType type() const { return type_; }
+
+  const std::string& public_key() const { return public_key_; }
+
+ protected:
+  DrmRootCertificate(CertificateType cert_type,
+                     const std::string& serialized_certificate,
+                     const std::string& serial_number, const std::string& public_key,
+                     std::unique_ptr<RsaKeyFactory> key_factory);
+
+ private:
+  friend class DrmRootCertificateTest;
+
+  static Status Create(CertificateType cert_type,
+                       std::unique_ptr<RsaKeyFactory> key_factory,
+                       std::unique_ptr<DrmRootCertificate>* cert);
+
+  Status VerifySignatures(const SignedDrmCertificate& signed_cert,
+                          const std::string& cert_serial_number,
+                          bool use_cache) const;
+
+  CertificateType type_;
+  std::string serialized_certificate_;
+  std::string serial_number_;
+  std::string public_key_;
+  std::unique_ptr<RsaKeyFactory> key_factory_;
+  mutable std::unique_ptr<VerifiedCertSignatureCache> signature_cache_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(DrmRootCertificate);
+};
+
+}  // namespace widevine
+
+#endif  // COMMON_DRM_ROOT_CERTIFICATE_H_

common/status.h

@@ -0,0 +1,108 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Google LLC.
+//
+// This software is licensed under the terms defined in the Widevine Master
+// License Agreement. For a copy of this agreement, please contact
+// widevine-licensing@google.com.
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef COMMON_STATUS_H_
+#define COMMON_STATUS_H_
+
+#include <string>
+
+#include "util/error_space.h"
+
+namespace widevine {
+namespace error {
+
+enum StatusCode {
+  // Success.
+  OK = 0,
+
+  // Client specified an invalid argument.
+  INVALID_ARGUMENT = 3,
+
+  // Some requested entity (e.g., file or directory) was not found.
+  NOT_FOUND = 5,
+
+  // Some entity that we attempted to create (e.g., file or directory)
+  // already exists.
+  ALREADY_EXISTS = 6,
+
+  // The caller does not have permission to execute the specified
+  // operation.  PERMISSION_DENIED must not be used for rejections
+  // caused by exhausting some resource (use RESOURCE_EXHAUSTED
+  // instead for those errors).
+  PERMISSION_DENIED = 7,
+
+  // Operation is not implemented or not supported/enabled in this service.
+  UNIMPLEMENTED = 12,
+
+  // Internal errors.  Means some invariants expected by underlying
+  // system has been broken.  If you see one of these errors,
+  // something is very broken.
+  INTERNAL = 13,
+
+  // Operation is not implemented or not supported/enabled in this service.
+  UNAVAILABLE = 14,
+
+  // Number of generic (non license related) errors.
+  NUM_ERRORS,
+};
+
+}  // namespace error
+
+class Status {
+ public:
+
+  Status() = default;
+
+  ~Status() = default;
+
+  explicit Status(error::StatusCode c) : status_code_(c) {}
+
+  Status(error::StatusCode c, const std::string& error_message)
+      : status_code_(c), error_message_(error_message) {}
+
+  Status(const util::ErrorSpace* e, error::StatusCode c,
+         const std::string& error_message)
+      : error_space_(e), status_code_(c), error_message_(error_message) {}
+
+  Status(const util::ErrorSpace* e, int error, const std::string& error_message)
+      : error_space_(e), status_code_(error), error_message_(error_message) {}
+
+  bool ok() const { return status_code_ == error::OK; }
+  const util::ErrorSpace* error_space() const { return error_space_; }
+  static const util::ErrorSpace* canonical_space();
+  std::string ToString() const;
+  std::string error_message() const { return error_message_; }
+  int error_code() const { return status_code_; }
+
+ private:
+  const util::ErrorSpace* error_space_ = canonical_space();
+  int status_code_ = error::OK;
+  std::string error_message_;
+};
+
+inline Status OkStatus() { return Status(); }
+
+inline bool operator==(const Status& s1, const Status& s2) {
+  return s1.error_space() == s2.error_space() &&
+         s1.error_code() == s2.error_code() &&
+         s1.error_message() == s2.error_message();
+}
+inline bool operator!=(const Status& s1, const Status& s2) {
+  return !(s1 == s2);
+}
+
+
+// Prints a human-readable representation of 'x' to 'os'.
+std::ostream& operator<<(std::ostream& os, const Status& x);
+
+#define CHECK_OK(expression) CHECK(expression.ok()) << expression.ToString()
+
+
+}  // namespace widevine
+
+#endif  // COMMON_STATUS_H_