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 1435 matching lines @@
   plugin_pdf_interface_->Transform(pp_instance(), transform_type);
   // NOTE: plugin instance may have been deleted.
 }
 
 void PluginInstance::set_decrypt_client(
     media::DecryptorClient* decryptor_client) {
   DCHECK(decryptor_client);
   decryptor_client_ = decryptor_client;
 }
 
-bool PluginInstance::GenerateKeyRequest(const std::string& key_system,
+void PluginInstance::GenerateKeyRequest(const std::string& key_system,
                                         const std::string& init_data) {
   if (!LoadContentDecryptorInterface())
-    return false;
+    return;
   if (key_system.empty())
-    return false;
+    return;

[dmichael (off chromium), 2012/09/11 15:59:17]

At this level, I think it's up to you guys what you want to return. If you want
to be able to handle these kinds of failures, then returning bool makes sense.
If not, then maybe you should use DCHECKs or NOTREACHED()?

[Tom Finegan, 2012/09/11 16:49:24]

Done.

 
   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);
 }
 
-bool PluginInstance::AddKey(const std::string& session_id,
+void PluginInstance::AddKey(const std::string& session_id,
                             const std::string& key,
                             const std::string& init_data) {
   if (!LoadContentDecryptorInterface())
-    return false;
+    return;
   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);
 }
 
-bool PluginInstance::CancelKeyRequest(const std::string& session_id) {
+void PluginInstance::CancelKeyRequest(const std::string& session_id) {
   if (!LoadContentDecryptorInterface())
-    return false;
+    return;
 
-  return PP_ToBool(plugin_decryption_interface_->CancelKeyRequest(
+  plugin_decryption_interface_->CancelKeyRequest(
       pp_instance(),
-      StringVar::StringToPPVar(session_id)));
+      StringVar::StringToPPVar(session_id));
 }
 
-bool PluginInstance::Decrypt(
+void PluginInstance::Decrypt(
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const media::Decryptor::DecryptCB& decrypt_cb) {
   if (!LoadContentDecryptorInterface())
-    return false;
+    return;
 
   ScopedPPResource encrypted_resource(
       ScopedPPResource::PassRef(),
       MakeBufferResource(pp_instance(),
                          encrypted_buffer->GetData(),
                          encrypted_buffer->GetDataSize()));
   if (!encrypted_resource.get())
-    return false;
+    return;
 
   uint32_t request_id = next_decryption_request_id_++;
 
   PP_EncryptedBlockInfo block_info;
   DCHECK(encrypted_buffer->GetDecryptConfig());
   if (!MakeEncryptedBlockInfo(*encrypted_buffer->GetDecryptConfig(),
                               encrypted_buffer->GetTimestamp().InMicroseconds(),
                               request_id,
                               &block_info)) {
-    return false;
+    return;
   }
 
   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);
 }
 
-bool PluginInstance::DecryptAndDecode(
+void PluginInstance::DecryptAndDecode(
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const media::Decryptor::DecryptCB& decrypt_cb) {
   if (!LoadContentDecryptorInterface())
-    return false;
+    return;
 
   ScopedPPResource encrypted_resource(MakeBufferResource(
       pp_instance(),
       encrypted_buffer->GetData(),
       encrypted_buffer->GetDataSize()));
   if (!encrypted_resource.get())
-    return false;
+    return;
 
   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);
 }
 
 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