OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "gpu/command_buffer/service/buffer_manager.h" | 5 #include "gpu/command_buffer/service/buffer_manager.h" |
6 #include <limits> | 6 #include <limits> |
7 #include "base/debug/trace_event.h" | 7 #include "base/debug/trace_event.h" |
8 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "gpu/command_buffer/common/gles2_cmd_utils.h" | 9 #include "gpu/command_buffer/common/gles2_cmd_utils.h" |
| 10 #include "gpu/command_buffer/service/feature_info.h" |
10 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" | 11 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" |
11 #include "gpu/command_buffer/service/memory_tracking.h" | 12 #include "gpu/command_buffer/service/memory_tracking.h" |
12 | 13 |
13 namespace gpu { | 14 namespace gpu { |
14 namespace gles2 { | 15 namespace gles2 { |
15 | 16 |
16 BufferManager::BufferManager(MemoryTracker* memory_tracker) | 17 BufferManager::BufferManager( |
| 18 MemoryTracker* memory_tracker, |
| 19 FeatureInfo* feature_info) |
17 : memory_tracker_( | 20 : memory_tracker_( |
18 new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)), | 21 new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)), |
| 22 feature_info_(feature_info), |
19 allow_buffers_on_multiple_targets_(false), | 23 allow_buffers_on_multiple_targets_(false), |
20 buffer_info_count_(0), | 24 buffer_info_count_(0), |
21 have_context_(true) { | 25 have_context_(true) { |
22 } | 26 } |
23 | 27 |
24 BufferManager::~BufferManager() { | 28 BufferManager::~BufferManager() { |
25 DCHECK(buffer_infos_.empty()); | 29 DCHECK(buffer_infos_.empty()); |
26 CHECK_EQ(buffer_info_count_, 0u); | 30 CHECK_EQ(buffer_info_count_, 0u); |
27 } | 31 } |
28 | 32 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
63 --buffer_info_count_; | 67 --buffer_info_count_; |
64 } | 68 } |
65 | 69 |
66 Buffer::Buffer(BufferManager* manager, GLuint service_id) | 70 Buffer::Buffer(BufferManager* manager, GLuint service_id) |
67 : manager_(manager), | 71 : manager_(manager), |
68 deleted_(false), | 72 deleted_(false), |
69 service_id_(service_id), | 73 service_id_(service_id), |
70 target_(0), | 74 target_(0), |
71 size_(0), | 75 size_(0), |
72 usage_(GL_STATIC_DRAW), | 76 usage_(GL_STATIC_DRAW), |
73 shadowed_(false) { | 77 shadowed_(false), |
| 78 is_client_side_array_(false) { |
74 manager_->StartTracking(this); | 79 manager_->StartTracking(this); |
75 } | 80 } |
76 | 81 |
77 Buffer::~Buffer() { | 82 Buffer::~Buffer() { |
78 if (manager_) { | 83 if (manager_) { |
79 if (manager_->have_context_) { | 84 if (manager_->have_context_) { |
80 GLuint id = service_id(); | 85 GLuint id = service_id(); |
81 glDeleteBuffersARB(1, &id); | 86 glDeleteBuffersARB(1, &id); |
82 } | 87 } |
83 manager_->StopTracking(this); | 88 manager_->StopTracking(this); |
84 manager_ = NULL; | 89 manager_ = NULL; |
85 } | 90 } |
86 } | 91 } |
87 | 92 |
88 void Buffer::SetInfo( | 93 void Buffer::SetInfo( |
89 GLsizeiptr size, GLenum usage, bool shadow) { | 94 GLsizeiptr size, GLenum usage, bool shadow, const GLvoid* data, |
| 95 bool is_client_side_array) { |
90 usage_ = usage; | 96 usage_ = usage; |
| 97 is_client_side_array_ = is_client_side_array; |
91 if (size != size_ || shadow != shadowed_) { | 98 if (size != size_ || shadow != shadowed_) { |
92 shadowed_ = shadow; | 99 shadowed_ = shadow; |
93 size_ = size; | 100 size_ = size; |
94 ClearCache(); | 101 ClearCache(); |
95 if (shadowed_) { | 102 if (shadowed_) { |
96 shadow_.reset(new int8[size]); | 103 shadow_.reset(new int8[size]); |
97 memset(shadow_.get(), 0, size); | 104 if (!data) { |
| 105 memset(shadow_.get(), 0, size); |
| 106 } |
| 107 } else { |
| 108 shadow_.reset(); |
98 } | 109 } |
99 } | 110 } |
| 111 if (shadowed_ && data) { |
| 112 memcpy(shadow_.get(), data, size); |
| 113 } |
100 } | 114 } |
101 | 115 |
102 bool Buffer::CheckRange( | 116 bool Buffer::CheckRange( |
103 GLintptr offset, GLsizeiptr size) const { | 117 GLintptr offset, GLsizeiptr size) const { |
104 int32 end = 0; | 118 int32 end = 0; |
105 return offset >= 0 && size >= 0 && | 119 return offset >= 0 && size >= 0 && |
106 offset <= std::numeric_limits<int32>::max() && | 120 offset <= std::numeric_limits<int32>::max() && |
107 size <= std::numeric_limits<int32>::max() && | 121 size <= std::numeric_limits<int32>::max() && |
108 SafeAddInt32(offset, size, &end) && end <= size_; | 122 SafeAddInt32(offset, size, &end) && end <= size_; |
109 } | 123 } |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
211 it != buffer_infos_.end(); ++it) { | 225 it != buffer_infos_.end(); ++it) { |
212 if (it->second->service_id() == service_id) { | 226 if (it->second->service_id() == service_id) { |
213 *client_id = it->first; | 227 *client_id = it->first; |
214 return true; | 228 return true; |
215 } | 229 } |
216 } | 230 } |
217 return false; | 231 return false; |
218 } | 232 } |
219 | 233 |
220 void BufferManager::SetInfo( | 234 void BufferManager::SetInfo( |
221 Buffer* info, GLsizeiptr size, GLenum usage) { | 235 Buffer* info, GLsizeiptr size, GLenum usage, const GLvoid* data) { |
222 DCHECK(info); | 236 DCHECK(info); |
223 memory_tracker_->TrackMemFree(info->size()); | 237 memory_tracker_->TrackMemFree(info->size()); |
224 info->SetInfo(size, | 238 bool is_client_side_array = |
225 usage, | 239 (usage == GL_STREAM_DRAW && |
226 info->target() == GL_ELEMENT_ARRAY_BUFFER || | 240 feature_info_->workarounds().use_client_side_arrays_for_stream_buffers); |
227 allow_buffers_on_multiple_targets_); | 241 bool shadow = info->target() == GL_ELEMENT_ARRAY_BUFFER || |
| 242 allow_buffers_on_multiple_targets_ || |
| 243 is_client_side_array; |
| 244 info->SetInfo(size, usage, shadow, data, is_client_side_array); |
228 memory_tracker_->TrackMemAlloc(info->size()); | 245 memory_tracker_->TrackMemAlloc(info->size()); |
229 } | 246 } |
230 | 247 |
231 bool BufferManager::SetTarget(Buffer* info, GLenum target) { | 248 bool BufferManager::SetTarget(Buffer* info, GLenum target) { |
232 // Check that we are not trying to bind it to a different target. | 249 // Check that we are not trying to bind it to a different target. |
233 if (info->target() != 0 && info->target() != target && | 250 if (info->target() != 0 && info->target() != target && |
234 !allow_buffers_on_multiple_targets_) { | 251 !allow_buffers_on_multiple_targets_) { |
235 return false; | 252 return false; |
236 } | 253 } |
237 if (info->target() == 0) { | 254 if (info->target() == 0) { |
238 info->set_target(target); | 255 info->set_target(target); |
239 } | 256 } |
240 return true; | 257 return true; |
241 } | 258 } |
242 | 259 |
243 } // namespace gles2 | 260 } // namespace gles2 |
244 } // namespace gpu | 261 } // namespace gpu |
245 | 262 |
246 | 263 |
OLD | NEW |