Return void from all PPP CDM API interface methods

webkit/media/crypto/ppapi_decryptor.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 "webkit/media/crypto/ppapi_decryptor.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 23 matching lines @@
 
 bool PpapiDecryptor::GenerateKeyRequest(const std::string& key_system,
                                         const uint8* init_data,
                                         int init_data_length) {
   DVLOG(1) << "GenerateKeyRequest()";
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   DCHECK(cdm_plugin_);
 
   // TODO(xhwang): Finalize the data type for |init_data| to avoid unnecessary
   // data type conversions.
-  if (!cdm_plugin_->GenerateKeyRequest(
+  cdm_plugin_->GenerateKeyRequest(
       key_system,
       std::string(reinterpret_cast<const char*>(init_data),
-                  init_data_length))) {
-    ReportFailureToCallPlugin(key_system, "");
-    return false;
-  }
-
+                  init_data_length));
   return true;
 }
 
 void PpapiDecryptor::AddKey(const std::string& key_system,
                             const uint8* key,
                             int key_length,
                             const uint8* init_data,
                             int init_data_length,
                             const std::string& session_id) {
   DVLOG(1) << "AddKey()";
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   DCHECK(cdm_plugin_);
 
-  if (!cdm_plugin_->AddKey(session_id,
-                           std::string(reinterpret_cast<const char*>(key),
-                                       key_length),
-                           std::string(reinterpret_cast<const char*>(init_data),
-                                       init_data_length))) {
-    ReportFailureToCallPlugin(key_system, session_id);
-  }
+  cdm_plugin_->AddKey(session_id,
+                      std::string(reinterpret_cast<const char*>(key),
+                                  key_length),
+                      std::string(reinterpret_cast<const char*>(init_data),
+                                  init_data_length));
 }
 
 void PpapiDecryptor::CancelKeyRequest(const std::string& key_system,
                                       const std::string& session_id) {
   DVLOG(1) << "CancelKeyRequest()";
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   DCHECK(cdm_plugin_);
 
-  if (!cdm_plugin_->CancelKeyRequest(session_id))
-    ReportFailureToCallPlugin(key_system, session_id);
+  cdm_plugin_->CancelKeyRequest(session_id);
 }
 
 void PpapiDecryptor::Decrypt(
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const DecryptCB& decrypt_cb) {
   DVLOG(1) << "Decrypt()";
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
     render_loop_proxy_->PostTask(
         FROM_HERE,
         base::Bind(&PpapiDecryptor::Decrypt, base::Unretained(this),
                    encrypted, decrypt_cb));
     return;
   }
 
-  if (!cdm_plugin_->Decrypt(encrypted, decrypt_cb))
-    decrypt_cb.Run(kError, NULL);
+  cdm_plugin_->Decrypt(encrypted, decrypt_cb);
 }
 
 void PpapiDecryptor::Stop() {
 }
 
-void PpapiDecryptor::ReportFailureToCallPlugin(const std::string& key_system,
-                                               const std::string& session_id) {
-  DVLOG(1) << "Failed to call plugin.";
-  client_->KeyError(key_system, session_id, kUnknownError, 0);
-}
-
 }  // namespace webkit_media