Revert 186416

gpu/command_buffer/service/buffer_manager.cc

 // Copyright (c) 2012 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.
 
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include <limits>
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
-#include "ui/gl/gl_bindings.h"
 
 namespace gpu {
 namespace gles2 {
 
-BufferManager::BufferManager(
-    MemoryTracker* memory_tracker,
-    FeatureInfo* feature_info)
+BufferManager::BufferManager(MemoryTracker* memory_tracker)
     : memory_tracker_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
-      feature_info_(feature_info),
       allow_buffers_on_multiple_targets_(false),
       buffer_info_count_(0),
-      have_context_(true),
-      use_client_side_arrays_for_stream_buffers_(
-          feature_info ? feature_info->workarounds(
-              ).use_client_side_arrays_for_stream_buffers : 0) {
+      have_context_(true) {
 }
 
 BufferManager::~BufferManager() {
   DCHECK(buffer_infos_.empty());
   CHECK_EQ(buffer_info_count_, 0u);
 }
 
 void BufferManager::Destroy(bool have_context) {
   have_context_ = have_context;
   buffer_infos_.clear();
@@ skipping 31 matching lines @@
   --buffer_info_count_;
 }
 
 Buffer::Buffer(BufferManager* manager, GLuint service_id)
     : manager_(manager),
       deleted_(false),
       service_id_(service_id),
       target_(0),
       size_(0),
       usage_(GL_STATIC_DRAW),
-      shadowed_(false),
-      is_client_side_array_(false) {
+      shadowed_(false) {
   manager_->StartTracking(this);
 }
 
 Buffer::~Buffer() {
   if (manager_) {
     if (manager_->have_context_) {
       GLuint id = service_id();
       glDeleteBuffersARB(1, &id);
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 void Buffer::SetInfo(
-    GLsizeiptr size, GLenum usage, bool shadow, const GLvoid* data,
-    bool is_client_side_array) {
+    GLsizeiptr size, GLenum usage, bool shadow) {
   usage_ = usage;
-  is_client_side_array_ = is_client_side_array;
   if (size != size_ || shadow != shadowed_) {
     shadowed_ = shadow;
     size_ = size;
     ClearCache();
     if (shadowed_) {
       shadow_.reset(new int8[size]);
-    } else {
-      shadow_.reset();
-    }
-  }
-  if (shadowed_) {
-    if (data) {
-      memcpy(shadow_.get(), data, size);
-    } else {
       memset(shadow_.get(), 0, size);
     }
   }
 }
 
 bool Buffer::CheckRange(
     GLintptr offset, GLsizeiptr size) const {
   int32 end = 0;
   return offset >= 0 && size >= 0 &&
          offset <= std::numeric_limits<int32>::max() &&
@@ skipping 103 matching lines @@
   for (BufferInfoMap::const_iterator it = buffer_infos_.begin();
        it != buffer_infos_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
   }
   return false;
 }
 
-bool BufferManager::IsUsageClientSideArray(GLenum usage) {
-  return usage == GL_STREAM_DRAW && use_client_side_arrays_for_stream_buffers_;
-}
-
 void BufferManager::SetInfo(
-    Buffer* info, GLsizeiptr size, GLenum usage, const GLvoid* data) {
+    Buffer* info, GLsizeiptr size, GLenum usage) {
   DCHECK(info);
   memory_tracker_->TrackMemFree(info->size());
-  bool is_client_side_array = IsUsageClientSideArray(usage);
-  bool shadow = info->target() == GL_ELEMENT_ARRAY_BUFFER ||
-                allow_buffers_on_multiple_targets_ ||
-                is_client_side_array;
-  info->SetInfo(size, usage, shadow, data, is_client_side_array);
+  info->SetInfo(size,
+                usage,
+                info->target() == GL_ELEMENT_ARRAY_BUFFER ||
+                allow_buffers_on_multiple_targets_);
   memory_tracker_->TrackMemAlloc(info->size());
 }
 
-void BufferManager::DoBufferData(
-    GLES2Decoder* decoder,
-    Buffer* buffer,
-    GLsizeiptr size,
-    GLenum usage,
-    const GLvoid* data) {
-  // Clear the buffer to 0 if no initial data was passed in.
-  scoped_array<int8> zero;
-  if (!data) {
-    zero.reset(new int8[size]);
-    memset(zero.get(), 0, size);
-    data = zero.get();
-  }
-
-  decoder->CopyRealGLErrorsToWrapper();
-  if (IsUsageClientSideArray(usage)) {
-    glBufferData(buffer->target(), 0, NULL, usage);
-  } else {
-    glBufferData(buffer->target(), size, data, usage);
-  }
-  GLenum error = decoder->PeekGLError();
-  if (error == GL_NO_ERROR) {
-    SetInfo(buffer, size, usage, data);
-  } else {
-    SetInfo(buffer, 0, usage, NULL);
-  }
-}
-
-void BufferManager::DoBufferSubData(
-    GLES2Decoder* decoder,
-    Buffer* buffer,
-    GLintptr offset,
-    GLsizeiptr size,
-    const GLvoid* data) {
-  if (!buffer->SetRange(offset, size, data)) {
-    decoder->SetGLError(GL_INVALID_VALUE, "glBufferSubData", "out of range");
-    return;
-  }
-
-  if (!buffer->IsClientSideArray()) {
-    glBufferSubData(buffer->target(), offset, size, data);
-  }
-}
-
 bool BufferManager::SetTarget(Buffer* info, GLenum target) {
   // Check that we are not trying to bind it to a different target.
   if (info->target() != 0 && info->target() != target &&
       !allow_buffers_on_multiple_targets_) {
     return false;
   }
   if (info->target() == 0) {
     info->set_target(target);
   }
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu