Update To 11.40.268.0

[platform/framework/web/crosswalk.git] / src / content / browser / compositor / gpu_process_transport_factory.cc

diff --git a/src/content/browser/compositor/gpu_process_transport_factory.cc b/src/content/browser/compositor/gpu_process_transport_factory.cc
index 478b0cb..24e721f 100644 (file)
--- a/src/content/browser/compositor/gpu_process_transport_factory.cc
+++ b/src/content/browser/compositor/gpu_process_transport_factory.cc
@@ -24,6 +24,7 @@
 #include "content/browser/compositor/software_browser_compositor_output_surface.h"
 #include "content/browser/compositor/surface_display_output_surface.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
+#include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
@@ -96,7 +97,11 @@ GpuProcessTransportFactory::~GpuProcessTransportFactory() {
 
 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 GpuProcessTransportFactory::CreateOffscreenCommandBufferContext() {
-  return CreateContextCommon(0);
+  CauseForGpuLaunch cause =
+      CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
+  scoped_refptr<GpuChannelHost> gpu_channel_host(
+      BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(cause));
+  return CreateContextCommon(gpu_channel_host, 0);
 }
 
 scoped_ptr<cc::SoftwareOutputDevice> CreateSoftwareOutputDevice(
@@ -134,11 +139,13 @@ scoped_ptr<cc::OverlayCandidateValidator> CreateOverlayCandidateValidator(
   return scoped_ptr<cc::OverlayCandidateValidator>();
 }
 
-scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
-    ui::Compositor* compositor, bool software_fallback) {
-  PerCompositorData* data = per_compositor_data_[compositor];
+void GpuProcessTransportFactory::CreateOutputSurface(
+    base::WeakPtr<ui::Compositor> compositor,
+    bool software_fallback) {
+  DCHECK(!!compositor);
+  PerCompositorData* data = per_compositor_data_[compositor.get()];
   if (!data)
-    data = CreatePerCompositorData(compositor);
+    data = CreatePerCompositorData(compositor.get());
 
   bool create_software_renderer = software_fallback;
 #if defined(OS_CHROMEOS)
@@ -150,12 +157,37 @@ scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
       create_software_renderer = true;
   }
 #endif
-
-  scoped_refptr<ContextProviderCommandBuffer> context_provider;
+  if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())
+    create_software_renderer = true;
 
   if (!create_software_renderer) {
+    CauseForGpuLaunch cause =
+        CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
+    BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
+        cause,
+        base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
+                   callback_factory_.GetWeakPtr(),
+                   compositor,
+                   create_software_renderer));
+  } else {
+    EstablishedGpuChannel(compositor, create_software_renderer);
+  }
+}
+
+void GpuProcessTransportFactory::EstablishedGpuChannel(
+    base::WeakPtr<ui::Compositor> compositor,
+    bool create_software_renderer) {
+  if (!compositor)
+    return;
+  PerCompositorData* data = per_compositor_data_[compositor.get()];
+  DCHECK(data);
+  scoped_refptr<GpuChannelHost> gpu_channel_host =
+      BrowserGpuChannelHostFactory::instance()->GetGpuChannel();
+  scoped_refptr<ContextProviderCommandBuffer> context_provider;
+  if (gpu_channel_host.get() && !create_software_renderer) {
     context_provider = ContextProviderCommandBuffer::Create(
-        GpuProcessTransportFactory::CreateContextCommon(data->surface_id),
+        GpuProcessTransportFactory::CreateContextCommon(gpu_channel_host,
+                                                        data->surface_id),
         "Compositor");
   }
 
@@ -185,14 +217,14 @@ scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
       display_surface =
           make_scoped_ptr(new SoftwareBrowserCompositorOutputSurface(
               output_surface_proxy_,
-              CreateSoftwareOutputDevice(compositor),
-              per_compositor_data_[compositor]->surface_id,
+              CreateSoftwareOutputDevice(compositor.get()),
+              data->surface_id,
               &output_surface_map_,
               compositor->vsync_manager()));
     } else {
       display_surface = make_scoped_ptr(new GpuBrowserCompositorOutputSurface(
           context_provider,
-          per_compositor_data_[compositor]->surface_id,
+          data->surface_id,
           &output_surface_map_,
           compositor->vsync_manager(),
           CreateOverlayCandidateValidator(compositor->widget())));
@@ -200,20 +232,14 @@ scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
     scoped_ptr<OnscreenDisplayClient> display_client(new OnscreenDisplayClient(
         display_surface.Pass(), manager, compositor->task_runner()));
 
-    scoped_refptr<cc::ContextProvider> offscreen_context_provider;
-    if (context_provider.get()) {
-      offscreen_context_provider = ContextProviderCommandBuffer::Create(
-          GpuProcessTransportFactory::CreateOffscreenCommandBufferContext(),
-          "Offscreen-Compositor");
-    }
     scoped_ptr<SurfaceDisplayOutputSurface> output_surface(
-        new SurfaceDisplayOutputSurface(manager,
-          next_surface_id_namespace_++,
-          offscreen_context_provider));
+        new SurfaceDisplayOutputSurface(
+            manager, compositor->surface_id_allocator(), context_provider));
     display_client->set_surface_output_surface(output_surface.get());
-    output_surface->set_display(display_client->display());
+    output_surface->set_display_client(display_client.get());
     data->display_client = display_client.Pass();
-    return output_surface.PassAs<cc::OutputSurface>();
+    compositor->SetOutputSurface(output_surface.Pass());
+    return;
   }
 
   if (!context_provider.get()) {
@@ -225,11 +251,12 @@ scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
     scoped_ptr<SoftwareBrowserCompositorOutputSurface> surface(
         new SoftwareBrowserCompositorOutputSurface(
             output_surface_proxy_,
-            CreateSoftwareOutputDevice(compositor),
-            per_compositor_data_[compositor]->surface_id,
+            CreateSoftwareOutputDevice(compositor.get()),
+            data->surface_id,
             &output_surface_map_,
             compositor->vsync_manager()));
-    return surface.PassAs<cc::OutputSurface>();
+    compositor->SetOutputSurface(surface.Pass());
+    return;
   }
 
   scoped_ptr<BrowserCompositorOutputSurface> surface;
@@ -237,17 +264,18 @@ scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
   if (ui::SurfaceFactoryOzone::GetInstance()->CanShowPrimaryPlaneAsOverlay()) {
     surface.reset(new GpuSurfacelessBrowserCompositorOutputSurface(
         context_provider,
-        per_compositor_data_[compositor]->surface_id,
+        data->surface_id,
         &output_surface_map_,
         compositor->vsync_manager(),
         CreateOverlayCandidateValidator(compositor->widget()),
-        GL_RGB8_OES));
+        GL_RGB,
+        compositor_thread_ != nullptr));
   }
 #endif
   if (!surface)
     surface.reset(new GpuBrowserCompositorOutputSurface(
         context_provider,
-        per_compositor_data_[compositor]->surface_id,
+        data->surface_id,
         &output_surface_map_,
         compositor->vsync_manager(),
         CreateOverlayCandidateValidator(compositor->widget())));
@@ -255,7 +283,7 @@ scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
   if (data->reflector.get())
     data->reflector->ReattachToOutputSurfaceFromMainThread(surface.get());
 
-  return surface.PassAs<cc::OutputSurface>();
+  compositor->SetOutputSurface(surface.Pass());
 }
 
 scoped_refptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
@@ -317,6 +345,11 @@ cc::SharedBitmapManager* GpuProcessTransportFactory::GetSharedBitmapManager() {
   return HostSharedBitmapManager::current();
 }
 
+gpu::GpuMemoryBufferManager*
+GpuProcessTransportFactory::GetGpuMemoryBufferManager() {
+  return BrowserGpuMemoryBufferManager::current();
+}
+
 ui::ContextFactory* GpuProcessTransportFactory::GetContextFactory() {
   return this;
 }
@@ -329,7 +362,7 @@ base::MessageLoopProxy* GpuProcessTransportFactory::GetCompositorMessageLoop() {
 
 gfx::GLSurfaceHandle GpuProcessTransportFactory::GetSharedSurfaceHandle() {
   gfx::GLSurfaceHandle handle = gfx::GLSurfaceHandle(
-      gfx::kNullPluginWindow, gfx::TEXTURE_TRANSPORT);
+      gfx::kNullPluginWindow, gfx::NULL_TRANSPORT);
   handle.parent_client_id =
       BrowserGpuChannelHostFactory::instance()->GetGpuChannelId();
   return handle;
@@ -419,7 +452,9 @@ GpuProcessTransportFactory::CreatePerCompositorData(
 }
 
 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
-GpuProcessTransportFactory::CreateContextCommon(int surface_id) {
+GpuProcessTransportFactory::CreateContextCommon(
+    scoped_refptr<GpuChannelHost> gpu_channel_host,
+    int surface_id) {
   if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   blink::WebGraphicsContext3D::Attributes attrs;
@@ -429,10 +464,6 @@ GpuProcessTransportFactory::CreateContextCommon(int surface_id) {
   attrs.antialias = false;
   attrs.noAutomaticFlushes = true;
   bool lose_context_when_out_of_memory = true;
-  CauseForGpuLaunch cause =
-      CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
-  scoped_refptr<GpuChannelHost> gpu_channel_host(
-      BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(cause));
   if (!gpu_channel_host.get()) {
     LOG(ERROR) << "Failed to establish GPU channel.";
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();