gpu: Remove in-process GPU service support for CHROMIUM_image.

gpu/command_buffer/service/in_process_command_buffer.cc

 // 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.
 
 #include "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
@@ skipping 29 matching lines @@
 
 #if defined(OS_ANDROID)
 #include "gpu/command_buffer/service/stream_texture_manager_in_process_android.h"
 #include "ui/gl/android/surface_texture.h"
 #endif
 
 namespace gpu {
 
 namespace {
 
-static InProcessGpuMemoryBufferFactory* g_gpu_memory_buffer_factory = NULL;
-
 template <typename T>
 static void RunTaskWithResult(base::Callback<T(void)> task,
                               T* result,
                               base::WaitableEvent* completion) {
   *result = task.Run();
   completion->Signal();
 }
 
 class GpuInProcessThread
     : public base::Thread,
@@ skipping 236 matching lines @@
       base::Bind(&InProcessCommandBuffer::InitializeOnGpuThread,
                  base::Unretained(this),
                  params);
 
   base::WaitableEvent completion(true, false);
   bool result = false;
   QueueTask(
       base::Bind(&RunTaskWithResult<bool>, init_task, &result, &completion));
   completion.Wait();
 
-  if (result) {
+  if (result)
     capabilities_ = capabilities;
-    capabilities_.map_image =
-        capabilities_.map_image && g_gpu_memory_buffer_factory;
-  }
+
   return result;
 }
 
 bool InProcessCommandBuffer::InitializeOnGpuThread(
     const InitializeOnGpuThreadParams& params) {
   CheckSequencedThread();
   gpu_thread_weak_ptr_ = gpu_thread_weak_ptr_factory_.GetWeakPtr();
 
   DCHECK(params.size.width() >= 0 && params.size.height() >= 0);
 
@@ skipping 289 matching lines @@
 gpu::Capabilities InProcessCommandBuffer::GetCapabilities() {
   return capabilities_;
 }
 
 gfx::GpuMemoryBuffer* InProcessCommandBuffer::CreateGpuMemoryBuffer(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage,
     int32* id) {
-  CheckSequencedThread();
-
-  *id = -1;
-
-  scoped_ptr<gfx::GpuMemoryBuffer> buffer =
-      g_gpu_memory_buffer_factory->AllocateGpuMemoryBuffer(
-          width, height, internalformat, usage);
-  if (!buffer.get())
-    return NULL;
-
-  static int32 next_id = 1;
-  int32 new_id = next_id++;
-
-  base::Closure task =
-      base::Bind(&InProcessCommandBuffer::RegisterGpuMemoryBufferOnGpuThread,
-                 base::Unretained(this),
-                 new_id,
-                 buffer->GetHandle(),
-                 width,
-                 height,
-                 internalformat);
-
-  QueueTask(task);
-
-  *id = new_id;
-  DCHECK(gpu_memory_buffers_.find(new_id) == gpu_memory_buffers_.end());
-  return gpu_memory_buffers_.add(new_id, buffer.Pass()).first->second;
-}
-
-void InProcessCommandBuffer::RegisterGpuMemoryBufferOnGpuThread(
-    int32 id,
-    const gfx::GpuMemoryBufferHandle& handle,
-    size_t width,
-    size_t height,
-    unsigned internalformat) {
-  scoped_refptr<gfx::GLImage> image =
-      g_gpu_memory_buffer_factory->CreateImageForGpuMemoryBuffer(
-          handle, gfx::Size(width, height), internalformat);
-  if (!image.get())
-    return;
-
-  // For Android specific workaround.
-  gles2::ContextGroup* context_group = decoder_->GetContextGroup();
-  if (context_group->feature_info()->workarounds().release_image_after_use)
-    image->SetReleaseAfterUse();
-
-  if (decoder_) {
-    gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
-    DCHECK(image_manager);
-    image_manager->AddImage(image.get(), id);
-  }
+  NOTREACHED();
+  return NULL;
 }
 
 void InProcessCommandBuffer::DestroyGpuMemoryBuffer(int32 id) {
-  CheckSequencedThread();
-
-  base::Closure task =
-      base::Bind(&InProcessCommandBuffer::UnregisterGpuMemoryBufferOnGpuThread,
-                 base::Unretained(this),
-                 id);
-
-  QueueTask(task);
-
-  gpu_memory_buffers_.erase(id);
-}
-
-void InProcessCommandBuffer::UnregisterGpuMemoryBufferOnGpuThread(int32 id) {
-  if (decoder_) {
-    gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
-    DCHECK(image_manager);
-    image_manager->RemoveImage(id);
-  }
+  NOTREACHED();
 }
 
 uint32 InProcessCommandBuffer::InsertSyncPoint() {
   uint32 sync_point = g_sync_point_manager.Get().GenerateSyncPoint();
   QueueTask(base::Bind(&InProcessCommandBuffer::RetireSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point));
   return sync_point;
 }
 
@@ skipping 138 matching lines @@
 }
 
 #if defined(OS_ANDROID)
 scoped_refptr<gfx::SurfaceTexture>
 InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 #endif
 
-// static
-void InProcessCommandBuffer::SetGpuMemoryBufferFactory(
-    InProcessGpuMemoryBufferFactory* factory) {
-  g_gpu_memory_buffer_factory = factory;
-}
-
 }  // namespace gpu