Avoid leaking SerializedHandles.

ppapi/proxy/resource_message_params.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/resource_message_params.h"
 
+#include "base/logging.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 namespace ppapi {
 namespace proxy {
 
+ResourceMessageParams::SerializedHandles::SerializedHandles()
+    : should_close_(false) {
+}
+
+ResourceMessageParams::SerializedHandles::~SerializedHandles() {
+  if (should_close_) {
+    for (std::vector<SerializedHandle>::iterator iter = data_.begin();
+         iter != data_.end(); ++iter) {
+      iter->Close();
+    }
+  }
+}
+
 ResourceMessageParams::ResourceMessageParams()
     : pp_resource_(0),
-      sequence_(0) {
+      sequence_(0),
+      handles_(new SerializedHandles()) {
 }
 
 ResourceMessageParams::ResourceMessageParams(PP_Resource resource,
                                              int32_t sequence)
     : pp_resource_(resource),
-      sequence_(sequence) {
+      sequence_(sequence),
+      handles_(new SerializedHandles()) {
 }
 
 ResourceMessageParams::~ResourceMessageParams() {
 }
 
 void ResourceMessageParams::Serialize(IPC::Message* msg) const {
   IPC::ParamTraits<PP_Resource>::Write(msg, pp_resource_);
   IPC::ParamTraits<int32_t>::Write(msg, sequence_);
-  IPC::ParamTraits<std::vector<SerializedHandle> >::Write(msg, handles_);
+  IPC::ParamTraits<std::vector<SerializedHandle> >::Write(msg,
+                                                          handles_->data());
 }
 
 bool ResourceMessageParams::Deserialize(const IPC::Message* msg,
                                         PickleIterator* iter) {
+  DCHECK(handles_->data().empty());
+  handles_->set_should_close(true);
   return IPC::ParamTraits<PP_Resource>::Read(msg, iter, &pp_resource_) &&
          IPC::ParamTraits<int32_t>::Read(msg, iter, &sequence_) &&
          IPC::ParamTraits<std::vector<SerializedHandle> >::Read(
-             msg, iter, &handles_);
+             msg, iter, &handles_->data());
 }
 
-const SerializedHandle* ResourceMessageParams::GetHandleOfTypeAtIndex(
+SerializedHandle ResourceMessageParams::TakeHandleOfTypeAtIndex(
     size_t index,
     SerializedHandle::Type type) const {
-  if (handles_.size() <= index)
-    return NULL;
-  if (handles_[index].type() != type)
-    return NULL;
-  return &handles_[index];
+  SerializedHandle handle;
+  std::vector<SerializedHandle>& data = handles_->data();
+  if (index < data.size() && data[index].type() == type) {
+    handle = data[index];
+    data[index] = SerializedHandle();
+  }
+  return handle;
 }
 
-bool ResourceMessageParams::GetSharedMemoryHandleAtIndex(
+bool ResourceMessageParams::TakeSharedMemoryHandleAtIndex(
     size_t index,
     base::SharedMemoryHandle* handle) const {
-  const SerializedHandle* serialized = GetHandleOfTypeAtIndex(
+  SerializedHandle serialized = TakeHandleOfTypeAtIndex(
       index, SerializedHandle::SHARED_MEMORY);
-  if (!serialized)
+  if (!serialized.is_shmem())
     return false;
-  *handle = serialized->shmem();
+  *handle = serialized.shmem();
   return true;
 }
 
-bool ResourceMessageParams::GetSocketHandleAtIndex(
+bool ResourceMessageParams::TakeSocketHandleAtIndex(
     size_t index,
     IPC::PlatformFileForTransit* handle) const {
-  const SerializedHandle* serialized = GetHandleOfTypeAtIndex(
+  SerializedHandle serialized = TakeHandleOfTypeAtIndex(
       index, SerializedHandle::SOCKET);
-  if (!serialized)
+  if (!serialized.is_socket())
     return false;
-  *handle = serialized->descriptor();
+  *handle = serialized.descriptor();
   return true;
 }
 
-void ResourceMessageParams::AppendHandle(const SerializedHandle& handle) {
-  handles_.push_back(handle);
+void ResourceMessageParams::AppendHandle(const SerializedHandle& handle) const {
+  handles_->data().push_back(handle);
 }
 
 ResourceMessageCallParams::ResourceMessageCallParams()
     : ResourceMessageParams(),
       has_callback_(0) {
 }
 
 ResourceMessageCallParams::ResourceMessageCallParams(PP_Resource resource,
                                                      int32_t sequence)
     : ResourceMessageParams(resource, sequence),
@@ skipping 36 matching lines @@
 
 bool ResourceMessageReplyParams::Deserialize(const IPC::Message* msg,
                                              PickleIterator* iter) {
   if (!ResourceMessageParams::Deserialize(msg, iter))
     return false;
   return IPC::ParamTraits<int32_t>::Read(msg, iter, &result_);
 }
 
 }  // namespace proxy
 }  // namespace ppapi