OLD | NEW |
1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/base/upload_data_stream.h" | 5 #include "net/base/upload_data_stream.h" |
6 | 6 |
7 #include "base/file_util.h" | 7 #include "base/file_util.h" |
8 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "net/base/file_stream.h" | 9 #include "net/base/file_stream.h" |
10 #include "net/base/io_buffer.h" | 10 #include "net/base/io_buffer.h" |
11 #include "net/base/net_errors.h" | 11 #include "net/base/net_errors.h" |
12 | 12 |
13 namespace net { | 13 namespace net { |
14 | 14 |
| 15 bool UploadDataStream::merge_chunks_ = true; |
| 16 |
15 UploadDataStream::~UploadDataStream() { | 17 UploadDataStream::~UploadDataStream() { |
16 } | 18 } |
17 | 19 |
18 UploadDataStream* UploadDataStream::Create(UploadData* data, int* error_code) { | 20 UploadDataStream* UploadDataStream::Create(UploadData* data, int* error_code) { |
19 scoped_ptr<UploadDataStream> stream(new UploadDataStream(data)); | 21 scoped_ptr<UploadDataStream> stream(new UploadDataStream(data)); |
20 int rv = stream->FillBuf(); | 22 int rv = stream->FillBuf(); |
21 if (error_code) | 23 if (error_code) |
22 *error_code = rv; | 24 *error_code = rv; |
23 if (rv != OK) | 25 if (rv != OK) |
24 return NULL; | 26 return NULL; |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
62 UploadData::Element& element = elements[next_element_]; | 64 UploadData::Element& element = elements[next_element_]; |
63 | 65 |
64 size_t size_remaining = kBufSize - buf_len_; | 66 size_t size_remaining = kBufSize - buf_len_; |
65 if (element.type() == UploadData::TYPE_BYTES || | 67 if (element.type() == UploadData::TYPE_BYTES || |
66 element.type() == UploadData::TYPE_CHUNK) { | 68 element.type() == UploadData::TYPE_CHUNK) { |
67 const std::vector<char>& d = element.bytes(); | 69 const std::vector<char>& d = element.bytes(); |
68 size_t count = d.size() - next_element_offset_; | 70 size_t count = d.size() - next_element_offset_; |
69 | 71 |
70 size_t bytes_copied = std::min(count, size_remaining); | 72 size_t bytes_copied = std::min(count, size_remaining); |
71 | 73 |
72 memcpy(buf_->data() + buf_len_, &d[next_element_offset_], bytes_copied); | 74 // Check if we have anything to copy first, because we are getting the |
73 buf_len_ += bytes_copied; | 75 // address of an element in |d| and that will throw an exception if |d| |
| 76 // is an empty vector. |
| 77 if (bytes_copied) { |
| 78 memcpy(buf_->data() + buf_len_, &d[next_element_offset_], bytes_copied); |
| 79 buf_len_ += bytes_copied; |
| 80 } |
74 | 81 |
75 if (bytes_copied == count) { | 82 if (bytes_copied == count) { |
76 advance_to_next_element = true; | 83 advance_to_next_element = true; |
77 } else { | 84 } else { |
78 next_element_offset_ += bytes_copied; | 85 next_element_offset_ += bytes_copied; |
79 } | 86 } |
80 } else { | 87 } else { |
81 DCHECK(element.type() == UploadData::TYPE_FILE); | 88 DCHECK(element.type() == UploadData::TYPE_FILE); |
82 | 89 |
83 if (!next_element_remaining_) { | 90 if (!next_element_remaining_) { |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
119 next_element_remaining_ -= rv; | 126 next_element_remaining_ -= rv; |
120 } | 127 } |
121 } | 128 } |
122 | 129 |
123 if (advance_to_next_element) { | 130 if (advance_to_next_element) { |
124 ++next_element_; | 131 ++next_element_; |
125 next_element_offset_ = 0; | 132 next_element_offset_ = 0; |
126 next_element_remaining_ = 0; | 133 next_element_remaining_ = 0; |
127 next_element_stream_.reset(); | 134 next_element_stream_.reset(); |
128 } | 135 } |
| 136 |
| 137 if (is_chunked() && !merge_chunks_) |
| 138 break; |
129 } | 139 } |
130 | 140 |
131 if (next_element_ == elements.size() && !buf_len_) { | 141 if (next_element_ == elements.size() && !buf_len_) { |
132 if (!data_->is_chunked() || | 142 if (!data_->is_chunked() || |
133 (!elements.empty() && elements.back().is_last_chunk())) { | 143 (!elements.empty() && elements.back().is_last_chunk())) { |
134 eof_ = true; | 144 eof_ = true; |
135 } | 145 } |
136 } | 146 } |
137 | 147 |
138 return OK; | 148 return OK; |
139 } | 149 } |
140 | 150 |
| 151 bool UploadDataStream::IsOnLastChunk() const { |
| 152 const std::vector<UploadData::Element>& elements = *data_->elements(); |
| 153 DCHECK(data_->is_chunked()); |
| 154 return (eof_ || |
| 155 (!elements.empty() && |
| 156 next_element_ == elements.size() && |
| 157 elements.back().is_last_chunk())); |
| 158 } |
| 159 |
141 } // namespace net | 160 } // namespace net |
OLD | NEW |