gpu: Add support for GLX_EXT_texture_from_pixmap extension.

content/browser/gpu/browser_gpu_channel_host_factory.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/browser/gpu/browser_gpu_channel_host_factory.h"
 
 #include "base/bind.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
@@ skipping 116 matching lines @@
         init_params));
   // We're blocking the UI thread, which is generally undesirable.
   // In this case we need to wait for this before we can show any UI /anyway/,
   // so it won't cause additional jank.
   // TODO(piman): Make this asynchronous (http://crbug.com/125248).
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   request.event.Wait();
   return request.route_id;
 }
 
+void BrowserGpuChannelHostFactory::CreateImageOnIO(
+    gfx::PluginWindowHandle window,
+    int32 image_id,
+    const CreateImageCallback& callback) {
+  GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
+  if (!host) {
+    ImageCreatedOnIO(callback, gfx::Size());
+    return;
+  }
+
+  host->CreateImage(
+      window,
+      gpu_client_id_,
+      image_id,
+      base::Bind(&BrowserGpuChannelHostFactory::ImageCreatedOnIO, callback));
+}
+
+// static
+void BrowserGpuChannelHostFactory::ImageCreatedOnIO(
+    const CreateImageCallback& callback, const gfx::Size size) {
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&BrowserGpuChannelHostFactory::OnImageCreated,
+                 callback, size));
+}
+
+// static
+void BrowserGpuChannelHostFactory::OnImageCreated(
+    const CreateImageCallback& callback, const gfx::Size size) {
+  callback.Run(size);
+}
+
+void BrowserGpuChannelHostFactory::CreateImage(
+    gfx::PluginWindowHandle window,
+    int32 image_id,
+    const CreateImageCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  GetIOLoopProxy()->PostTask(FROM_HERE, base::Bind(
+        &BrowserGpuChannelHostFactory::CreateImageOnIO,
+        base::Unretained(this),
+        window,
+        image_id,
+        callback));
+}
+
+void BrowserGpuChannelHostFactory::DeleteImageOnIO(int32 image_id) {
+  GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
+  if (!host) {
+    return;
+  }
+
+  host->DeleteImage(gpu_client_id_, image_id);
+}
+
+void BrowserGpuChannelHostFactory::DeleteImage(int32 image_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  GetIOLoopProxy()->PostTask(FROM_HERE, base::Bind(
+        &BrowserGpuChannelHostFactory::DeleteImageOnIO,
+        base::Unretained(this),
+        image_id));

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

Note: there's still a race on destruction. Take this example:

CreateImage(XID, id, callback);

callback() {
  context->bindTexImage2D(id);
  context->drawQuad();
  context->releaseTexImage2D(id)
  DeleteImage(id);
}

In this case, the DeleteImage may be executed before the bindImage has a chance
to happen.

One way out is to have DeleteImage on the context's channel (it's similar to how
we create view contexts through the process channel, but they get deleted from
the context channel).
Another way is ask for a sync point here, and pass it along, so that on the GPU
process side you can wait for the referencing commands to be finished. It makes
it more verbose from the client's pov.

Depending on the image id allocation scheme though, there may still be races
with the first one. If image ids get re-used aggressively, you could get into:

[...]
DeleteImage(id);
CreateImage(XID, id, callback);

In the first case, CreateImage might be executed before the DeleteImage, and
hilarity ensues.

If ids aren't re-used before wrapping, we can probably construct an argument
that it can't happen (you'd need to exhaust memory to have 4B DeleteImage
messages in flight).
Something to note somewhere.

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

I've added a sync point to DeleteImage. I liked that approach.

+}
+
 void BrowserGpuChannelHostFactory::EstablishGpuChannelOnIO(
     EstablishRequest* request) {
   GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
   if (!host) {
     host = GpuProcessHost::Get(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
                                request->cause_for_gpu_launch);
     if (!host) {
       request->event.Signal();
       return;
     }
@@ skipping 71 matching lines @@
   gpu_channel_->set_gpu_info(request.gpu_info);
   content::GetContentClient()->SetGpuInfo(request.gpu_info);
 
   // Connect to the GPU process if a channel name was received.
   gpu_channel_->Connect(request.channel_handle);
 
   return gpu_channel_.get();
 }
 
 }  // namespace content