Re-land: cc: Use worker context for one-copy tile initialization.

content/browser/compositor/gpu_process_transport_factory.cc

 // Copyright 2014 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/compositor/gpu_process_transport_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 245 matching lines @@
       CauseForGpuLaunch cause =
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
       BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
           cause, base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
                             callback_factory_.GetWeakPtr(), compositor,
                             create_gpu_output_surface, num_attempts + 1));
       return;
     }
   }
 
+  scoped_refptr<ContextProviderCommandBuffer> worker_context_provider(
+      ContextProviderCommandBuffer::Create(
+          GpuProcessTransportFactory::CreateOffscreenCommandBufferContext(),
+          BROWSER_WORKER_CONTEXT));

[piman, 2015/07/23 20:44:52]

Can you move this into the else block below, so that we don't try to do this if
we go software?

Separately, is there a way for us to share this context across compositors?
Since compositors typically don't go "invisible", we never really trim memory
for them (shm, command buffers etc.), so it would be good if we could share the
context to keep the memory footprint in check (avoid scaling with the number of
windows).

[reveman, 2015/07/24 17:49:15]

Done. Added a shared worker context provider to latest patch.

+
   scoped_ptr<BrowserCompositorOutputSurface> surface;
   if (!create_gpu_output_surface) {
     surface = make_scoped_ptr(new SoftwareBrowserCompositorOutputSurface(
         CreateSoftwareOutputDevice(compositor.get()),
         compositor->vsync_manager()));
   } else {
     DCHECK(context_provider);
     ContextProvider::Capabilities capabilities =
         context_provider->ContextCapabilities();
     if (!data->surface_id) {
       surface = make_scoped_ptr(new OffscreenBrowserCompositorOutputSurface(
           context_provider, compositor->vsync_manager(),
           scoped_ptr<BrowserCompositorOverlayCandidateValidator>()));
     } else if (capabilities.gpu.surfaceless) {
       surface =
           make_scoped_ptr(new GpuSurfacelessBrowserCompositorOutputSurface(
-              context_provider, data->surface_id, compositor->vsync_manager(),
+              context_provider, worker_context_provider, data->surface_id,
+              compositor->vsync_manager(),
               CreateOverlayCandidateValidator(compositor->widget()),
               GL_TEXTURE_2D, GL_RGB, BrowserGpuMemoryBufferManager::current()));
     } else {
       surface = make_scoped_ptr(new GpuBrowserCompositorOutputSurface(
-          context_provider, compositor->vsync_manager(),
+          context_provider, worker_context_provider,
+          compositor->vsync_manager(),
           CreateOverlayCandidateValidator(compositor->widget())));
     }
   }
 
   // TODO(piman): Use GpuSurfaceTracker to map ids to surfaces instead of an
   // output_surface_map_ here.
   output_surface_map_.AddWithID(surface.get(), data->surface_id);
   data->surface = surface.get();
   if (data->reflector)
     data->reflector->OnSourceSurfaceReady(data->surface);
 
   if (!UseSurfacesEnabled()) {
     compositor->SetOutputSurface(surface.Pass());
     return;
   }
 
   // This gets a bit confusing. Here we have a ContextProvider in the |surface|
   // configured to render directly to this widget. We need to make an
   // OnscreenDisplayClient associated with that context, then return a
   // SurfaceDisplayOutputSurface set up to draw to the display's surface.
   cc::SurfaceManager* manager = surface_manager_.get();
   scoped_ptr<cc::OnscreenDisplayClient> display_client(
       new cc::OnscreenDisplayClient(
           surface.Pass(), manager, HostSharedBitmapManager::current(),
           BrowserGpuMemoryBufferManager::current(),
           compositor->GetRendererSettings(), compositor->task_runner()));
 
   scoped_ptr<cc::SurfaceDisplayOutputSurface> output_surface(
       new cc::SurfaceDisplayOutputSurface(
-          manager, compositor->surface_id_allocator(), context_provider));
+          manager, compositor->surface_id_allocator(), context_provider,
+          worker_context_provider));
   display_client->set_surface_output_surface(output_surface.get());
   output_surface->set_display_client(display_client.get());
   display_client->display()->Resize(compositor->size());
   data->display_client = display_client.Pass();
   compositor->SetOutputSurface(output_surface.Pass());
 }
 
 scoped_ptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
     ui::Compositor* source_compositor,
     ui::Layer* target_layer) {
@@ skipping 259 matching lines @@
   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
                     observer_list_,
                     OnLostResources());
 
   // Kill things that use the shared context before killing the shared context.
   lost_gl_helper.reset();
   lost_shared_main_thread_contexts  = NULL;
 }
 
 }  // namespace content