gpu: Add support for GLX_EXT_texture_from_pixmap extension.

content/common/gpu/gpu_channel.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop_proxy.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "content/common/child_process.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/sync_point_manager.h"
 #include "content/public/common/content_switches.h"
+#include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_image.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "content/common/gpu/stream_texture_manager_android.h"
 #endif
 
@@ skipping 109 matching lines @@
                        GpuWatchdog* watchdog,
                        gfx::GLShareGroup* share_group,
                        gpu::gles2::MailboxManager* mailbox,
                        int client_id,
                        bool software)
     : gpu_channel_manager_(gpu_channel_manager),
       unprocessed_messages_(new gpu::RefCountedCounter),
       client_id_(client_id),
       share_group_(share_group ? share_group : new gfx::GLShareGroup),
       mailbox_manager_(mailbox ? mailbox : new gpu::gles2::MailboxManager),
+      image_manager_(new gpu::gles2::ImageManager),
       watchdog_(watchdog),
       software_(software),
       handle_messages_scheduled_(false),
       processed_get_state_fast_(false),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   channel_id_ = IPC::Channel::GenerateVerifiedChannelID("gpu");
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
@@ skipping 150 matching lines @@
 #if defined(ENABLE_GPU)
 
   GpuCommandBufferStub* share_group = stubs_.Lookup(init_params.share_group_id);
 
   *route_id = GenerateRouteID();
   scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
       this,
       share_group,
       window,
       mailbox_manager_,
+      image_manager_,
       gfx::Size(),
       disallowed_features_,
       init_params.allowed_extensions,
       init_params.attribs,
       init_params.gpu_preference,
       *route_id,
       surface_id,
       watchdog_,
       software_,
       init_params.active_url));
   if (preempt_by_counter_.get())
     stub->SetPreemptByCounter(preempt_by_counter_);
   router_.AddRoute(*route_id, stub.get());
   stubs_.AddWithID(stub.release(), *route_id);
 #endif  // ENABLE_GPU
 }
 
 GpuCommandBufferStub* GpuChannel::LookupCommandBuffer(int32 route_id) {
   return stubs_.Lookup(route_id);
 }
 
+void GpuChannel::CreateImage(
+    gfx::PluginWindowHandle window,
+    int32 image_id,
+    gfx::Size* size) {
+  TRACE_EVENT1("gpu",
+               "GpuChannel::CreateImage",
+               "image_id",
+               image_id);
+
+  *size = gfx::Size();
+
+  scoped_refptr<gfx::GLImage> image = gfx::GLImage::CreateGLImage(window);
+  if (!image)
+    return;
+
+  image_manager_->AddImage(image, image_id);

[piman, 2012/10/12 22:05:11]

Should we consider the case where image_id already exists?
Currently it will replace the image in the image_manager_ but textures may still
be referencing the old one. It may cause a bunch of surprises later.

While I assume the client would of course try to avoid that, if ids get re-used,
races can come in (see comments in browser_gpu_channel_host_factory).

[reveman, 2012/10/13 05:25:53]

I made it fail if an image_id already exists.

+  *size = image->GetSize();
+}
+
+void GpuChannel::DeleteImage(int32 image_id) {
+  TRACE_EVENT1("gpu",
+               "GpuChannel::DeleteImage",
+               "image_id",
+               image_id);
+
+  image_manager_->RemoveImage(image_id);
+}
+
 void GpuChannel::LoseAllContexts() {
   gpu_channel_manager_->LoseAllContexts();
 }
 
 void GpuChannel::DestroySoon() {
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&GpuChannel::OnDestroy, this));
 }
 
 int GpuChannel::GenerateRouteID() {
@@ skipping 114 matching lines @@
 #if defined(ENABLE_GPU)
   GpuCommandBufferStub* share_group = stubs_.Lookup(init_params.share_group_id);
 
   route_id = GenerateRouteID();
 
   scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
       this,
       share_group,
       gfx::GLSurfaceHandle(),
       mailbox_manager_.get(),
+      image_manager_.get(),
       size,
       disallowed_features_,
       init_params.allowed_extensions,
       init_params.attribs,
       init_params.gpu_preference,
       route_id,
       0, watchdog_,
       software_,
       init_params.active_url));
   if (preempt_by_counter_.get())
@@ skipping 71 matching lines @@
       stats.total_texture_upload_time += total_texture_upload_time;
       stats.total_processing_commands_time += total_processing_commands_time;
     }
   }
 
   GpuChannelMsg_CollectRenderingStatsForSurface::WriteReplyParams(
       reply_message,
       stats);
   Send(reply_message);
 }