PPAPI: Make CallWhileUnlocked more permissive.

ppapi/proxy/ppp_content_decryptor_private_proxy.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 "ppapi/proxy/ppp_content_decryptor_private_proxy.h"
 
 #include "base/files/file.h"
 #include "media/base/limits.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/ppb_core.h"
@@ skipping 670 matching lines @@
       PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
                                          encrypted_buffer.handle,
                                          encrypted_buffer.size));
   if (ppp_decryptor_impl_) {
     PP_EncryptedBlockInfo block_info;
     if (!DeserializeBlockInfo(serialized_block_info, &block_info))
       return;
     CallWhileUnlocked(ppp_decryptor_impl_->Decrypt,
                       instance,
                       plugin_resource.get(),
-                      const_cast<const PP_EncryptedBlockInfo*>(&block_info));
+                      &block_info);
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitializeAudioDecoder(
     PP_Instance instance,
     const std::string& serialized_decoder_config,
     const PPPDecryptor_Buffer& extra_data_buffer) {
   ScopedPPResource plugin_resource;
   if (extra_data_buffer.size > 0) {
     plugin_resource = ScopedPPResource(
         ScopedPPResource::PassRef(),
         PPB_Buffer_Proxy::AddProxyResource(extra_data_buffer.resource,
                                            extra_data_buffer.handle,
                                            extra_data_buffer.size));
   }
 
   PP_AudioDecoderConfig decoder_config;
   if (!DeserializeBlockInfo(serialized_decoder_config, &decoder_config))
       return;
 
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
         ppp_decryptor_impl_->InitializeAudioDecoder,
         instance,
-        const_cast<const PP_AudioDecoderConfig*>(&decoder_config),
+        &decoder_config,
         plugin_resource.get());
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitializeVideoDecoder(
     PP_Instance instance,
     const std::string& serialized_decoder_config,
     const PPPDecryptor_Buffer& extra_data_buffer) {
   ScopedPPResource plugin_resource;
   if (extra_data_buffer.resource.host_resource() != 0) {
     plugin_resource = ScopedPPResource(
         ScopedPPResource::PassRef(),
         PPB_Buffer_Proxy::AddProxyResource(extra_data_buffer.resource,
                                            extra_data_buffer.handle,
                                            extra_data_buffer.size));
   }
 
   PP_VideoDecoderConfig decoder_config;
   if (!DeserializeBlockInfo(serialized_decoder_config, &decoder_config))
       return;
 
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
         ppp_decryptor_impl_->InitializeVideoDecoder,
         instance,
-        const_cast<const PP_VideoDecoderConfig*>(&decoder_config),
+        &decoder_config,
         plugin_resource.get());
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgDeinitializeDecoder(
     PP_Instance instance,
     PP_DecryptorStreamType decoder_type,
     uint32_t request_id) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
@@ skipping 33 matching lines @@
 
   if (ppp_decryptor_impl_) {
     PP_EncryptedBlockInfo block_info;
     if (!DeserializeBlockInfo(serialized_block_info, &block_info))
       return;
     CallWhileUnlocked(
         ppp_decryptor_impl_->DecryptAndDecode,
         instance,
         decoder_type,
         plugin_resource.get(),
-        const_cast<const PP_EncryptedBlockInfo*>(&block_info));
+        &block_info);
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi