Return void from all PPP CDM API interface methods

webkit/plugins/ppapi/ppapi_plugin_instance.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/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 1446 matching lines @@
                                         const std::string& init_data) {
   if (!LoadContentDecryptorInterface())
     return false;
   if (key_system.empty())
     return false;
 
   PP_Var init_data_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           init_data.size(), init_data.data());
 
-  return PP_ToBool(plugin_decryption_interface_->GenerateKeyRequest(
+  plugin_decryption_interface_->GenerateKeyRequest(
       pp_instance(),
       StringVar::StringToPPVar(key_system),
-      init_data_array));
+      init_data_array);
+  return true;
 }
 
 bool PluginInstance::AddKey(const std::string& session_id,
                             const std::string& key,
                             const std::string& init_data) {
   if (!LoadContentDecryptorInterface())
     return false;
   PP_Var key_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(key.size(),
                                                                  key.data());
   PP_Var init_data_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           init_data.size(),
           init_data.data());
 
-  return PP_ToBool(plugin_decryption_interface_->AddKey(
+  plugin_decryption_interface_->AddKey(
       pp_instance(),
       StringVar::StringToPPVar(session_id),
       key_array,
-      init_data_array));
+      init_data_array);
+  return true;
 }
 
 bool PluginInstance::CancelKeyRequest(const std::string& session_id) {
   if (!LoadContentDecryptorInterface())
     return false;
-
-  return PP_ToBool(plugin_decryption_interface_->CancelKeyRequest(
+  plugin_decryption_interface_->CancelKeyRequest(
       pp_instance(),
-      StringVar::StringToPPVar(session_id)));
+      StringVar::StringToPPVar(session_id));
+  return true;
 }
 
 bool PluginInstance::Decrypt(
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const media::Decryptor::DecryptCB& decrypt_cb) {
   if (!LoadContentDecryptorInterface())
     return false;
 
   ScopedPPResource encrypted_resource(
       ScopedPPResource::PassRef(),
@@ skipping 10 matching lines @@
   if (!MakeEncryptedBlockInfo(*encrypted_buffer->GetDecryptConfig(),
                               encrypted_buffer->GetTimestamp().InMicroseconds(),
                               request_id,
                               &block_info)) {
     return false;
   }
 
   DCHECK(!ContainsKey(pending_decryption_cbs_, request_id));
   pending_decryption_cbs_.insert(std::make_pair(request_id, decrypt_cb));
 
-  return PP_ToBool(plugin_decryption_interface_->Decrypt(pp_instance(),
-                                                         encrypted_resource,
-                                                         &block_info));
+  plugin_decryption_interface_->Decrypt(pp_instance(),
+                                        encrypted_resource,
+                                        &block_info);
+  return true;
 }
 
 bool PluginInstance::DecryptAndDecode(
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const media::Decryptor::DecryptCB& decrypt_cb) {
   if (!LoadContentDecryptorInterface())
     return false;
 
   ScopedPPResource encrypted_resource(MakeBufferResource(
       pp_instance(),
       encrypted_buffer->GetData(),
       encrypted_buffer->GetDataSize()));
   if (!encrypted_resource.get())
     return false;
 
   PP_EncryptedBlockInfo block_info;
 
   // TODO(tomfinegan): Store callback and ID in a map, and pass ID to decryptor.
-  return PP_ToBool(
-      plugin_decryption_interface_->DecryptAndDecode(pp_instance(),
-                                                     encrypted_resource,
-                                                     &block_info));
+  plugin_decryption_interface_->DecryptAndDecode(pp_instance(),
+                                                 encrypted_resource,
+                                                 &block_info);
+  return true;
 }
 
 bool PluginInstance::FlashIsFullscreenOrPending() {
   return fullscreen_container_ != NULL;
 }
 
 bool PluginInstance::IsFullscreenOrPending() {
   return desired_fullscreen_state_;
 }
 
@@ skipping 1100 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit