IPC: Add attachment brokering support to the message header.

ipc/ipc_channel_reader.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 "ipc/ipc_channel_reader.h"
 
 #include <algorithm>
 
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_attachment_set.h"
 #include "ipc/ipc_message_macros.h"
 
 namespace IPC {
 namespace internal {
 
 ChannelReader::ChannelReader(Listener* listener) : listener_(listener) {
   memset(input_buf_, 0, sizeof(input_buf_));
 }
 
 ChannelReader::~ChannelReader() {
-  if (!blocked_ids_.empty())
-    StopObservingAttachmentBroker();
+  DCHECK(blocked_ids_.empty());
 }
 
 ChannelReader::DispatchState ChannelReader::ProcessIncomingMessages() {
   while (true) {
     int bytes_read = 0;
     ReadState read_state = ReadData(input_buf_, Channel::kReadBufferSize,
                                     &bytes_read);
     if (read_state == READ_FAILED)
       return DISPATCH_ERROR;
     if (read_state == READ_PENDING)
@@ skipping 43 matching lines @@
       LOG(ERROR) << "IPC message is too big";
       return false;
     }
     input_overflow_buf_.append(input_data, input_data_len);
     p = input_overflow_buf_.data();
     end = p + input_overflow_buf_.size();
   }
 
   // Dispatch all complete messages in the data buffer.
   while (p < end) {
-    const char* message_tail = Message::FindNext(p, end);
-    if (message_tail) {
-      int len = static_cast<int>(message_tail - p);
+    Message::NextMessageInfo info = Message::FindNext(p, end);
+    if (info.message_found) {
+      int pickle_len = static_cast<int>(info.pickle_end - p);
+      Message translated_message(p, pickle_len);
 
-      Message translated_message(p, len);
+      for (const auto& id : info.attachment_ids)
+        translated_message.AddPlaceholderBrokerableAttachmentWithId(id);
+
       if (!GetNonBrokeredAttachments(&translated_message))
         return false;
 
       // If there are no queued messages, attempt to immediately dispatch the
       // newly translated message.
       if (queued_messages_.empty()) {
         DCHECK(blocked_ids_.empty());
         AttachmentIdSet blocked_ids =
             GetBrokeredAttachments(&translated_message);
 
         if (blocked_ids.empty()) {
           // Dispatch the message and continue the loop.
           DispatchMessage(&translated_message);
-          p = message_tail;
+          p = info.message_end;
           continue;
         }
 
         blocked_ids_.swap(blocked_ids);
         StartObservingAttachmentBroker();
       }
 
       // Make a deep copy of |translated_message| to add to the queue.
       scoped_ptr<Message> m(new Message(translated_message));
       queued_messages_.push_back(m.release());
-      p = message_tail;
+      p = info.message_end;
     } else {
       // Last message is partial.
       break;
     }
   }
 
   // Save any partial data in the overflow buffer.
   input_overflow_buf_.assign(p, end - p);
 
   if (input_overflow_buf_.empty() && !DidEmptyInputBuffers())
@@ skipping 14 matching lines @@
       StartObservingAttachmentBroker();
       return DISPATCH_WAITING_ON_BROKER;
     }
 
     DispatchMessage(m);
     queued_messages_.erase(queued_messages_.begin());
   }
   return DISPATCH_FINISHED;
 }
 
+void ChannelReader::CleanUp() {
+  if (!blocked_ids_.empty()) {
+    StopObservingAttachmentBroker();
+    blocked_ids_.clear();
+  }
+}
+
 void ChannelReader::DispatchMessage(Message* m) {
   m->set_sender_pid(GetSenderPID());
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
   std::string name;
   Logging::GetInstance()->GetMessageText(m->type(), &name, m, NULL);
   TRACE_EVENT_WITH_FLOW1("ipc,toplevel",
                          "ChannelReader::DispatchInputData",
                          m->flags(),
                          TRACE_EVENT_FLAG_FLOW_IN,
@@ skipping 22 matching lines @@
   if (m->dispatch_error())
     listener_->OnBadMessageReceived(*m);
 }
 
 ChannelReader::AttachmentIdSet ChannelReader::GetBrokeredAttachments(
     Message* msg) {
   std::set<BrokerableAttachment::AttachmentId> blocked_ids;
 
 #if USE_ATTACHMENT_BROKER
   MessageAttachmentSet* set = msg->attachment_set();
-  for (const scoped_refptr<BrokerableAttachment>& attachment :
-       set->GetBrokerableAttachmentsForUpdating()) {
+  std::vector<const BrokerableAttachment*> brokerable_attachments_copy =
+      set->PeekBrokerableAttachments();
+  for (const BrokerableAttachment* attachment : brokerable_attachments_copy) {
     if (attachment->NeedsBrokering()) {
       AttachmentBroker* broker = GetAttachmentBroker();
       scoped_refptr<BrokerableAttachment> brokered_attachment;
       bool result = broker->GetAttachmentWithId(attachment->GetIdentifier(),
                                                 &brokered_attachment);
       if (!result) {
         blocked_ids.insert(attachment->GetIdentifier());
         continue;
       }
 
-      attachment->PopulateWithAttachment(brokered_attachment.get());
+      set->ReplacePlaceholderWithAttachment(brokered_attachment);
     }
   }
 #endif  // USE_ATTACHMENT_BROKER
 
   return blocked_ids;
 }
 
 void ChannelReader::ReceivedBrokerableAttachmentWithId(
     const BrokerableAttachment::AttachmentId& id) {
   if (blocked_ids_.empty())
@@ skipping 16 matching lines @@
 }
 
 void ChannelReader::StopObservingAttachmentBroker() {
 #if USE_ATTACHMENT_BROKER
   GetAttachmentBroker()->RemoveObserver(this);
 #endif  // USE_ATTACHMENT_BROKER
 }
 
 }  // namespace internal
 }  // namespace IPC