Revert "Delete CC."

cc/test/test_gpu_memory_buffer_manager.cc

Index: cc/test/test_gpu_memory_buffer_manager.cc
diff --git a/cc/test/test_gpu_memory_buffer_manager.cc b/cc/test/test_gpu_memory_buffer_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b43cd76c58098572ff97f4cc3959976072ca3db1
--- /dev/null
+++ b/cc/test/test_gpu_memory_buffer_manager.cc
@@ -0,0 +1,112 @@
+// Copyright 2014 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 "cc/test/test_gpu_memory_buffer_manager.h"
+
+#include "base/logging.h"
+#include "ui/gfx/gpu_memory_buffer.h"
+
+namespace cc {
+namespace {
+
+size_t StrideInBytes(size_t width, gfx::GpuMemoryBuffer::Format format) {
+  switch (format) {
+    case gfx::GpuMemoryBuffer::ATCIA:
+    case gfx::GpuMemoryBuffer::DXT5:
+      return width;
+    case gfx::GpuMemoryBuffer::ATC:
+    case gfx::GpuMemoryBuffer::DXT1:
+    case gfx::GpuMemoryBuffer::ETC1:
+      DCHECK_EQ(width % 2, 0U);
+      return width / 2;
+    case gfx::GpuMemoryBuffer::RGBA_8888:
+    case gfx::GpuMemoryBuffer::RGBX_8888:
+    case gfx::GpuMemoryBuffer::BGRA_8888:
+      return width * 4;
+  }
+
+  NOTREACHED();
+  return 0;
+}
+
+class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
+ public:
+  GpuMemoryBufferImpl(const gfx::Size& size,
+                      Format format,
+                      scoped_ptr<base::SharedMemory> shared_memory)
+      : size_(size),
+        format_(format),
+        shared_memory_(shared_memory.Pass()),
+        mapped_(false) {}
+
+  // Overridden from gfx::GpuMemoryBuffer:
+  bool Map(void** data) override {
+    DCHECK(!mapped_);
+    if (!shared_memory_->Map(StrideInBytes(size_.width(), format_) *
+                             size_.height()))
+      return false;
+    mapped_ = true;
+    *data = shared_memory_->memory();
+    return true;
+  }
+  void Unmap() override {
+    DCHECK(mapped_);
+    shared_memory_->Unmap();
+    mapped_ = false;
+  }
+  bool IsMapped() const override { return mapped_; }
+  Format GetFormat() const override { return format_; }
+  void GetStride(uint32* stride) const override {
+    *stride = StrideInBytes(size_.width(), format_);
+  }
+  gfx::GpuMemoryBufferHandle GetHandle() const override {
+    gfx::GpuMemoryBufferHandle handle;
+    handle.type = gfx::SHARED_MEMORY_BUFFER;
+    handle.handle = shared_memory_->handle();
+    return handle;
+  }
+  ClientBuffer AsClientBuffer() override {
+    return reinterpret_cast<ClientBuffer>(this);
+  }
+
+ private:
+  const gfx::Size size_;
+  gfx::GpuMemoryBuffer::Format format_;
+  scoped_ptr<base::SharedMemory> shared_memory_;
+  bool mapped_;
+};
+
+}  // namespace
+
+TestGpuMemoryBufferManager::TestGpuMemoryBufferManager() {
+}
+
+TestGpuMemoryBufferManager::~TestGpuMemoryBufferManager() {
+}
+
+scoped_ptr<gfx::GpuMemoryBuffer>
+TestGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
+    const gfx::Size& size,
+    gfx::GpuMemoryBuffer::Format format,
+    gfx::GpuMemoryBuffer::Usage usage) {
+  scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
+  if (!shared_memory->CreateAnonymous(StrideInBytes(size.width(), format) *
+                                      size.height()))
+    return nullptr;
+  return make_scoped_ptr<gfx::GpuMemoryBuffer>(
+      new GpuMemoryBufferImpl(size, format, shared_memory.Pass()));
+}
+
+gfx::GpuMemoryBuffer*
+TestGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
+    ClientBuffer buffer) {
+  return reinterpret_cast<gfx::GpuMemoryBuffer*>(buffer);
+}
+
+void TestGpuMemoryBufferManager::SetDestructionSyncPoint(
+    gfx::GpuMemoryBuffer* buffer,
+    uint32 sync_point) {
+}
+
+}  // namespace cc