Fix resource leaks in CDM implementation.

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/platform_file.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/proxy/content_decryptor_private_serializer.h"
@@ skipping 122 matching lines @@
     NOTREACHED();
     return PP_FALSE;
   }
   const PPB_Core* core = static_cast<const PPB_Core*>(
       dispatcher->local_get_interface()(PPB_CORE_INTERFACE));
   if (!core) {
     NOTREACHED();
     return PP_FALSE;
   }
 
-  // We need to take a ref on the resource now. The browser may drop
-  // references once we return from here, but we're sending an asynchronous
-  // message. The plugin side takes ownership of that reference.
-  core->AddRefResource(encrypted_block);

[dmichael (off chromium), 2012/09/05 17:13:06]

tl;dr: Keep this. What you're missing is the corresponding dereference.

I think you still need this. You want to make sure that the resource lives long
enough that it's still alive when the plugin receives it. Since you're sending
an asynchronous message (as you should), it's reasonably likely that the browser
will be done with this call before the plugin can handle the
PpapiMsg_PPPContentDecryptor_Decrypt message. What you want to do is add the
corresponding RemoveRef after the plugin has gotten the message (see comment
later in the file).

It might actually work for now. I think the IPC magic under the hood might hold
open the shared memory, since you're sending a shared memory handle. But it
might cause trouble that you have a HostResource on the other side that's no
longer valid. That'll probably bite you later if you start reusing the buffer
resources.

[Tom Finegan, 2012/09/05 19:21:43]

Done.

-
   HostResource host_resource;
   host_resource.SetHostResource(instance, encrypted_block);
 
   uint32_t size = 0;
   if (DescribeHostBufferResource(encrypted_block, &size) == PP_FALSE)
     return PP_FALSE;
 
   base::SharedMemoryHandle handle;
   if (ShareHostBufferResourceToPlugin(dispatcher,
                                       encrypted_block,
@@ skipping 155 matching lines @@
         PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
                                            encrypted_buffer.handle,
                                            encrypted_buffer.size);
     PP_EncryptedBlockInfo block_info;
     if (!DeserializeBlockInfo(serialized_block_info, &block_info))
       return;
     CallWhileUnlocked(ppp_decryptor_impl_->Decrypt,
                       instance,
                       plugin_resource,
                       const_cast<const PP_EncryptedBlockInfo*>(&block_info));
   }

[dmichael (off chromium), 2012/09/05 17:13:06]

At this point, you need to tell the renderer to drop the reference it added on
the plugin's behalf. Doing ReleaseResource() on the plugin-side ResourceTracker
won't work, since what you really want is to release a reference on the
renderer/host side. There's an example of this in ppb_image_data_proxy.cc; I'll
copy/paste that part here for your reference:
"""
  // The renderer sent us a reference with the message. If the image data was
  // still cached in our process, the proxy still holds a reference so we can
  // remove the one the renderer just sent is. If the proxy no longer holds a
  // reference, we released everything and we should also release the one the
  // renderer just sent us.
  dispatcher()->Send(new PpapiHostMsg_PPBCore_ReleaseResource(
      API_ID_PPB_CORE, old_image_data));
"""

[Tom Finegan, 2012/09/05 19:21:43]

Done.

 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecryptAndDecode(
     PP_Instance instance,
     const PPPDecryptor_Buffer& encrypted_buffer,
     const std::string& serialized_block_info) {
   if (ppp_decryptor_impl_) {
     PP_Resource plugin_resource =
         PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
                                            encrypted_buffer.handle,
                                            encrypted_buffer.size);
     PP_EncryptedBlockInfo block_info;
     if (!DeserializeBlockInfo(serialized_block_info, &block_info))
       return;
     CallWhileUnlocked(ppp_decryptor_impl_->DecryptAndDecode,
                       instance,
                       plugin_resource,
                       const_cast<const PP_EncryptedBlockInfo*>(&block_info));
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi