Aura: Have ui::Layer implement WebKit::WebExternalTextureLayerClient

content/browser/renderer_host/image_transport_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/renderer_host/image_transport_factory.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
-#include "content/browser/renderer_host/image_transport_client.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/ipc/command_buffer_proxy.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_setup.h"
+#include "ui/compositor/test_web_graphics_context_3d.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/size.h"
 #include "ui/gl/scoped_make_current.h"
 
 using content::BrowserGpuChannelHostFactory;
 using content::GLHelper;
 
 namespace {
 
 ImageTransportFactory* g_factory;
@@ skipping 12 matching lines @@
 
   virtual gfx::GLSurfaceHandle CreateSharedSurfaceHandle(
       ui::Compositor* compositor) OVERRIDE {
     return gfx::GLSurfaceHandle();
   }
 
   virtual void DestroySharedSurfaceHandle(
       gfx::GLSurfaceHandle surface) OVERRIDE {
   }
 
-  virtual scoped_refptr<ImageTransportClient> CreateTransportClient(
+  virtual scoped_refptr<ui::Texture> CreateTransportClient(
       const gfx::Size& size,
-      uint64* transport_handle) OVERRIDE {
+      uint64* transport_handle,
+      ui::Compositor* compositor) OVERRIDE {
     return NULL;
   }
 
   virtual GLHelper* GetGLHelper(ui::Compositor* compositor) OVERRIDE {
     return NULL;
   }
 
   virtual uint32 InsertSyncPoint(ui::Compositor* compositor) OVERRIDE {
     return 0;
   }
 
-  virtual gfx::ScopedMakeCurrent* GetScopedMakeCurrent() OVERRIDE {
-    return NULL;
-  }
-
   // We don't generate lost context events, so we don't need to keep track of
   // observers
   virtual void AddObserver(ImageTransportFactoryObserver* observer) OVERRIDE {
   }
 
   virtual void RemoveObserver(
       ImageTransportFactoryObserver* observer) OVERRIDE {
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultTransportFactory);
 };
 
-class TestTransportFactory : public DefaultTransportFactory {
+class ImageTransportClientTexture : public ui::Texture {
  public:
-  TestTransportFactory() {}
-
-  virtual gfx::GLSurfaceHandle CreateSharedSurfaceHandle(
-      ui::Compositor* compositor) OVERRIDE {
-    return gfx::GLSurfaceHandle(gfx::kNullPluginWindow, true);
+  ImageTransportClientTexture(
+      WebKit::WebGraphicsContext3D* host_context,
+      const gfx::Size& size,
+      uint64 surface_id)
+          : ui::Texture(true, size),
+            host_context_(host_context) {
+    set_texture_id(surface_id);
   }
 
-  virtual scoped_refptr<ImageTransportClient> CreateTransportClient(
-      const gfx::Size& size,
-      uint64* transport_handle) OVERRIDE {
-#if defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
-    scoped_refptr<ImageTransportClient> surface(
-        ImageTransportClient::Create(this, size));
-    if (!surface || !surface->Initialize(transport_handle)) {
-      LOG(ERROR) << "Failed to create ImageTransportClient";
-      return NULL;
-    }
-    return surface;
-#else
-    return NULL;
-#endif
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestTransportFactory);
-};
-
-class ImageTransportClientTexture : public ImageTransportClient {
- public:
-  explicit ImageTransportClientTexture(const gfx::Size& size)
-      : ImageTransportClient(true, size) {
-  }
-
-  virtual bool Initialize(uint64* surface_id) OVERRIDE {
-    set_texture_id(*surface_id);
-    return true;
-  }
-
-  virtual void Update() OVERRIDE {}
-  virtual TransportDIB::Handle Handle() const OVERRIDE {
-    return TransportDIB::DefaultHandleValue();
+  virtual WebKit::WebGraphicsContext3D* HostContext3D() {
+    return host_context_;
   }
 
  protected:
   virtual ~ImageTransportClientTexture() {}
 
  private:
+  // A raw pointer. This |ImageTransportClientTexture| will be destroyed
+  // before the |host_context_| via
+  // |ImageTransportFactoryObserver::OnLostContext()| handlers.
+  WebKit::WebGraphicsContext3D* host_context_;
+
   DISALLOW_COPY_AND_ASSIGN(ImageTransportClientTexture);
 };
 
 class GpuProcessTransportFactory;
 
 class CompositorSwapClient
     : public base::SupportsWeakPtr<CompositorSwapClient>,
       public WebGraphicsContext3DSwapBuffersClient {
  public:
   CompositorSwapClient(ui::Compositor* compositor,
@@ skipping 92 matching lines @@
           surface.parent_client_id == client_id &&
           surface.parent_context_id == context_id) {
         data->shared_context->deleteTexture(surface.parent_texture_id[0]);
         data->shared_context->deleteTexture(surface.parent_texture_id[1]);
         data->shared_context->flush();
         break;
       }
     }
   }
 
-  virtual scoped_refptr<ImageTransportClient> CreateTransportClient(
+  virtual scoped_refptr<ui::Texture> CreateTransportClient(
       const gfx::Size& size,
-      uint64* transport_handle) {
+      uint64* transport_handle,
+      ui::Compositor* compositor) {
+    PerCompositorData* data = per_compositor_data_[compositor];
+    DCHECK(data);
     scoped_refptr<ImageTransportClientTexture> image(
-        new ImageTransportClientTexture(size));
-    image->Initialize(transport_handle);
+        new ImageTransportClientTexture(data->shared_context.get(),
+                                        size, *transport_handle));
     return image;
   }
 
   virtual GLHelper* GetGLHelper(ui::Compositor* compositor) {
     PerCompositorData* data = per_compositor_data_[compositor];
     if (!data)
       data = CreatePerCompositorData(compositor);
     if (!data->gl_helper.get()) {
       WebKit::WebGraphicsContext3D* context_for_thread =
           CreateContextCommon(compositor, true);
       if (!context_for_thread)
         return NULL;
       data->gl_helper.reset(new GLHelper(data->shared_context.get(),
                                          context_for_thread));
     }
     return data->gl_helper.get();
   }
 
   virtual uint32 InsertSyncPoint(ui::Compositor* compositor) OVERRIDE {
     PerCompositorData* data = per_compositor_data_[compositor];
     if (!data)
       data = CreatePerCompositorData(compositor);
     return data->shared_context->insertSyncPoint();
   }
 
-  virtual gfx::ScopedMakeCurrent* GetScopedMakeCurrent() { return NULL; }
-
   virtual void AddObserver(ImageTransportFactoryObserver* observer) {
     observer_list_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(ImageTransportFactoryObserver* observer) {
     observer_list_.RemoveObserver(observer);
   }
 
   void OnLostContext(ui::Compositor* compositor) {
     LOG(ERROR) << "Lost UI compositor context.";
@@ skipping 110 matching lines @@
 
 }  // anonymous namespace
 
 // static
 void ImageTransportFactory::Initialize() {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kTestCompositor)) {
     ui::SetupTestCompositor();
   }
   if (ui::IsTestCompositorEnabled()) {
-    g_factory = new TestTransportFactory();
+    g_factory = new DefaultTransportFactory();
   } else {
 #if defined(OS_WIN)
     g_factory = new DefaultTransportFactory();
 #else
     g_factory = new GpuProcessTransportFactory();
 #endif
   }
   ui::ContextFactory::SetInstance(g_factory->AsContextFactory());
 }
 
 // static
 void ImageTransportFactory::Terminate() {
   ui::ContextFactory::SetInstance(NULL);
   delete g_factory;
   g_factory = NULL;
 }
 
 // static
 ImageTransportFactory* ImageTransportFactory::GetInstance() {
   return g_factory;
 }