Switch out use of std::string and std::vector for large allocations for a buffer class that doesn...

courgette/streams.h

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
 // Streams classes.
 //
 // These memory-resident streams are used for serializing 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
 // used at once.  Example: we can write A1, B1, A2, B2 but achieve the memory
@@ skipping 102 matching lines @@
 // initially in an 'accumulating' state where writes are permitted.  Accessing
 // the buffer moves the stream into a 'locked' state where no more writes are
 // permitted.  The stream may also be in a 'retired' state where the buffer
 // contents are no longer available.
 class SinkStream {
  public:
   SinkStream() {}
   ~SinkStream() {}
 
   // Appends |byte_count| bytes from |data| to the stream.
-  CheckBool Write(const void* data, size_t byte_count);
+  CheckBool Write(const void* data, size_t byte_count) WARN_UNUSED_RESULT;
 
   // Appends the 'varint32' encoding of |value| to the stream.
-  CheckBool WriteVarint32(uint32 value);
+  CheckBool WriteVarint32(uint32 value) WARN_UNUSED_RESULT;
 
   // Appends the 'varint32' encoding of |value| to the stream.
-  CheckBool WriteVarint32Signed(int32 value);
+  CheckBool WriteVarint32Signed(int32 value) WARN_UNUSED_RESULT;
 
   // Appends the 'varint32' encoding of |value| to the stream.
   // On platforms where sizeof(size_t) != sizeof(int32), do a safety check.
-  CheckBool WriteSizeVarint32(size_t value);
+  CheckBool WriteSizeVarint32(size_t value) WARN_UNUSED_RESULT;
 
   // Contents of |other| are appended to |this| stream.  The |other| stream
   // becomes retired.
-  CheckBool Append(SinkStream* other);
+  CheckBool Append(SinkStream* other) WARN_UNUSED_RESULT;
 
   // Returns the number of bytes in this SinkStream
   size_t Length() const { return buffer_.size(); }
 
   // 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());
+    return reinterpret_cast<const uint8*>(buffer_.data());
   }
 
   // Hints that the stream will grow by an additional |length| bytes.
   // Caller must be prepared to handle memory allocation problems.
-  CheckBool Reserve(size_t length) {
-    buffer_.reserve(length + buffer_.length());
-    //TODO(tommi): return false when allocation fails.
-    return true;
+  CheckBool Reserve(size_t length) WARN_UNUSED_RESULT {
+    return buffer_.reserve(length + buffer_.size());
   }
 
   // Finished with this stream and any storage it has.
   void Retire();
 
  private:
-  // Use a string to manage the stream's memory.
-  typedef std::basic_string<char,
-                            std::char_traits<char>,
-                            MemoryAllocator<char> > SinkBuffer;
-  SinkBuffer buffer_;
+  NoThrowBuffer<char> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(SinkStream);
 };
 
 // A SourceStreamSet is a set of SourceStreams.
 class SourceStreamSet {
  public:
   SourceStreamSet();
   ~SourceStreamSet();
 
@@ skipping 38 matching lines @@
   // 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 this SinkStreamSet into a single target
   // stream.  The serialized format may be re-read by initializing a
   // SourceStreamSet with a buffer containing the data.
-  CheckBool CopyTo(SinkStream* combined_stream);
+  CheckBool CopyTo(SinkStream* combined_stream) WARN_UNUSED_RESULT;
 
   // 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.
-  CheckBool WriteSet(SinkStreamSet* set);
+  CheckBool WriteSet(SinkStreamSet* set) WARN_UNUSED_RESULT;
 
  private:
-  CheckBool CopyHeaderTo(SinkStream* stream);
+  CheckBool CopyHeaderTo(SinkStream* stream) WARN_UNUSED_RESULT;
 
   size_t count_;
   SinkStream streams_[kMaxStreams];
 
   DISALLOW_COPY_AND_ASSIGN(SinkStreamSet);
 };
 
 }  // namespace
 #endif  // COURGETTE_STREAMS_H_