Handle out of memory in GrowableIOBuffer more gracefully....

net/base/io_buffer.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.
 
 #ifndef NET_BASE_IO_BUFFER_H_
 #define NET_BASE_IO_BUFFER_H_
 
 #include <string>
 
 #include "base/ref_counted.h"
@@ skipping 88 matching lines @@
   int size_;
   int used_;
 };
 
 // This version provides a resizable buffer and a changeable offset.
 class GrowableIOBuffer : public IOBuffer {
  public:
   GrowableIOBuffer() : IOBuffer(), capacity_(0), offset_(0) {}
   ~GrowableIOBuffer() { data_ = NULL; }
 
+
+  // realloc memory to the specified capacity.  On failure, the capacity

[wtc, 2009/10/27 22:42:10]

You need to document that true means success and false means
failure.

+  // and buffer are unchanged.
+  bool SetCapacity(int capacity);
   int capacity() { return capacity_; }
-  void set_capacity(int capacity);
 
   // |offset| moves the |data_| pointer, allowing "seeking" in the data.
+  void set_offset(int offset);
   int offset() { return offset_; }
-  void set_offset(int offset);
 
   int RemainingCapacity() { return capacity_ - offset_; }
   char* StartOfBuffer() { return real_data_.get(); }
 
  private:
   scoped_ptr_malloc<char> real_data_;
   int capacity_;
   int offset_;
 };
 
 // This class allows the creation of a temporary IOBuffer that doesn't really
 // own the underlying buffer. Please use this class only as a last resort.
 // A good example is the buffer for a synchronous operation, where we can be
 // sure that nobody is keeping an extra reference to this object so the lifetime
 // of the buffer can be completely managed by its intended owner.
 class WrappedIOBuffer : public IOBuffer {
  public:
   explicit WrappedIOBuffer(const char* data)
       : IOBuffer(const_cast<char*>(data)) {}
   ~WrappedIOBuffer() {
     data_ = NULL;
   }
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_IO_BUFFER_H_