Properly set the BufferToTextureTargetMap in Blimp

blimp/client/feature/compositor/blimp_gpu_memory_buffer_manager.cc

 // Copyright 2016 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 "blimp/client/feature/compositor/blimp_gpu_memory_buffer_manager.h"
 
+#include <GLES2/gl2.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 
+#include "base/hash.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
+namespace {

[Khushal, 2016/08/02 06:39:01]

Doesn't look like GetDefaultBufferToTextureTargetMap is using this code?

[David Trainor- moved to gerrit, 2016/08/02 15:37:27]

Crap.  done.

+
+using GpuMemoryBufferConfigurationKey =
+    std::pair<gfx::BufferFormat, gfx::BufferUsage>;
+using GpuMemoryBufferConfigurationSet =
+    base::hash_set<GpuMemoryBufferConfigurationKey>;
+
+}  // namespace
+
+namespace BASE_HASH_NAMESPACE {
+
+template <>
+struct hash<GpuMemoryBufferConfigurationKey> {
+  size_t operator()(const GpuMemoryBufferConfigurationKey& key) const {
+    return base::HashInts(static_cast<int>(key.first),
+                          static_cast<int>(key.second));
+  }
+};
+
+}  // namespace BASE_HASH_NAMESPACE
+
 namespace blimp {
 namespace client {
 
 namespace {
 
 class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
  public:
   GpuMemoryBufferImpl(const gfx::Size& size,
                       gfx::BufferFormat format,
                       std::unique_ptr<base::SharedMemory> shared_memory,
@@ skipping 66 matching lines @@
   size_t stride_;
   bool mapped_;
 };
 
 }  // namespace
 
 BlimpGpuMemoryBufferManager::BlimpGpuMemoryBufferManager() {}
 
 BlimpGpuMemoryBufferManager::~BlimpGpuMemoryBufferManager() {}
 
+// static
+cc::BufferToTextureTargetMap
+BlimpGpuMemoryBufferManager::GetDefaultBufferToTextureTargetMap() {
+  cc::BufferToTextureTargetMap image_targets;
+  for (int usage_idx = 0; usage_idx <= static_cast<int>(gfx::BufferUsage::LAST);
+       ++usage_idx) {
+    gfx::BufferUsage usage = static_cast<gfx::BufferUsage>(usage_idx);
+    for (int format_idx = 0;
+         format_idx <= static_cast<int>(gfx::BufferFormat::LAST);
+         ++format_idx) {
+      gfx::BufferFormat format = static_cast<gfx::BufferFormat>(format_idx);
+      image_targets.insert(cc::BufferToTextureTargetMap::value_type(
+          cc::BufferToTextureTargetKey(usage, format), GL_TEXTURE_2D));
+    }
+  }
+  return image_targets;
+}
+
 std::unique_ptr<gfx::GpuMemoryBuffer>
 BlimpGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gpu::SurfaceHandle surface_handle) {
   DCHECK_EQ(gpu::kNullSurfaceHandle, surface_handle)
       << "Blimp should not be allocating scanout buffers";
   std::unique_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
   const size_t buffer_size = gfx::BufferSizeForBufferFormat(size, format);
@@ skipping 26 matching lines @@
 }
 
 void BlimpGpuMemoryBufferManager::SetDestructionSyncToken(
     gfx::GpuMemoryBuffer* buffer,
     const gpu::SyncToken& sync_token) {
   NOTIMPLEMENTED();
 }
 
 }  // namespace client
 }  // namespace blimp