gpu: Move image creation part of GpuMemoryBufferFactory interface to gpu namespace.

content/common/gpu/client/command_buffer_proxy_impl.cc

 // 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.
 
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 
 #include "base/callback.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/stl_util.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/client/gpu_video_decode_accelerator_host.h"
 #include "content/common/gpu/client/gpu_video_encode_accelerator_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 #include "gpu/command_buffer/common/command_buffer_shared.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
+#include "gpu/command_buffer/service/image_factory.h"
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace content {
-namespace {
-
-gfx::GpuMemoryBuffer::Format ImageFormatToGpuMemoryBufferFormat(
-    unsigned internalformat) {
-  switch (internalformat) {
-    case GL_RGB:
-      return gfx::GpuMemoryBuffer::RGBX_8888;
-    case GL_RGBA:
-      return gfx::GpuMemoryBuffer::RGBA_8888;
-    default:
-      NOTREACHED();
-      return gfx::GpuMemoryBuffer::RGBA_8888;
-  }
-}
-
-gfx::GpuMemoryBuffer::Usage ImageUsageToGpuMemoryBufferUsage(unsigned usage) {
-  switch (usage) {
-    case GL_MAP_CHROMIUM:
-      return gfx::GpuMemoryBuffer::MAP;
-    case GL_SCANOUT_CHROMIUM:
-      return gfx::GpuMemoryBuffer::SCANOUT;
-    default:
-      NOTREACHED();
-      return gfx::GpuMemoryBuffer::MAP;
-  }
-}
-
-bool IsImageFormatCompatibleWithGpuMemoryBufferFormat(
-    gfx::GpuMemoryBuffer::Format format,
-    unsigned internalformat) {
-  switch (internalformat) {
-    case GL_RGB:
-      switch (format) {
-        case gfx::GpuMemoryBuffer::RGBX_8888:
-          return true;
-        case gfx::GpuMemoryBuffer::RGBA_8888:
-        case gfx::GpuMemoryBuffer::BGRA_8888:
-          return false;
-      }
-      NOTREACHED();
-      return false;
-    case GL_RGBA:
-      switch (format) {
-        case gfx::GpuMemoryBuffer::RGBX_8888:
-          return false;
-        case gfx::GpuMemoryBuffer::RGBA_8888:
-        case gfx::GpuMemoryBuffer::BGRA_8888:
-          return true;
-      }
-      NOTREACHED();
-      return false;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-}  // namespace
 
 CommandBufferProxyImpl::CommandBufferProxyImpl(
     GpuChannelHost* channel,
     int route_id)
     : channel_(channel),
       route_id_(route_id),
       flush_count_(0),
       last_put_offset_(-1),
       next_signal_id_(0) {
 }
@@ skipping 276 matching lines @@
           buffer);
   DCHECK(gpu_memory_buffer);
 
   // This handle is owned by the GPU process and must be passed to it or it
   // will leak. In otherwords, do not early out on error between here and the
   // sending of the CreateImage IPC below.
   gfx::GpuMemoryBufferHandle handle =
       channel_->ShareGpuMemoryBufferToGpuProcess(
           gpu_memory_buffer->GetHandle());
 
-  DCHECK(IsImageFormatCompatibleWithGpuMemoryBufferFormat(
-      gpu_memory_buffer->GetFormat(), internalformat));
+  DCHECK(gpu::ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
+      internalformat, gpu_memory_buffer->GetFormat()));
   if (!Send(new GpuCommandBufferMsg_CreateImage(route_id_,
                                                 new_id,
                                                 handle,
                                                 gfx::Size(width, height),
                                                 gpu_memory_buffer->GetFormat(),
                                                 internalformat))) {
     return -1;
   }
 
   return new_id;
 }
 
 void CommandBufferProxyImpl::DestroyImage(int32 id) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_DestroyImage(route_id_, id));
 }
 
 int32_t CommandBufferProxyImpl::CreateGpuMemoryBufferImage(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage) {
   scoped_ptr<gfx::GpuMemoryBuffer> buffer(
       channel_->gpu_memory_buffer_manager()->AllocateGpuMemoryBuffer(
           gfx::Size(width, height),
-          ImageFormatToGpuMemoryBufferFormat(internalformat),
-          ImageUsageToGpuMemoryBufferUsage(usage)));
+          gpu::ImageFactory::ImageFormatToGpuMemoryBufferFormat(internalformat),
+          gpu::ImageFactory::ImageUsageToGpuMemoryBufferUsage(usage)));
   if (!buffer)
     return -1;
 
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
 int CommandBufferProxyImpl::GetRouteID() const {
   return route_id_;
 }
 
@@ skipping 161 matching lines @@
     if (!ui::LatencyInfo::Verify(
             latency_info, "CommandBufferProxyImpl::OnSwapBuffersCompleted")) {
       swap_buffers_completion_callback_.Run(std::vector<ui::LatencyInfo>());
       return;
     }
     swap_buffers_completion_callback_.Run(latency_info);
   }
 }
 
 }  // namespace content