Improved memory usage while applying patch....

courgette/streams.h

 // Copyright (c) 2009 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.
 
 // Streams classes.
 //
 // These memory-resident streams are used for serialzing data into a sequential
 // region of memory.
 // Streams are divided into SourceStreams for reading and SinkStreams for
 // writing.  Streams are aggregated into Sets which allows several streams to be
@@ skipping 129 matching lines @@
   // Returns a pointer to contiguously allocated Length() bytes in the stream.
   // Writing to the stream invalidates the pointer.  The SinkStream continues to
   // own the memory.
   const uint8* Buffer() const {
     return reinterpret_cast<const uint8*>(buffer_.c_str());
   }
 
   // Hints that the stream will grow by an additional |length| bytes.
   void Reserve(size_t length) { buffer_.reserve(length + buffer_.length()); }
 
+  // Finished with this stream and any storage it has.
+  void Retire();
+
  private:
   std::string buffer_;  // Use a string to manage the stream's memory.
 
   DISALLOW_COPY_AND_ASSIGN(SinkStream);
 };
 
 // A SourceStreamSet is a set of SourceStreams.
 class SourceStreamSet {
  public:
   SourceStreamSet();
@@ skipping 20 matching lines @@
   // Returns 'true' if all streams are completely consumed.
   bool Empty() const;
 
  private:
   size_t count_;
   SourceStream streams_[kMaxStreams];
 
   DISALLOW_COPY_AND_ASSIGN(SourceStreamSet);
 };
 
+// A SinkStreamSet is a set of SinkStreams.  Data is collected by writing to the
+// component streams.  When data collection is complete, it is destructively
+// transferred, either by flattening into one stream (CopyTo), or transfering
+// data pairwise into another SinkStreamSet by calling that SinkStreamSet's
+// WriteSet method.
 class SinkStreamSet {
  public:
   SinkStreamSet();
   ~SinkStreamSet();
 
   // Initializes the SinkStreamSet to have |stream_index_limit| streams.  Must
   // be <= kMaxStreams.  If Init is not called the default is has kMaxStream.
   void Init(size_t stream_index_limit);
 
   // Returns a pointer to a substream.
   SinkStream* stream(size_t id) { return id < count_ ? &streams_[id] : NULL; }
 
-  // CopyTo serializes the streams in the SinkStreamSet into a single target
-  // stream or file.  The serialized format may be re-read by initializing a
+  // CopyTo serializes the streams in this SinkStreamSet into a single target
+  // stream.  The serialized format may be re-read by initializing a
   // SourceStreamSet with a buffer containing the data.
   bool CopyTo(SinkStream* combined_stream);
 
   // Writes the streams of |set| into the corresponding streams of |this|.
   // Stream zero first has some metadata written to it.  |set| becomes retired.
   // Partner to SourceStreamSet::ReadSet.
   bool WriteSet(SinkStreamSet* set);
 
  private:
   void CopyHeaderTo(SinkStream* stream);
 
   size_t count_;
   SinkStream streams_[kMaxStreams];
 
   DISALLOW_COPY_AND_ASSIGN(SinkStreamSet);
 };
 
 }  // namespace
 #endif  // COURGETTE_STREAMS_H_