Change glimage to accept a type.

gpu/command_buffer/service/gpu_control_service.h

 // Copyright 2013 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_GPU_CONTROL_SERVICE_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GPU_CONTROL_SERVICE_H_
 
 #include <map>
 
 #include "base/memory/linked_ptr.h"
@@ skipping 14 matching lines @@
   GpuControlService(GpuMemoryBufferManagerInterface* gpu_memory_buffer_manager,
                     GpuMemoryBufferFactory* gpu_memory_buffer_factory,
                     gles2::MailboxManager* mailbox_manager,
                     gles2::QueryManager* query_manager,
                     const gpu::Capabilities& decoder_capabilities);
   virtual ~GpuControlService();
 
 
   // GpuControl implementation.
   virtual gpu::Capabilities GetCapabilities() OVERRIDE;
-  virtual gfx::GpuMemoryBuffer* CreateGpuMemoryBuffer(
-      size_t width,
-      size_t height,
-      unsigned internalformat,
-      int32* id) OVERRIDE;
+  virtual gfx::GpuMemoryBuffer* CreateGpuMemoryBuffer(size_t width,
+                                                      size_t height,
+                                                      unsigned internalformat,
+                                                      unsigned usage,
+                                                      int32* id) OVERRIDE;
   virtual void DestroyGpuMemoryBuffer(int32 id) OVERRIDE;
   virtual uint32 InsertSyncPoint() OVERRIDE;
   virtual void SignalSyncPoint(uint32 sync_point,
                                const base::Closure& callback) OVERRIDE;
   virtual void SignalQuery(uint32 query,
                            const base::Closure& callback) OVERRIDE;
   virtual void SetSurfaceVisible(bool visible) OVERRIDE;
   virtual void SendManagedMemoryStats(const ManagedMemoryStats& stats)
       OVERRIDE;
   virtual void Echo(const base::Closure& callback) OVERRIDE;
   virtual uint32 CreateStreamTexture(uint32 texture_id) OVERRIDE;
 
   // Register an existing gpu memory buffer and get an ID that can be used
   // to identify it in the command buffer.
   bool RegisterGpuMemoryBuffer(int32 id,
                                gfx::GpuMemoryBufferHandle buffer,
                                size_t width,
                                size_t height,
-                               unsigned internalformat);
+                               unsigned internalformat,
+                               unsigned usage);

[reveman, 2014/05/01 12:06:38]

Does the GPU service really need to know about usage? We can't rely on this to
determine the actual usage that is allowed for a buffer as a malicious renderer
can easily manufacture this.

[alexst (slow to review), 2014/05/01 13:44:51]

I suppose it's not strictly necessary,  I was going to use this to reject
buffers not meant for scanout but set as overlay early to produce a better error
message in command buffer. If the usage is malicious here, it'll get rejected
eventually anyway in the lower level ozone bits because they know what the
actual buffer is like. I can remove this if you prefer.

[reveman, 2014/05/01 13:48:46]

Let's avoid it for now and we can add it later if it turns out to be useful. 

 
  private:
   GpuMemoryBufferManagerInterface* gpu_memory_buffer_manager_;
   GpuMemoryBufferFactory* gpu_memory_buffer_factory_;
   gles2::MailboxManager* mailbox_manager_;
   gles2::QueryManager* query_manager_;
   typedef std::map<int32, linked_ptr<gfx::GpuMemoryBuffer> > GpuMemoryBufferMap;
   GpuMemoryBufferMap gpu_memory_buffers_;
   gpu::Capabilities capabilities_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuControlService);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GPU_CONTROL_SERVICE_H_