Stub in more IPC attachment brokering functionality.

ipc/ipc_message_attachment_set.cc

 // Copyright (c) 2011 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 "ipc/ipc_message_attachment_set.h"
 
 #include <algorithm>
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
+#include "ipc/brokerable_attachment.h"
 #include "ipc/ipc_message_attachment.h"
 
 #if defined(OS_POSIX)
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif // OS_POSIX
 
 namespace IPC {
 
+namespace {
+
+unsigned count_attachments_of_type(
+    const std::vector<scoped_refptr<MessageAttachment>>& attachments,
+    MessageAttachment::Type type) {
+  unsigned count = 0;
+  for (const scoped_refptr<MessageAttachment>& attachment : attachments) {
+    if (attachment->GetType() == type)
+      ++count;
+  }
+  return count;
+}
+
+}  // namespace
+
 MessageAttachmentSet::MessageAttachmentSet()
     : consumed_descriptor_highwater_(0) {
 }
 
 MessageAttachmentSet::~MessageAttachmentSet() {
   if (consumed_descriptor_highwater_ == size())
     return;
 
   // We close all the owning descriptors. If this message should have
   // been transmitted, then closing those with close flags set mirrors
   // the expected behaviour.
   //
   // If this message was received with more descriptors than expected
   // (which could a DOS against the browser by a rogue renderer) then all
   // the descriptors have their close flag set and we free all the extra
   // kernel resources.
   LOG(WARNING) << "MessageAttachmentSet destroyed with unconsumed descriptors: "
                << consumed_descriptor_highwater_ << "/" << size();
 }
 
 unsigned MessageAttachmentSet::num_descriptors() const {
-  return std::count_if(attachments_.begin(), attachments_.end(),
-                       [](scoped_refptr<MessageAttachment> i) {
-    return i->GetType() == MessageAttachment::TYPE_PLATFORM_FILE;
-  });
+  return count_attachments_of_type(attachments_,
+                                   MessageAttachment::TYPE_PLATFORM_FILE);
 }
 
 unsigned MessageAttachmentSet::num_mojo_handles() const {
-  return std::count_if(attachments_.begin(), attachments_.end(),
-                       [](scoped_refptr<MessageAttachment> i) {
-    return i->GetType() == MessageAttachment::TYPE_MOJO_HANDLE;
-  });
+  return count_attachments_of_type(attachments_,
+                                   MessageAttachment::TYPE_MOJO_HANDLE);
+}
+
+unsigned MessageAttachmentSet::num_brokerable_attachments() const {
+  return count_attachments_of_type(
+      attachments_, MessageAttachment::TYPE_BROKERABLE_ATTACHMENT);
 }
 
 unsigned MessageAttachmentSet::size() const {
   return static_cast<unsigned>(attachments_.size());
 }
 
 bool MessageAttachmentSet::AddAttachment(
     scoped_refptr<MessageAttachment> attachment) {
 #if defined(OS_POSIX)
   if (attachment->GetType() == MessageAttachment::TYPE_PLATFORM_FILE &&
@@ skipping 44 matching lines @@
   consumed_descriptor_highwater_ = index + 1;
 
   return attachments_[index];
 }
 
 void MessageAttachmentSet::CommitAll() {
   attachments_.clear();
   consumed_descriptor_highwater_ = 0;
 }
 
+std::vector<const BrokerableAttachment*>
+MessageAttachmentSet::PeekBrokerableAttachments() const {
+  std::vector<const BrokerableAttachment*> output;
+  for (const scoped_refptr<MessageAttachment>& attachment : attachments_) {
+    if (attachment->GetType() ==
+        MessageAttachment::TYPE_BROKERABLE_ATTACHMENT) {
+      output.push_back(static_cast<BrokerableAttachment*>(attachment.get()));
+    }
+  }
+  return output;
+}
+
 #if defined(OS_POSIX)
 
 void MessageAttachmentSet::PeekDescriptors(base::PlatformFile* buffer) const {
   for (size_t i = 0; i != attachments_.size(); ++i)
     buffer[i] = internal::GetPlatformFile(attachments_[i]);
 }
 
 bool MessageAttachmentSet::ContainsDirectoryDescriptor() const {
   struct stat st;
 
@@ skipping 27 matching lines @@
   for (unsigned i = 0; i < count; ++i)
     AddAttachment(
         new internal::PlatformFileAttachment(base::ScopedFD(buffer[i])));
 }
 
 #endif  // OS_POSIX
 
 }  // namespace IPC