Resize IPC input buffer to fit the next message.

ipc/ipc_channel_reader.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_CHANNEL_READER_H_
 #define IPC_IPC_CHANNEL_READER_H_
 
 #include <set>
 
 #include "base/gtest_prod_util.h"
@@ skipping 109 matching lines @@
 
   // Get the process ID for the sender of the message.
   virtual base::ProcessId GetSenderPID() = 0;
 
   // Whether the channel is an endpoint of attachment brokering.
   virtual bool IsAttachmentBrokerEndpoint() = 0;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ChannelReaderTest, AttachmentAlreadyBrokered);
   FRIEND_TEST_ALL_PREFIXES(ChannelReaderTest, AttachmentNotYetBrokered);
+  FRIEND_TEST_ALL_PREFIXES(ChannelReaderTest, ResizeOverflowBuffer);
+  FRIEND_TEST_ALL_PREFIXES(ChannelReaderTest, InvalidMessageSize);
 
   typedef std::set<BrokerableAttachment::AttachmentId> AttachmentIdSet;
 
   // Takes the given data received from the IPC channel, translates it into
   // Messages, and puts them in queued_messages_.
   // As an optimization, after a message is translated, the message is
   // immediately dispatched if able. This prevents an otherwise unnecessary deep
   // copy of the message which is needed to store the message in the message
   // queue.
   bool TranslateInputData(const char* input_data, int input_data_len);
 
   // Dispatches messages from queued_messages_ to listeners. Successfully
   // dispatched messages are removed from queued_messages_.
   DispatchState DispatchMessages();
 
   // Attempts to fill in the brokerable attachments of |msg| with information
   // from the Attachment Broker.
   // Returns the set of ids that are still waiting to be brokered.
   AttachmentIdSet GetBrokeredAttachments(Message* msg);
 
   // AttachmentBroker::Observer overrides.
   void ReceivedBrokerableAttachmentWithId(
       const BrokerableAttachment::AttachmentId& id) override;
 
   // This class should observe the attachment broker if and only if blocked_ids_
   // is not empty.
   void StartObservingAttachmentBroker();
   void StopObservingAttachmentBroker();
 
+  // Checks that |size| is a valid message size. Has side effects if it's not.

[jam, 2015/09/30 14:18:16]

nit: why does it need to mention an internal impl' detail of resetting the
buffer?

[Dmitry Skiba, 2015/09/30 15:32:35]

Well, the function is named 'Check', so personally I wouldn't expect it to have
side effects (although lack of const-ness gives a hint). And I couldn't come up
with a better verb. Naming is hard...

+  bool CheckMessageSize(size_t size);
+
   Listener* listener_;
 
   // We read from the pipe into this buffer. Managed by DispatchInputData, do
   // not access directly outside that function.
   char input_buf_[Channel::kReadBufferSize];
 
   // Large messages that span multiple pipe buffers, get built-up using
   // this buffer.
   std::string input_overflow_buf_;
 
   // These messages are waiting to be dispatched. If this vector is non-empty,
   // then the front Message must be blocked on receiving an attachment from the
   // AttachmentBroker.
   ScopedVector<Message> queued_messages_;
 
   // If the next message to be processed is blocked by the broker, then this
   // set contains the AttachmentIds that are needed to unblock the message.
   AttachmentIdSet blocked_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(ChannelReader);
 };
 
 }  // namespace internal
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_READER_H_