Plumb PPAPI PlatformVerification into CDM.h

media/cdm/ppapi/cdm_wrapper.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <cstring>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
+#include "build/build_config.h"
 #include "media/cdm/ppapi/api/content_decryption_module.h"
 #include "media/cdm/ppapi/linked_ptr.h"
+#include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/c/private/pp_content_decryptor.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/core.h"
 #include "ppapi/cpp/dev/buffer_dev.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/pass_ref.h"
 #include "ppapi/cpp/private/content_decryptor_private.h"
 #include "ppapi/cpp/resource.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/utility/completion_callback_factory.h"
 
 #if defined(CHECK_DOCUMENT_URL)
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/instance_handle.h"
 #endif  // defined(CHECK_DOCUMENT_URL)
 
+#if defined(OS_CHROMEOS)
+#include "ppapi/cpp/private/output_protection_private.h"
+#include "ppapi/cpp/private/platform_verification.h"
+#endif
+
 namespace {
 
 bool IsMainThread() {
   return pp::Module::Get()->core()->IsMainThread();
 }
 
 // Posts a task to run |cb| on the main thread. The task is posted even if the
 // current thread is the main thread.
 void PostOnMain(pp::CompletionCallback cb) {
   pp::Module::Get()->core()->CallOnMainThread(0, cb, PP_OK);
@@ skipping 403 matching lines @@
     plane_offsets_[i] = 0;
     strides_[i] = 0;
   }
 }
 
 VideoFrameImpl::~VideoFrameImpl() {
   if (frame_buffer_)
     frame_buffer_->Destroy();
 }
 
-class AudioFramesImpl : public cdm::AudioFrames {
+class AudioFramesImpl : public cdm::AudioFrames_1,
+                        public cdm::AudioFrames_2 {
  public:
-  AudioFramesImpl() : buffer_(NULL) {}
+  AudioFramesImpl() : buffer_(NULL), format_(cdm::kAudioFormatS16) {}
   virtual ~AudioFramesImpl() {
     if (buffer_)
       buffer_->Destroy();
   }
 
   // AudioFrames implementation.
   virtual void SetFrameBuffer(cdm::Buffer* buffer) OVERRIDE {
     buffer_ = static_cast<PpbBuffer*>(buffer);
   }
   virtual cdm::Buffer* FrameBuffer() OVERRIDE {
     return buffer_;
   }
+  virtual void SetFormat(cdm::AudioFormat format) OVERRIDE {
+    format_ = format;
+  }
+  virtual cdm::AudioFormat Format() const OVERRIDE {
+    return format_;
+  }
 
  private:
   PpbBuffer* buffer_;
+  cdm::AudioFormat format_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioFramesImpl);
 };
 
 // GetCdmHostFunc implementation.
 void* GetCdmHost(int host_interface_version, void* user_data);
 
 // A wrapper class for abstracting away PPAPI interaction and threading for a
 // Content Decryption Module (CDM).
 class CdmWrapper : public pp::Instance,
                    public pp::ContentDecryptor_Private,
-                   public cdm::Host {
+                   public cdm::Host_1,
+                   public cdm::Host_2 {
  public:
   CdmWrapper(PP_Instance instance, pp::Module* module);
   virtual ~CdmWrapper();
 
   // pp::Instance implementation.
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     return true;
   }
 
   // PPP_ContentDecryptor_Private implementation.
@@ skipping 18 matching lines @@
       pp::Buffer_Dev extra_data_buffer) OVERRIDE;
   virtual void DeinitializeDecoder(PP_DecryptorStreamType decoder_type,
                                    uint32_t request_id) OVERRIDE;
   virtual void ResetDecoder(PP_DecryptorStreamType decoder_type,
                             uint32_t request_id) OVERRIDE;
   virtual void DecryptAndDecode(
       PP_DecryptorStreamType decoder_type,
       pp::Buffer_Dev encrypted_buffer,
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
 
-  // cdm::Host implementation.
+  // cdm::Host_1 implementation.
   virtual cdm::Buffer* Allocate(int32_t capacity) OVERRIDE;
   virtual void SetTimer(int64_t delay_ms, void* context) OVERRIDE;
   virtual double GetCurrentWallTimeInSeconds() OVERRIDE;
   virtual void SendKeyMessage(
       const char* session_id, int32_t session_id_length,
       const char* message, int32_t message_length,
       const char* default_url, int32_t default_url_length) OVERRIDE;
   virtual void SendKeyError(const char* session_id,
                             int32_t session_id_length,
                             cdm::MediaKeyError error_code,
                             uint32_t system_code) OVERRIDE;
   virtual void GetPrivateData(int32_t* instance,
                               GetPrivateInterface* get_interface) OVERRIDE;
 
+  // cdm::Host_2 implementation.
+  virtual bool CanChallengePlatform() OVERRIDE;
+  virtual void SendPlatformChallenge(
+      const char* service_id, int32_t service_id_length,
+      const char* challenge, int32_t challenge_length) OVERRIDE;
+  virtual void EnableOutputProtection(
+      uint32_t desired_protection_mask) OVERRIDE;
+  virtual void QueryOutputProtectionStatus() OVERRIDE;
+
  private:
   struct SessionInfo {
     SessionInfo(const std::string& key_system_in,
                 const std::string& session_id_in)
         : key_system(key_system_in),
           session_id(session_id_in) {}
     const std::string key_system;
     const std::string session_id;
   };
 
@@ skipping 47 matching lines @@
   void DeliverSamples(int32_t result,
                       const cdm::Status& status,
                       const LinkedAudioFrames& audio_frames,
                       const PP_DecryptTrackingInfo& tracking_info);
 
   // Helper for SetTimer().
   void TimerExpired(int32_t result, void* context);
 
   bool IsValidVideoFrame(const LinkedVideoFrame& video_frame);
 
+#if defined(OS_CHROMEOS)
+  void CanChallengePlatformDone(int32_t result, bool can_challenge_platform);
+  void SendPlatformChallengeDone(int32_t result);
+  void EnableProtectionDone(int32_t result);
+  void QueryOutputProtectionStatusDone(int32_t result);
+
+  pp::OutputProtection_Private output_protection_;
+  pp::PlatformVerification platform_verification_;
+
+  // |can_challenge_platform_| is currently set asynchronously, return the value
+  // if we have it, otherwise guess "true" for the most common case...
+  // TODO(jrummell): This stinks.  The value should be delivered via the
+  // Initialize() method once plumbed.
+  bool can_challenge_platform_;
+
+  // Since PPAPI doesn't provide handlers for CompletionCallbacks w/ more than
+  // one output we need to manage our own.  These values are only read by
+  // SendPlatformChallengeDone().
+  pp::Var signed_data_output_;
+  pp::Var signed_data_signature_output_;
+  pp::Var platform_key_certificate_output_;
+  bool challenge_in_progress_;
+
+  // Same as above, these are only read by QueryOutputProtectionStatusDone().
+  uint32_t output_link_mask_;
+  uint32_t output_protection_mask_;
+  bool query_output_protection_in_progress_;
+#endif
+
   PpbBufferAllocator allocator_;
   pp::CompletionCallbackFactory<CdmWrapper> callback_factory_;
   cdm::ContentDecryptionModule* cdm_;
   std::string key_system_;
 
   DISALLOW_COPY_AND_ASSIGN(CdmWrapper);
 };
 
 CdmWrapper::CdmWrapper(PP_Instance instance, pp::Module* module)
     : pp::Instance(instance),
       pp::ContentDecryptor_Private(this),
+#if defined(OS_CHROMEOS)
+      output_protection_(this),
+      platform_verification_(this),
+      // Err on the side of the most common case...
+      can_challenge_platform_(true),
+      challenge_in_progress_(false),
+      output_link_mask_(0),
+      output_protection_mask_(0),
+      query_output_protection_in_progress_(false),
+#endif
       allocator_(this),
       cdm_(NULL) {
   callback_factory_.Initialize(this);
+#if defined(OS_CHROMEOS)
+  // Preemptively retrieve the platform challenge status.  It will not change.
+  platform_verification_.CanChallengePlatform(
+      callback_factory_.NewCallbackWithOutput(
+          &CdmWrapper::CanChallengePlatformDone));
+#endif
 }
 
 CdmWrapper::~CdmWrapper() {
   if (cdm_)
     cdm_->Destroy();
 }
 
 bool CdmWrapper::CreateCdmInstance(const std::string& key_system) {
   PP_DCHECK(!cdm_);
   cdm_ = static_cast<cdm::ContentDecryptionModule*>(
@@ skipping 296 matching lines @@
                               int32_t session_id_length,
                               cdm::MediaKeyError error_code,
                               uint32_t system_code) {
   SendKeyErrorInternal(key_system_,
                        std::string(session_id, session_id_length),
                        error_code,
                        system_code);
 }
 
 void CdmWrapper::GetPrivateData(int32_t* instance,
-                                cdm::Host::GetPrivateInterface* get_interface) {
+                                GetPrivateInterface* get_interface) {
   *instance = pp_instance();
   *get_interface = pp::Module::Get()->get_browser_interface();
 }
 
 void CdmWrapper::SendUnknownKeyError(const std::string& key_system,
                                      const std::string& session_id) {
   SendKeyErrorInternal(key_system, session_id, cdm::kUnknownError, 0);
 }
 
 void CdmWrapper::SendKeyAdded(const std::string& key_system,
@@ skipping 198 matching lines @@
         static_cast<cdm::VideoFrame::VideoPlane>(i);
     if (ppb_buffer->Size() < video_frame->PlaneOffset(plane) +
                              plane_height * video_frame->Stride(plane)) {
       return false;
     }
   }
 
   return true;
 }
 
+bool CdmWrapper::CanChallengePlatform() {
+#if defined(OS_CHROMEOS)
+  return can_challenge_platform_;
+#else
+  return false;
+#endif
+}
+
+void CdmWrapper::SendPlatformChallenge(
+    const char* service_id, int32_t service_id_length,
+    const char* challenge, int32_t challenge_length) {
+#if defined(OS_CHROMEOS)
+  PP_DCHECK(!challenge_in_progress_);
+
+  // Ensure member variables set by the callback are in a clean state.
+  signed_data_output_ = pp::Var();
+  signed_data_signature_output_ = pp::Var();
+  platform_key_certificate_output_ = pp::Var();
+
+  pp::VarArrayBuffer challenge_var(challenge_length);
+  uint8_t* var_data = static_cast<uint8_t*>(challenge_var.Map());
+  memcpy(var_data, challenge, challenge_length);
+
+  std::string service_id_str(service_id, service_id_length);
+  int32_t result = platform_verification_.ChallengePlatform(
+      pp::Var(service_id_str), challenge_var, &signed_data_output_,
+      &signed_data_signature_output_, &platform_key_certificate_output_,
+      callback_factory_.NewCallback(&CdmWrapper::SendPlatformChallengeDone));
+  challenge_var.Unmap();
+  if (result == PP_OK_COMPLETIONPENDING) {
+    challenge_in_progress_ = true;
+    return;
+  }
+
+  // Fall through on error and issue an empty OnPlatformChallengeResponse().
+  PP_DCHECK(result != PP_OK);
+#endif
+
+  cdm::PlatformChallengeResponse response = {};
+  cdm_->OnPlatformChallengeResponse(response);
+}
+
+void CdmWrapper::EnableOutputProtection(uint32_t desired_protection_mask) {
+#if defined(OS_CHROMEOS)
+  output_protection_.EnableProtection(
+      desired_protection_mask, callback_factory_.NewCallback(
+          &CdmWrapper::EnableProtectionDone));
+
+  // Errors are ignored since clients must call QueryOutputProtectionStatus() to
+  // inspect the protection status on a regular basis.
+  // TODO(dalecurtis): It'd be nice to log a message or non-fatal error here...
+#endif
+}
+
+void CdmWrapper::QueryOutputProtectionStatus() {
+#if defined(OS_CHROMEOS)
+  PP_DCHECK(!query_output_protection_in_progress_);
+
+  output_link_mask_ = output_protection_mask_ = 0;
+  const int32_t result = output_protection_.QueryStatus(
+      &output_link_mask_,
+      &output_protection_mask_,
+      callback_factory_.NewCallback(
+          &CdmWrapper::QueryOutputProtectionStatusDone));
+  if (result == PP_OK_COMPLETIONPENDING) {
+    query_output_protection_in_progress_ = true;
+    return;
+  }
+
+  // Fall through on error and issue an empty OnQueryOutputProtectionStatus().
+  PP_DCHECK(result != PP_OK);
+#endif
+
+  cdm_->OnQueryOutputProtectionStatus(0, 0);
+}
+
+#if defined(OS_CHROMEOS)
+void CdmWrapper::CanChallengePlatformDone(int32_t result,
+                                          bool can_challenge_platform) {
+  can_challenge_platform_ = (result == PP_OK) ? can_challenge_platform : false;
+}
+
+void CdmWrapper::SendPlatformChallengeDone(int32_t result) {
+  challenge_in_progress_ = false;
+
+  if (result != PP_OK) {
+    cdm::PlatformChallengeResponse response = {};
+    cdm_->OnPlatformChallengeResponse(response);
+    return;
+  }
+
+  pp::VarArrayBuffer signed_data_var(signed_data_output_);
+  pp::VarArrayBuffer signed_data_signature_var(signed_data_signature_output_);
+  std::string platform_key_certificate_string =
+      platform_key_certificate_output_.AsString();
+
+  cdm::PlatformChallengeResponse response = {
+    static_cast<uint8_t*>(signed_data_var.Map()),
+    static_cast<int32_t>(signed_data_var.ByteLength()),
+
+    static_cast<uint8_t*>(signed_data_signature_var.Map()),
+    static_cast<int32_t>(signed_data_signature_var.ByteLength()),
+
+    reinterpret_cast<const uint8_t*>(platform_key_certificate_string.c_str()),
+    static_cast<int32_t>(platform_key_certificate_string.length())
+  };
+  cdm_->OnPlatformChallengeResponse(response);
+
+  signed_data_var.Unmap();
+  signed_data_signature_var.Unmap();
+}
+
+void CdmWrapper::EnableProtectionDone(int32_t result) {
+  // Does nothing since clients must call QueryOutputProtectionStatus() to
+  // inspect the protection status on a regular basis.
+  // TODO(dalecurtis): It'd be nice to log a message or non-fatal error here...
+}
+
+void CdmWrapper::QueryOutputProtectionStatusDone(int32_t result) {
+  PP_DCHECK(query_output_protection_in_progress_);
+  query_output_protection_in_progress_ = false;
+
+  // Return a protection status of none on error.
+  if (result != PP_OK)
+    output_link_mask_ = output_protection_mask_ = 0;
+
+  cdm_->OnQueryOutputProtectionStatus(output_link_mask_,
+                                      output_protection_mask_);
+}
+#endif
+
 void* GetCdmHost(int host_interface_version, void* user_data) {
   if (!host_interface_version || !user_data)
     return NULL;
 
-  if (host_interface_version != cdm::kHostInterfaceVersion)
-    return NULL;
-
   CdmWrapper* cdm_wrapper = static_cast<CdmWrapper*>(user_data);
-  return static_cast<cdm::Host*>(cdm_wrapper);
+  switch (host_interface_version) {
+    case cdm::kHostInterfaceVersion_1:
+      return static_cast<cdm::Host_1*>(cdm_wrapper);
+    case cdm::kHostInterfaceVersion_2:
+      return static_cast<cdm::Host_2*>(cdm_wrapper);
+    default:
+      PP_NOTREACHED();
+      return NULL;
+  }
 }
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class CdmWrapperModule : public pp::Module {
  public:
   CdmWrapperModule() : pp::Module() {
     // This function blocks the renderer thread (PluginInstance::Initialize()).
     // Move this call to other places if this may be a concern in the future.
     INITIALIZE_CDM_MODULE();
@@ skipping 10 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmWrapperModule();
 }
 
 }  // namespace pp