Defer compositor context creation to the thread.

cc/output/output_surface.h

 // Copyright 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.
 
 #ifndef CC_OUTPUT_OUTPUT_SURFACE_H_
 #define CC_OUTPUT_OUTPUT_SURFACE_H_
 
 #include <deque>
 #include <memory>
 
@@ skipping 28 matching lines @@
 
 // Represents the output surface for a compositor. The compositor owns
 // and manages its destruction. Its lifetime is:
 //   1. Created on the main thread by the LayerTreeHost through its client.
 //   2. Passed to the compositor thread and bound to a client via BindToClient.
 //      From here on, it will only be used on the compositor thread.
 //   3. If the 3D context is lost, then the compositor will delete the output
 //      surface (on the compositor thread) and go back to step 1.
 class CC_EXPORT OutputSurface : public base::trace_event::MemoryDumpProvider {
  public:
-  OutputSurface(scoped_refptr<ContextProvider> context_provider,
-                scoped_refptr<ContextProvider> worker_context_provider,
-                scoped_refptr<VulkanContextProvider> vulkan_context_provider,
-                std::unique_ptr<SoftwareOutputDevice> software_device);
-  OutputSurface(scoped_refptr<ContextProvider> context_provider,
-                scoped_refptr<ContextProvider> worker_context_provider);
-  explicit OutputSurface(scoped_refptr<ContextProvider> context_provider);
+  OutputSurface(
+      std::unique_ptr<ContextProvider::DeferredCreate> context_provider_create,
+      scoped_refptr<ContextProvider> worker_context_provider,

[piman, 2016/05/17 03:41:40]

Is the intent that the worker will also come from a
ContextProvider::DeferredCreate?

[danakj, 2016/05/17 19:53:33]

Yes. I did the compositor one first since it's already bound on the compositor
thread. The worker patch will look similar but requires the weak reference on
the main thread to reuse, so it's a bit more complicated. So this is easier
first while we sort out the design.

+      scoped_refptr<VulkanContextProvider> vulkan_context_provider,
+      std::unique_ptr<SoftwareOutputDevice> software_device);
+  OutputSurface(
+      std::unique_ptr<ContextProvider::DeferredCreate> context_provider_create,
+      scoped_refptr<ContextProvider> worker_context_provider);
+  explicit OutputSurface(
+      std::unique_ptr<ContextProvider::DeferredCreate> context_provider_create);
   explicit OutputSurface(std::unique_ptr<SoftwareOutputDevice> software_device);
 
-  OutputSurface(scoped_refptr<ContextProvider> context_provider,
-                std::unique_ptr<SoftwareOutputDevice> software_device);
+  OutputSurface(
+      std::unique_ptr<ContextProvider::DeferredCreate> context_provider_create,
+      std::unique_ptr<SoftwareOutputDevice> software_device);
 
   ~OutputSurface() override;
 
   struct Capabilities {
     Capabilities()
         : delegated_rendering(false),
           max_frames_pending(1),
           adjust_deadline_for_parent(true),
           uses_default_gl_framebuffer(true),
           flipped_output_surface(false),
@@ skipping 100 matching lines @@
   // base::trace_event::MemoryDumpProvider implementation.
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
  protected:
   OutputSurfaceClient* client_;
 
   void PostSwapBuffersComplete();
 
   struct OutputSurface::Capabilities capabilities_;
+  std::unique_ptr<ContextProvider::DeferredCreate> context_provider_create_;
   scoped_refptr<ContextProvider> context_provider_;
   scoped_refptr<ContextProvider> worker_context_provider_;
   scoped_refptr<VulkanContextProvider> vulkan_context_provider_;
   std::unique_ptr<SoftwareOutputDevice> software_device_;
   gfx::Size surface_size_;
   float device_scale_factor_;
   bool has_alpha_;
   base::ThreadChecker client_thread_checker_;
 
   void SetNeedsRedrawRect(const gfx::Rect& damage_rect);
   void ReclaimResources(const CompositorFrameAck* ack);
   void SetExternalStencilTest(bool enabled);
   void DetachFromClientInternal();
 
  private:
   bool external_stencil_test_enabled_;
 
   base::WeakPtrFactory<OutputSurface> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OutputSurface);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_OUTPUT_SURFACE_H_