Added the Vulkan Context Provider implementation.

content/browser/compositor/gpu_process_transport_factory.h

 // 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.
 
 #ifndef CONTENT_BROWSER_COMPOSITOR_GPU_PROCESS_TRANSPORT_FACTORY_H_
 #define CONTENT_BROWSER_COMPOSITOR_GPU_PROCESS_TRANSPORT_FACTORY_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 12 matching lines @@
 
 namespace base {
 class SimpleThread;
 class Thread;
 }
 
 namespace cc {
 class SingleThreadTaskGraphRunner;
 class SoftwareOutputDevice;
 class SurfaceManager;
+class VulkanInProcessContextProvider;
 }
 
 namespace content {
 class BrowserCompositorOutputSurface;
 class CompositorSwapClient;
 class ContextProviderCommandBuffer;
 class OutputDeviceBacking;
 class ReflectorImpl;
 class WebGraphicsContext3DCommandBufferImpl;
 
@@ skipping 51 matching lines @@
   void EstablishedGpuChannel(base::WeakPtr<ui::Compositor> compositor,
                              bool create_gpu_output_surface,
                              int num_attempts);
   std::unique_ptr<WebGraphicsContext3DCommandBufferImpl> CreateContextCommon(
       scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
       gpu::SurfaceHandle surface_handle);
 
   void OnLostMainThreadSharedContextInsideCallback();
   void OnLostMainThreadSharedContext();
 
+#if defined(ENABLE_VULKAN)

[piman, 2016/04/19 01:36:42]

Trying to find a way to limit the amount of #ifdef we need... in terms of
interface, VulkanInProcessContextProvider doesn't need Vulkan types explicitly,
maybe we can remove the ifdef here, and limit it to the implementation of
VulkanInProcessContextProvider (i.e. have Initialize fail)

[David Yen, 2016/04/19 22:20:28]

Done. The only thing is we still have to #ifdef out
VulkanBrowserCompositorOutputSurface, so there is a bit of a mismatch going on
there. A little strange but it works out I think.

If we are going to compile in VulkanInProcessContextProvider, perhaps we should
also remove the #ifdefs in OutputSurface? We discussed that before and decided
not to so that we wouldn't have to compile in that file. But since we are
already including it I think we might as well. What do you think?

[piman, 2016/04/19 23:29:57]

Yeah, I think I agree. I'm thinking that eventually we'll want to dynamically
load the loader anyway, at which point everything can compile, even on platforms
where Vulkan is not supported. We may want to keep a #ifdef in the lower levels
to avoid bringing too much code, but if we can avoid it in the higher levels,
it's probably more readable.

+  scoped_refptr<cc::VulkanInProcessContextProvider>
+  SharedVulkanContextProvider();
+#endif
+
   typedef std::map<ui::Compositor*, PerCompositorData*> PerCompositorDataMap;
   PerCompositorDataMap per_compositor_data_;
   scoped_refptr<ContextProviderCommandBuffer> shared_main_thread_contexts_;
   std::unique_ptr<GLHelper> gl_helper_;
   base::ObserverList<ImageTransportFactoryObserver> observer_list_;
   std::unique_ptr<cc::SurfaceManager> surface_manager_;
   uint32_t next_surface_id_namespace_;
   std::unique_ptr<cc::SingleThreadTaskGraphRunner> task_graph_runner_;
   scoped_refptr<ContextProviderCommandBuffer> shared_worker_context_provider_;
 
+#if defined(ENABLE_VULKAN)
+  bool shared_vulkan_context_provider_initialized_ = false;
+  scoped_refptr<cc::VulkanInProcessContextProvider>
+      shared_vulkan_context_provider_;
+#endif
+
 #if defined(OS_WIN)
   std::unique_ptr<OutputDeviceBacking> software_backing_;
 #endif
 
   // The contents of this map and its methods may only be used on the compositor
   // thread.
   IDMap<BrowserCompositorOutputSurface> output_surface_map_;
 
   base::WeakPtrFactory<GpuProcessTransportFactory> callback_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuProcessTransportFactory);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_COMPOSITOR_GPU_PROCESS_TRANSPORT_FACTORY_H_