Update shadowed data in MapBufferRange path.

gpu/command_buffer/service/buffer_manager.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_BUFFER_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_BUFFER_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 20 matching lines @@
 class TestHelper;
 
 // Info about Buffers currently in the system.
 class GPU_EXPORT Buffer : public base::RefCounted<Buffer> {
  public:
   struct MappedRange {
     GLintptr offset;
     GLsizeiptr size;
     GLenum access;
     void* pointer;  // Pointer returned by driver.
-    scoped_refptr<gpu::Buffer> shm;  // Client side mem.
+    scoped_refptr<gpu::Buffer> shm;  // Client side mem buffer.
+    unsigned int shm_offset;  // Client side mem buffer offset.
 
-    MappedRange(GLintptr offset, GLsizeiptr size, GLenum access,
-                void* pointer, scoped_refptr<gpu::Buffer> shm);
+    MappedRange(GLintptr offset, GLsizeiptr size, GLenum access, void* pointer,
+                scoped_refptr<gpu::Buffer> shm, unsigned int shm_offset);
     ~MappedRange();
     void* GetShmPointer() const;
   };
 
   Buffer(BufferManager* manager, GLuint service_id);
 
   GLuint service_id() const {
     return service_id_;
   }
 
   GLsizeiptr size() const {
     return size_;
   }
 
   GLenum usage() const {
     return usage_;
   }
 
+  bool shadowed() const {
+    return !shadow_.empty();
+  }
+
   // Gets the maximum value in the buffer for the given range interpreted as
   // the given type. Returns false if offset and count are out of range.
   // offset is in bytes.
   // count is in elements of type.
   bool GetMaxValueForRange(GLuint offset, GLsizei count, GLenum type,
                            bool primitive_restart_enabled, GLuint* max_value);
 
   // Returns a pointer to shadowed data.
   const void* GetRange(GLintptr offset, GLsizeiptr size) const;
 
   // Check if an offset, size range is valid for the current buffer.
   bool CheckRange(GLintptr offset, GLsizeiptr size) const;
 
+  // Sets a range of this buffer's shadowed data. Returns false if offset/size
+  // is out of range.
+  bool SetRange(GLintptr offset, GLsizeiptr size, const GLvoid * data);
+
   bool IsDeleted() const {
     return deleted_;
   }
 
   bool IsValid() const {
     return initial_target() && !IsDeleted();
   }
 
   bool IsClientSideArray() const {
     return is_client_side_array_;
   }
 
   void SetMappedRange(GLintptr offset, GLsizeiptr size, GLenum access,
-                      void* pointer, scoped_refptr<gpu::Buffer> shm) {
-    mapped_range_.reset(new MappedRange(offset, size, access, pointer, shm));
+                      void* pointer, scoped_refptr<gpu::Buffer> shm,
+                      unsigned int shm_offset) {
+    mapped_range_.reset(
+        new MappedRange(offset, size, access, pointer, shm, shm_offset));
   }
 
   void RemoveMappedRange() {
     mapped_range_.reset(nullptr);
   }
 
   const MappedRange* GetMappedRange() const {
     return mapped_range_.get();
   }
 
@@ skipping 40 matching lines @@
 
   GLenum initial_target() const {
     return initial_target_;
   }
 
   void set_initial_target(GLenum target) {
     DCHECK_EQ(0u, initial_target_);
     initial_target_ = target;
   }
 
-  bool shadowed() const { return !shadow_.empty(); }
-
   void MarkAsDeleted() {
     deleted_ = true;
   }
 
   // Setup the shadow buffer. This will either initialize the shadow buffer
   // with the passed data or clear the shadow buffer if no shadow required. This
   // will return a pointer to the shadowed data if using shadow, otherwise will
   // return the original data pointer.
   const GLvoid* StageShadow(bool use_shadow,
                             GLsizeiptr size,
                             const GLvoid* data);
 
   // Sets the size, usage and initial data of a buffer.
   // If shadow is true then if data is NULL buffer will be initialized to 0.
   void SetInfo(GLsizeiptr size,
                GLenum usage,
                bool use_shadow,
                bool is_client_side_array);
 
-  // Sets a range of data for this buffer. Returns false if the offset or size
-  // is out of range.
-  bool SetRange(
-    GLintptr offset, GLsizeiptr size, const GLvoid * data);
-
   // Clears any cache of index ranges.
   void ClearCache();
 
   // The manager that owns this Buffer.
   BufferManager* manager_;
 
   // A copy of the data in the buffer. This data is only kept if the conditions
   // checked in UseShadowBuffer() are true.
   std::vector<uint8_t> shadow_;
 
@@ skipping 192 matching lines @@
   bool lost_context_;
   bool use_client_side_arrays_for_stream_buffers_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferManager);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_BUFFER_MANAGER_H_