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 #include "net/base/io_buffer.h" 6 7 #include "base/logging.h" 8 9 namespace net { 10 11 IOBuffer::IOBuffer() 12 : data_(NULL) { 13 } 14 15 IOBuffer::IOBuffer(int buffer_size) { 16 CHECK_GE(buffer_size, 0); 17 data_ = new char[buffer_size]; 18 } 19 20 IOBuffer::IOBuffer(char* data) 21 : data_(data) { 22 } 23 24 IOBuffer::~IOBuffer() { 25 delete[] data_; 26 data_ = NULL; 27 } 28 29 IOBufferWithSize::IOBufferWithSize(int size) 30 : IOBuffer(size), 31 size_(size) { 32 } 33 34 IOBufferWithSize::IOBufferWithSize(char* data, int size) 35 : IOBuffer(data), 36 size_(size) { 37 } 38 39 IOBufferWithSize::~IOBufferWithSize() { 40 } 41 42 StringIOBuffer::StringIOBuffer(const std::string& s) 43 : IOBuffer(static_cast<char*>(NULL)), 44 string_data_(s) { 45 CHECK_LT(s.size(), static_cast<size_t>(INT_MAX)); 46 data_ = const_cast<char*>(string_data_.data()); 47 } 48 49 StringIOBuffer::StringIOBuffer(scoped_ptr<std::string> s) 50 : IOBuffer(static_cast<char*>(NULL)) { 51 CHECK_LT(s->size(), static_cast<size_t>(INT_MAX)); 52 string_data_.swap(*s.get()); 53 data_ = const_cast<char*>(string_data_.data()); 54 } 55 56 StringIOBuffer::~StringIOBuffer() { 57 // We haven't allocated the buffer, so remove it before the base class 58 // destructor tries to delete[] it. 59 data_ = NULL; 60 } 61 62 DrainableIOBuffer::DrainableIOBuffer(IOBuffer* base, int size) 63 : IOBuffer(base->data()), 64 base_(base), 65 size_(size), 66 used_(0) { 67 } 68 69 void DrainableIOBuffer::DidConsume(int bytes) { 70 SetOffset(used_ + bytes); 71 } 72 73 int DrainableIOBuffer::BytesRemaining() const { 74 return size_ - used_; 75 } 76 77 // Returns the number of consumed bytes. 78 int DrainableIOBuffer::BytesConsumed() const { 79 return used_; 80 } 81 82 void DrainableIOBuffer::SetOffset(int bytes) { 83 DCHECK_GE(bytes, 0); 84 DCHECK_LE(bytes, size_); 85 used_ = bytes; 86 data_ = base_->data() + used_; 87 } 88 89 DrainableIOBuffer::~DrainableIOBuffer() { 90 // The buffer is owned by the |base_| instance. 91 data_ = NULL; 92 } 93 94 GrowableIOBuffer::GrowableIOBuffer() 95 : IOBuffer(), 96 capacity_(0), 97 offset_(0) { 98 } 99 100 void GrowableIOBuffer::SetCapacity(int capacity) { 101 DCHECK_GE(capacity, 0); 102 // realloc will crash if it fails. 103 real_data_.reset(static_cast<char*>(realloc(real_data_.release(), capacity))); 104 capacity_ = capacity; 105 if (offset_ > capacity) 106 set_offset(capacity); 107 else 108 set_offset(offset_); // The pointer may have changed. 109 } 110 111 void GrowableIOBuffer::set_offset(int offset) { 112 DCHECK_GE(offset, 0); 113 DCHECK_LE(offset, capacity_); 114 offset_ = offset; 115 data_ = real_data_.get() + offset; 116 } 117 118 int GrowableIOBuffer::RemainingCapacity() { 119 return capacity_ - offset_; 120 } 121 122 char* GrowableIOBuffer::StartOfBuffer() { 123 return real_data_.get(); 124 } 125 126 GrowableIOBuffer::~GrowableIOBuffer() { 127 data_ = NULL; 128 } 129 130 PickledIOBuffer::PickledIOBuffer() : IOBuffer() {} 131 132 void PickledIOBuffer::Done() { 133 data_ = const_cast<char*>(static_cast<const char*>(pickle_.data())); 134 } 135 136 PickledIOBuffer::~PickledIOBuffer() { data_ = NULL; } 137 138 WrappedIOBuffer::WrappedIOBuffer(const char* data) 139 : IOBuffer(const_cast<char*>(data)) { 140 } 141 142 WrappedIOBuffer::~WrappedIOBuffer() { 143 data_ = NULL; 144 } 145 146 } // namespace net 147