Revert of IPC: Add attachment brokering support to the message header.

ipc/ipc_message.h

 // 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.
 
 #ifndef IPC_IPC_MESSAGE_H_
 #define IPC_IPC_MESSAGE_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/pickle.h"
 #include "base/trace_event/trace_event.h"
-#include "ipc/attachment_broker.h"
-#include "ipc/brokerable_attachment.h"
 #include "ipc/ipc_export.h"
 
 #if !defined(NDEBUG)
 #define IPC_MESSAGE_LOG_ENABLED
 #endif
 
 namespace IPC {
 
 namespace internal {
 class ChannelReader;
@@ skipping 133 matching lines @@
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,
                        void (T::*func)(P*)) {
     (obj->*func)(parameter);
     return true;
   }
 
   // Used for async messages with no parameters.
   static void Log(std::string* name, const Message* msg, std::string* l) {
   }
 
-  // The static method FindNext() returns several pieces of information, which
-  // are aggregated into an instance of this struct.
-  struct NextMessageInfo {
-    NextMessageInfo();
-    ~NextMessageInfo();
-    // Whether an entire message was found in the given memory range. If this is
-    // false, the other fields are left uninitialized.
-    bool message_found;
-    // The start address is passed into FindNext() by the caller, so isn't
-    // repeated in this struct. The end address of the pickle should be used to
-    // construct a base::Pickle.
-    const char* pickle_end;
-    // The end address of the message should be used to determine the start
-    // address of the next message.
-    const char* message_end;
-    // If the message has brokerable attachments, this vector will contain the
-    // ids of the brokerable attachments. The caller of FindNext() is
-    // responsible for adding the attachments to the message.
-    std::vector<BrokerableAttachment::AttachmentId> attachment_ids;
-  };
-
-  static NextMessageInfo FindNext(const char* range_start,
-                                  const char* range_end);
-
-  struct SerializedAttachmentIds {
-    void* buffer;
-    size_t size;
-  };
-  // Creates a buffer that contains a serialization of the ids of the brokerable
-  // attachments of the message. This buffer is intended to be sent over the IPC
-  // channel immediately after the pickled message. The caller takes ownership
-  // of the buffer.
-  // This method should only be called if the message has brokerable
-  // attachments.
-  SerializedAttachmentIds SerializedIdsOfBrokerableAttachments();
-
-  // Adds a placeholder brokerable attachment that must be replaced before the
-  // message can be dispatched.
-  bool AddPlaceholderBrokerableAttachmentWithId(
-      BrokerableAttachment::AttachmentId id);
+  // Find the end of the message data that starts at range_start.  Returns NULL
+  // if the entire message is not found in the given data range.
+  static const char* FindNext(const char* range_start, const char* range_end) {
+    return base::Pickle::FindNext(sizeof(Header), range_start, range_end);
+  }
 
   // WriteAttachment appends |attachment| to the end of the set. It returns
   // false iff the set is full.
   bool WriteAttachment(scoped_refptr<MessageAttachment> attachment);
   // ReadAttachment parses an attachment given the parsing state |iter| and
   // writes it to |*attachment|. It returns true on success.
   bool ReadAttachment(base::PickleIterator* iter,
                       scoped_refptr<MessageAttachment>* attachment) const;
   // Returns true if there are any attachment in this message.
   bool HasAttachments() const;
@@ skipping 44 matching lines @@
   friend class ChannelWin;
   friend class internal::ChannelReader;
   friend class MessageReplyDeserializer;
   friend class SyncMessage;
 
 #pragma pack(push, 4)
   struct Header : base::Pickle::Header {
     int32 routing;  // ID of the view that this message is destined for
     uint32 type;    // specifies the user-defined message type
     uint32 flags;   // specifies control flags for the message
-#if USE_ATTACHMENT_BROKER
-    // The number of brokered attachments included with this message. The
-    // ids of the brokered attachment ids are sent immediately after the pickled
-    // message, before the next pickled message is sent.
-    uint32 num_brokered_attachments;
-#endif
 #if defined(OS_POSIX)
     uint16 num_fds; // the number of descriptors included with this message
     uint16 pad;     // explicitly initialize this to appease valgrind
 #endif
   };
 #pragma pack(pop)
 
   Header* header() {
     return headerT<Header>();
   }
@@ skipping 42 matching lines @@
   MSG_ROUTING_NONE = -2,
 
   // indicates a general message not sent to a particular tab.
   MSG_ROUTING_CONTROL = kint32max,
 };
 
 #define IPC_REPLY_ID 0xFFFFFFF0  // Special message id for replies
 #define IPC_LOGGING_ID 0xFFFFFFF1  // Special message id for logging
 
 #endif  // IPC_IPC_MESSAGE_H_