1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef NET_BASE_IO_BUFFER_H_ 6 #define NET_BASE_IO_BUFFER_H_ 7 #pragma once 8 9 #include <string> 10 11 #include "base/memory/ref_counted.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/pickle.h" 14 #include "net/base/net_export.h" 15 16 namespace net { 17 18 // This is a simple wrapper around a buffer that provides ref counting for 19 // easier asynchronous IO handling. 20 class NET_EXPORT IOBuffer : public base::RefCountedThreadSafe<IOBuffer> { 21 public: 22 IOBuffer(); 23 explicit IOBuffer(int buffer_size); 24 data()25 char* data() { return data_; } 26 27 protected: 28 friend class base::RefCountedThreadSafe<IOBuffer>; 29 30 // Only allow derived classes to specify data_. 31 // In all other cases, we own data_, and must delete it at destruction time. 32 explicit IOBuffer(char* data); 33 34 virtual ~IOBuffer(); 35 36 char* data_; 37 }; 38 39 // This version stores the size of the buffer so that the creator of the object 40 // doesn't have to keep track of that value. 41 // NOTE: This doesn't mean that we want to stop sending the size as an explicit 42 // argument to IO functions. Please keep using IOBuffer* for API declarations. 43 class NET_EXPORT IOBufferWithSize : public IOBuffer { 44 public: 45 explicit IOBufferWithSize(int size); 46 size()47 int size() const { return size_; } 48 49 private: 50 virtual ~IOBufferWithSize(); 51 52 int size_; 53 }; 54 55 // This is a read only IOBuffer. The data is stored in a string and 56 // the IOBuffer interface does not provide a proper way to modify it. 57 class NET_EXPORT StringIOBuffer : public IOBuffer { 58 public: 59 explicit StringIOBuffer(const std::string& s); 60 size()61 int size() const { return string_data_.size(); } 62 63 private: 64 virtual ~StringIOBuffer(); 65 66 std::string string_data_; 67 }; 68 69 // This version wraps an existing IOBuffer and provides convenient functions 70 // to progressively read all the data. 71 class NET_EXPORT DrainableIOBuffer : public IOBuffer { 72 public: 73 DrainableIOBuffer(IOBuffer* base, int size); 74 75 // DidConsume() changes the |data_| pointer so that |data_| always points 76 // to the first unconsumed byte. 77 void DidConsume(int bytes); 78 79 // Returns the number of unconsumed bytes. 80 int BytesRemaining() const; 81 82 // Returns the number of consumed bytes. 83 int BytesConsumed() const; 84 85 // Seeks to an arbitrary point in the buffer. The notion of bytes consumed 86 // and remaining are updated appropriately. 87 void SetOffset(int bytes); 88 size()89 int size() const { return size_; } 90 91 private: 92 virtual ~DrainableIOBuffer(); 93 94 scoped_refptr<IOBuffer> base_; 95 int size_; 96 int used_; 97 }; 98 99 // This version provides a resizable buffer and a changeable offset. 100 class NET_EXPORT GrowableIOBuffer : public IOBuffer { 101 public: 102 GrowableIOBuffer(); 103 104 // realloc memory to the specified capacity. 105 void SetCapacity(int capacity); capacity()106 int capacity() { return capacity_; } 107 108 // |offset| moves the |data_| pointer, allowing "seeking" in the data. 109 void set_offset(int offset); offset()110 int offset() { return offset_; } 111 112 int RemainingCapacity(); 113 char* StartOfBuffer(); 114 115 private: 116 virtual ~GrowableIOBuffer(); 117 118 scoped_ptr_malloc<char> real_data_; 119 int capacity_; 120 int offset_; 121 }; 122 123 // This versions allows a pickle to be used as the storage for a write-style 124 // operation, avoiding an extra data copy. 125 class NET_EXPORT PickledIOBuffer : public IOBuffer { 126 public: 127 PickledIOBuffer(); 128 pickle()129 Pickle* pickle() { return &pickle_; } 130 131 // Signals that we are done writing to the picke and we can use it for a 132 // write-style IO operation. 133 void Done(); 134 135 private: 136 virtual ~PickledIOBuffer(); 137 138 Pickle pickle_; 139 }; 140 141 // This class allows the creation of a temporary IOBuffer that doesn't really 142 // own the underlying buffer. Please use this class only as a last resort. 143 // A good example is the buffer for a synchronous operation, where we can be 144 // sure that nobody is keeping an extra reference to this object so the lifetime 145 // of the buffer can be completely managed by its intended owner. 146 class NET_EXPORT WrappedIOBuffer : public IOBuffer { 147 public: 148 explicit WrappedIOBuffer(const char* data); 149 150 protected: 151 virtual ~WrappedIOBuffer(); 152 }; 153 154 } // namespace net 155 156 #endif // NET_BASE_IO_BUFFER_H_ 157