Return void from all PPP CDM API interface methods

webkit/media/crypto/ppapi/cdm_wrapper.cc

 // Copyright (c) 2012 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>  // For memcpy.
 #include <vector>
 
 #include "base/compiler_specific.h"  // For OVERRIDE.
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_stdint.h"
@@ skipping 54 matching lines @@
 
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     return true;
   }
 
   // PPP_ContentDecryptor_Private methods
   // Note: As per comments in PPP_ContentDecryptor_Private, these calls should
   // return false if the call was not forwarded to the CDM and should return
   // true otherwise. Once the call reaches the CDM, the call result/status
   // should be reported through the PPB_ContentDecryptor_Private interface.
-  virtual bool GenerateKeyRequest(const std::string& key_system,
+  virtual void GenerateKeyRequest(const std::string& key_system,
                                   pp::VarArrayBuffer init_data) OVERRIDE;
-  virtual bool AddKey(const std::string& session_id,
+  virtual void AddKey(const std::string& session_id,
                       pp::VarArrayBuffer key,
                       pp::VarArrayBuffer init_data) OVERRIDE;
-  virtual bool CancelKeyRequest(const std::string& session_id) OVERRIDE;
-  virtual bool Decrypt(
+  virtual void CancelKeyRequest(const std::string& session_id) OVERRIDE;
+  virtual void Decrypt(
       pp::Buffer_Dev encrypted_buffer,
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
-  virtual bool DecryptAndDecode(
+  virtual void DecryptAndDecode(
       pp::Buffer_Dev encrypted_buffer,
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
 
  private:
   // Creates a PP_Resource containing a PPB_Buffer_Impl, copies |data| into the
   // buffer resource, and returns it. Returns a an invalid PP_Resource with an
   // ID of 0 on failure. Upon success, the returned Buffer resource has a
   // reference count of 1.
   pp::Buffer_Dev MakeBufferResource(const uint8_t* data, uint32_t data_size);
 
@@ skipping 18 matching lines @@
       pp::ContentDecryptor_Private(this),
       cdm_(NULL) {
   callback_factory_.Initialize(this);
 }
 
 CdmWrapper::~CdmWrapper() {
   if (cdm_)
     DestroyCdmInstance(cdm_);
 }
 
-bool CdmWrapper::GenerateKeyRequest(const std::string& key_system,
+void CdmWrapper::GenerateKeyRequest(const std::string& key_system,
                                     pp::VarArrayBuffer init_data) {
   PP_DCHECK(!key_system.empty());
 
   if (!cdm_) {
     cdm_ = CreateCdmInstance();
     if (!cdm_)
-      return false;
+      return;

[xhwang, 2012/09/13 12:24:59]

Should we return a keyerror here? Based on the spec, if the key request cannot
be generated, a keyerror should be fired
(http://dvcs.w3.org/hg/html-media/raw-file/eme-v0.1b/encrypted-media/encrypted...)

[Tom Finegan, 2012/09/14 00:08:37]

Makes sense. I agree.

   }
 
   cdm::KeyMessage key_request;
   cdm::Status status = cdm_->GenerateKeyRequest(
       reinterpret_cast<const uint8_t*>(init_data.Map()),
       init_data.ByteLength(),
       &key_request);
 
   if (status != cdm::kSuccess ||
       !key_request.message ||
       key_request.message_size == 0) {
     CallOnMain(callback_factory_.NewCallback(&CdmWrapper::KeyError,
                                              std::string()));
-    return true;
+    return;
   }
 
   // TODO(xhwang): Remove unnecessary CallOnMain calls here and below once we
   // only support out-of-process.
   // If running out-of-process, PPB calls will always behave asynchronously
   // since IPC is involved. In that case, if we are already on main thread,
   // we don't need to use CallOnMain to help us call PPB call on main thread,
   // or to help call PPB asynchronously.
   key_system_ = key_system;
   CallOnMain(callback_factory_.NewCallback(&CdmWrapper::KeyMessage,
                                            key_request));
-
-  return true;
 }
 
-bool CdmWrapper::AddKey(const std::string& session_id,
+void CdmWrapper::AddKey(const std::string& session_id,
                         pp::VarArrayBuffer key,
                         pp::VarArrayBuffer init_data) {
   const uint8_t* key_ptr = reinterpret_cast<const uint8_t*>(key.Map());
   int key_size = key.ByteLength();
   const uint8_t* init_data_ptr =
       reinterpret_cast<const uint8_t*>(init_data.Map());
   int init_data_size = init_data.ByteLength();
 
   if (!key_ptr || key_size <= 0 || !init_data_ptr || init_data_size <= 0)
-    return false;
+    return;

[xhwang, 2012/09/13 12:24:59]

ditto, a keyerror here?

[Tom Finegan, 2012/09/14 00:08:37]

Same, agreed.

 
   PP_DCHECK(cdm_);
   cdm::Status status = cdm_->AddKey(session_id.data(), session_id.size(),
                                     key_ptr, key_size,
                                     init_data_ptr, init_data_size);
 
   if (status != cdm::kSuccess) {
     CallOnMain(callback_factory_.NewCallback(&CdmWrapper::KeyError,
                                              session_id));
-    return true;
+    return;
   }
 
   CallOnMain(callback_factory_.NewCallback(&CdmWrapper::KeyAdded, session_id));
-  return true;
 }
 
-bool CdmWrapper::CancelKeyRequest(const std::string& session_id) {
+void CdmWrapper::CancelKeyRequest(const std::string& session_id) {
   PP_DCHECK(cdm_);
-
   cdm::Status status = cdm_->CancelKeyRequest(session_id.data(),
                                               session_id.size());
-
   if (status != cdm::kSuccess) {
     CallOnMain(callback_factory_.NewCallback(&CdmWrapper::KeyError,
                                              session_id));
-    return true;
   }
-
-  return true;
 }
 
-bool CdmWrapper::Decrypt(pp::Buffer_Dev encrypted_buffer,
+void CdmWrapper::Decrypt(pp::Buffer_Dev encrypted_buffer,
                          const PP_EncryptedBlockInfo& encrypted_block_info) {
   PP_DCHECK(!encrypted_buffer.is_null());
   PP_DCHECK(cdm_);
 
   // TODO(xhwang): Simplify the following data conversion.
   cdm::InputBuffer input_buffer;
   input_buffer.data = reinterpret_cast<uint8_t*>(encrypted_buffer.data());
   input_buffer.data_size = encrypted_buffer.size();
   input_buffer.data_offset = encrypted_block_info.data_offset;
   input_buffer.key_id = encrypted_block_info.key_id;
@@ skipping 13 matching lines @@
   input_buffer.timestamp = encrypted_block_info.tracking_info.timestamp;
 
   cdm::OutputBuffer output_buffer;
   cdm::Status status = cdm_->Decrypt(input_buffer, &output_buffer);
 
   CallOnMain(callback_factory_.NewCallback(
       &CdmWrapper::DeliverBlock,
       status,
       output_buffer,
       encrypted_block_info.tracking_info));
-  return true;
 }
 
-bool CdmWrapper::DecryptAndDecode(
+void CdmWrapper::DecryptAndDecode(
     pp::Buffer_Dev encrypted_buffer,
     const PP_EncryptedBlockInfo& encrypted_block_info) {
-  return false;
 }
 
 pp::Buffer_Dev CdmWrapper::MakeBufferResource(const uint8_t* data,
                                               uint32_t data_size) {
   if (!data || !data_size)
     return pp::Buffer_Dev();
 
   pp::Buffer_Dev buffer(this, data_size);
   if (!buffer.data())
     return pp::Buffer_Dev();
@@ skipping 80 matching lines @@
 }  // namespace webkit_media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new webkit_media::MyModule();
 }
 
 }  // namespace pp