Update from https://crrev.com/320343

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 <map>
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "gpu/command_buffer/common/buffer.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/gpu_export.h"
 
 namespace gpu {
 namespace gles2 {
 
 class BufferManager;
 struct ContextState;
 class ErrorState;
 class FeatureInfo;
 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.
+
+    MappedRange(GLintptr offset, GLsizeiptr size, GLenum access,
+                void* pointer, scoped_refptr<gpu::Buffer> shm);
+    ~MappedRange();
+    void* GetShmPointer() const;
+  };
+
   Buffer(BufferManager* manager, GLuint service_id);
 
   GLuint service_id() const {
     return service_id_;
   }
 
   GLenum target() const {
     return target_;
   }
 
@@ skipping 20 matching lines @@
   }
 
   bool IsValid() const {
     return 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 RemoveMappedRange() {
+    mapped_range_.reset(nullptr);
+  }
+
+  const MappedRange* GetMappedRange() const {
+    return mapped_range_.get();
+  }
+
  private:
   friend class BufferManager;
   friend class BufferManagerTestBase;
   friend class base::RefCounted<Buffer>;
 
   // Represents a range in a buffer.
   class Range {
    public:
     Range(GLuint offset, GLsizei count, GLenum type)
         : offset_(offset),
@@ skipping 76 matching lines @@
   GLuint service_id_;
 
   // The type of buffer. 0 = unset, GL_BUFFER_ARRAY = vertex data,
   // GL_ELEMENT_BUFFER_ARRAY = index data.
   // Once set a buffer can not be used for something else.
   GLenum target_;
 
   // Usage of buffer.
   GLenum usage_;
 
+  // Data cached from last glMapBufferRange call.
+  scoped_ptr<MappedRange> mapped_range_;
+
   // A map of ranges to the highest value in that range of a certain type.
   typedef std::map<Range, GLuint, Range::Less> RangeToMaxValueMap;
   RangeToMaxValueMap range_set_;
 };
 
 // This class keeps track of the buffers and their sizes so we can do
 // bounds checking.
 //
 // NOTE: To support shared resources an instance of this class will need to be
 // shared by multiple GLES2Decoders.
@@ skipping 49 matching lines @@
     return memory_tracker_->GetMemRepresented();
   }
 
   // Tells for a given usage if this would be a client side array.
   bool IsUsageClientSideArray(GLenum usage);
 
   // Tells whether a buffer that is emulated using client-side arrays should be
   // set to a non-zero size.
   bool UseNonZeroSizeForClientSideArrayBuffer();
 
+  Buffer* GetBufferInfoForTarget(ContextState* state, GLenum target) const;
+
  private:
   friend class Buffer;
   friend class TestHelper;  // Needs access to DoBufferData.
   friend class BufferManagerTestBase;  // Needs access to DoBufferSubData.
+
   void StartTracking(Buffer* buffer);
   void StopTracking(Buffer* buffer);
 
-  Buffer* GetBufferInfoForTarget(ContextState* state, GLenum target);
-
   // Does a glBufferSubData and updates the approriate accounting.
   // Assumes the values have already been validated.
   void DoBufferSubData(
       ErrorState* error_state,
       Buffer* buffer,
       GLintptr offset,
       GLsizeiptr size,
       const GLvoid* data);
 
   // Does a glBufferData and updates the approprate accounting. Currently
@@ skipping 30 matching lines @@
   bool have_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_