diff --git a/android_webview/browser/gfx/aw_draw_fn_impl.cc b/android_webview/browser/gfx/aw_draw_fn_impl.cc
index 4d8eb96ad41184..ea0139c38bdfcc 100644
--- a/android_webview/browser/gfx/aw_draw_fn_impl.cc
+++ b/android_webview/browser/gfx/aw_draw_fn_impl.cc
@@ -280,8 +280,9 @@ void AwDrawFnImpl::InitVk(AwDrawFn_InitVkParams* params) {
   // We should never have a |vulkan_context_provider_| if we are calling VkInit.
   // This means context destroyed was not correctly called.
   DCHECK(!vulkan_context_provider_);
-  vulkan_context_provider_ =
-      AwVulkanContextProvider::GetOrCreateInstance(params);
+  vulkan_context_provider_ = AwVulkanContextProvider::Create(params);
+  render_thread_manager_.SetVulkanContextProviderOnRT(
+      vulkan_context_provider_.get());
 
   // Make sure we have a GL context.
   DCHECK(!gl_context_);
@@ -316,8 +317,8 @@ void AwDrawFnImpl::DrawVkDirect(AwDrawFn_DrawVkParams* params) {
     LOG(ERROR) << "Received invalid colorspace.";
     color_space = SkColorSpace::MakeSRGB();
   }
-  auto draw_context = CreateDrawContext(vulkan_context_provider_->gr_context(),
-                                        params, color_space);
+  auto draw_context = CreateDrawContext(
+      vulkan_context_provider_->GetGrContext(), params, color_space);
 
   // Set the draw contexct in |vulkan_context_provider_|, so the SkiaRenderer
   // and SkiaOutputSurface* will use it as frame render target.
@@ -437,16 +438,18 @@ void AwDrawFnImpl::DrawVkInterop(AwDrawFn_DrawVkParams* params) {
   }
 
   pending_draw->draw_context = CreateDrawContext(
-      vulkan_context_provider_->gr_context(), params, color_space);
+      vulkan_context_provider_->GetGrContext(), params, color_space);
 
   // If we have a |gl_done_fd|, create a Skia GrBackendSemaphore from
   // |gl_done_fd| and wait.
   if (gl_done_fd.is_valid()) {
     VkSemaphore gl_done_semaphore =
-        vulkan_context_provider_->implementation()->ImportSemaphoreHandle(
-            vulkan_context_provider_->device(),
-            gpu::SemaphoreHandle(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
-                                 std::move(gl_done_fd)));
+        vulkan_context_provider_->GetVulkanImplementation()
+            ->ImportSemaphoreHandle(
+                vulkan_context_provider_->device(),
+                gpu::SemaphoreHandle(
+                    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
+                    std::move(gl_done_fd)));
     if (gl_done_semaphore == VK_NULL_HANDLE) {
       LOG(ERROR) << "Could not create Vulkan semaphore for GL completion.";
       return;
@@ -485,7 +488,7 @@ void AwDrawFnImpl::DrawVkInterop(AwDrawFn_DrawVkParams* params) {
   GrBackendTexture backend_texture(params->width, params->height,
                                    pending_draw->image_info);
   pending_draw->ahb_skimage = SkImage::MakeFromTexture(
-      vulkan_context_provider_->gr_context(), backend_texture,
+      vulkan_context_provider_->GetGrContext(), backend_texture,
       kBottomLeft_GrSurfaceOrigin, kRGBA_8888_SkColorType, kPremul_SkAlphaType,
       color_space);
   if (!pending_draw->ahb_skimage) {
@@ -555,14 +558,14 @@ void AwDrawFnImpl::PostDrawVkInterop(AwDrawFn_PostDrawVkParams* params) {
   flushInfo.fNumSemaphores = 1;
   flushInfo.fSignalSemaphores = &gr_post_draw_semaphore;
   GrSemaphoresSubmitted submitted =
-      vulkan_context_provider_->gr_context()->flush(flushInfo);
-  vulkan_context_provider_->gr_context()->submit();
+      vulkan_context_provider_->GetGrContext()->flush(flushInfo);
+  vulkan_context_provider_->GetGrContext()->submit();
   if (submitted != GrSemaphoresSubmitted::kYes) {
     LOG(ERROR) << "Skia could not submit GrSemaphore.";
     return;
   }
   gpu::SemaphoreHandle semaphore_handle =
-      vulkan_context_provider_->implementation()->GetSemaphoreHandle(
+      vulkan_context_provider_->GetVulkanImplementation()->GetSemaphoreHandle(
           vulkan_context_provider_->device(),
           pending_draw->post_draw_semaphore);
   if (!semaphore_handle.is_valid()) {
@@ -625,7 +628,7 @@ AwDrawFnImpl::InFlightInteropDraw::~InFlightInteropDraw() {
     // to flush before the vkQueueWaitIdle below.
     if (ahb_skimage) {
       ahb_skimage.reset();
-      vk_context_provider->gr_context()->flushAndSubmit();
+      vk_context_provider->GetGrContext()->flushAndSubmit();
     }
     // We encountered an error and are not sure when our Vk objects are safe to
     // delete. VkQueueWaitIdle to ensure safety.
diff --git a/android_webview/browser/gfx/aw_vulkan_context_provider.cc b/android_webview/browser/gfx/aw_vulkan_context_provider.cc
index 5e748087fb2835..aaad08abac2d84 100644
--- a/android_webview/browser/gfx/aw_vulkan_context_provider.cc
+++ b/android_webview/browser/gfx/aw_vulkan_context_provider.cc
@@ -24,9 +24,9 @@
 
 namespace android_webview {
 
-namespace {
+AwVulkanContextProvider::Globals* AwVulkanContextProvider::g_globals = nullptr;
 
-AwVulkanContextProvider* g_vulkan_context_provider = nullptr;
+namespace {
 
 bool InitVulkanForWebView(VkInstance instance,
                           VkPhysicalDevice physical_device,
@@ -69,72 +69,39 @@ bool InitVulkanForWebView(VkInstance instance,
 }  // namespace
 
 // static
-scoped_refptr<AwVulkanContextProvider>
-AwVulkanContextProvider::GetOrCreateInstance(AwDrawFn_InitVkParams* params) {
-  if (g_vulkan_context_provider) {
-    DCHECK(!params || params->device == g_vulkan_context_provider->device());
-    DCHECK(!params || params->queue == g_vulkan_context_provider->queue());
-    return base::WrapRefCounted(g_vulkan_context_provider);
+scoped_refptr<AwVulkanContextProvider::Globals>
+AwVulkanContextProvider::Globals::GetOrCreateInstance(
+    AwDrawFn_InitVkParams* params) {
+  if (g_globals) {
+    DCHECK(params->device == g_globals->device_queue->GetVulkanDevice());
+    DCHECK(params->queue == g_globals->device_queue->GetVulkanQueue());
+    return base::WrapRefCounted(g_globals);
   }
-
-  auto provider = base::WrapRefCounted(new AwVulkanContextProvider);
-  if (!provider->Initialize(params))
+  auto globals = base::MakeRefCounted<AwVulkanContextProvider::Globals>();
+  if (!globals->Initialize(params))
     return nullptr;
-
-  return provider;
-}
-
-AwVulkanContextProvider::AwVulkanContextProvider() {
-  DCHECK_EQ(nullptr, g_vulkan_context_provider);
-  g_vulkan_context_provider = this;
-}
-
-AwVulkanContextProvider::~AwVulkanContextProvider() {
-  DCHECK_EQ(g_vulkan_context_provider, this);
-  g_vulkan_context_provider = nullptr;
-
-  draw_context_.reset();
-  gr_context_.reset();
-
-  device_queue_->Destroy();
-  device_queue_ = nullptr;
-}
-
-gpu::VulkanImplementation* AwVulkanContextProvider::GetVulkanImplementation() {
-  return implementation_.get();
-}
-
-gpu::VulkanDeviceQueue* AwVulkanContextProvider::GetDeviceQueue() {
-  return device_queue_.get();
+  return globals;
 }
 
-GrDirectContext* AwVulkanContextProvider::GetGrContext() {
-  return gr_context_.get();
+AwVulkanContextProvider::Globals::Globals() {
+  DCHECK_EQ(nullptr, g_globals);
+  g_globals = this;
 }
 
-GrVkSecondaryCBDrawContext*
-AwVulkanContextProvider::GetGrSecondaryCBDrawContext() {
-  return draw_context_.get();
-}
+AwVulkanContextProvider::Globals::~Globals() {
+  DCHECK_EQ(g_globals, this);
+  g_globals = nullptr;
 
-void AwVulkanContextProvider::EnqueueSecondaryCBSemaphores(
-    std::vector<VkSemaphore> semaphores) {
-  post_submit_semaphores_.reserve(post_submit_semaphores_.size() +
-                                  semaphores.size());
-  std::copy(semaphores.begin(), semaphores.end(),
-            std::back_inserter(post_submit_semaphores_));
+  gr_context.reset();
+  device_queue->Destroy();
+  device_queue = nullptr;
 }
 
-void AwVulkanContextProvider::EnqueueSecondaryCBPostSubmitTask(
-    base::OnceClosure closure) {
-  post_submit_tasks_.push_back(std::move(closure));
-}
-
-bool AwVulkanContextProvider::Initialize(AwDrawFn_InitVkParams* params) {
-  DCHECK(params);
+bool AwVulkanContextProvider::Globals::Initialize(
+    AwDrawFn_InitVkParams* params) {
   // Don't call init on implementation. Instead call InitVulkanForWebView,
   // which avoids creating a new instance.
-  implementation_ = gpu::CreateVulkanImplementation();
+  implementation = gpu::CreateVulkanImplementation();
 
   gfx::ExtensionSet instance_extensions;
   for (uint32_t i = 0; i < params->enabled_instance_extension_names_length; ++i)
@@ -151,8 +118,8 @@ bool AwVulkanContextProvider::Initialize(AwDrawFn_InitVkParams* params) {
     return false;
   }
 
-  device_queue_ = std::make_unique<gpu::VulkanDeviceQueue>(params->instance);
-  device_queue_->InitializeForWebView(
+  device_queue = std::make_unique<gpu::VulkanDeviceQueue>(params->instance);
+  device_queue->InitializeForWebView(
       params->physical_device, params->device, params->queue,
       params->graphics_queue_index, std::move(device_extensions));
 
@@ -178,18 +145,70 @@ bool AwVulkanContextProvider::Initialize(AwDrawFn_InitVkParams* params) {
       .fVkExtensions = &vk_extensions,
       .fDeviceFeatures = params->device_features,
       .fDeviceFeatures2 = params->device_features_2,
-      .fMemoryAllocator = gpu::CreateGrVkMemoryAllocator(device_queue_.get()),
+      .fMemoryAllocator = gpu::CreateGrVkMemoryAllocator(device_queue.get()),
       .fGetProc = get_proc,
       .fOwnsInstanceAndDevice = false,
   };
-  gr_context_ = GrDirectContext::MakeVulkan(backend_context);
-  if (!gr_context_) {
+  gr_context = GrDirectContext::MakeVulkan(backend_context);
+  if (!gr_context) {
     LOG(ERROR) << "Unable to initialize GrContext.";
     return false;
   }
   return true;
 }
 
+// static
+scoped_refptr<AwVulkanContextProvider> AwVulkanContextProvider::Create(
+    AwDrawFn_InitVkParams* params) {
+  auto provider = base::WrapRefCounted(new AwVulkanContextProvider);
+  if (!provider->Initialize(params))
+    return nullptr;
+
+  return provider;
+}
+
+AwVulkanContextProvider::AwVulkanContextProvider() = default;
+
+AwVulkanContextProvider::~AwVulkanContextProvider() {
+  draw_context_.reset();
+}
+
+gpu::VulkanImplementation* AwVulkanContextProvider::GetVulkanImplementation() {
+  return globals_->implementation.get();
+}
+
+gpu::VulkanDeviceQueue* AwVulkanContextProvider::GetDeviceQueue() {
+  return globals_->device_queue.get();
+}
+
+GrDirectContext* AwVulkanContextProvider::GetGrContext() {
+  return globals_->gr_context.get();
+}
+
+GrVkSecondaryCBDrawContext*
+AwVulkanContextProvider::GetGrSecondaryCBDrawContext() {
+  return draw_context_.get();
+}
+
+void AwVulkanContextProvider::EnqueueSecondaryCBSemaphores(
+    std::vector<VkSemaphore> semaphores) {
+  post_submit_semaphores_.reserve(post_submit_semaphores_.size() +
+                                  semaphores.size());
+  std::copy(semaphores.begin(), semaphores.end(),
+            std::back_inserter(post_submit_semaphores_));
+}
+
+void AwVulkanContextProvider::EnqueueSecondaryCBPostSubmitTask(
+    base::OnceClosure closure) {
+  post_submit_tasks_.push_back(std::move(closure));
+}
+
+bool AwVulkanContextProvider::Initialize(AwDrawFn_InitVkParams* params) {
+  DCHECK(params);
+  globals_ = Globals::GetOrCreateInstance(params);
+  return !!globals_;
+}
+
 void AwVulkanContextProvider::SecondaryCBDrawBegin(
     sk_sp<GrVkSecondaryCBDrawContext> draw_context) {
   DCHECK(draw_context);
@@ -202,7 +221,7 @@ void AwVulkanContextProvider::SecondaryCMBDrawSubmitted() {
   DCHECK(draw_context_);
   auto draw_context = std::move(draw_context_);
 
-  auto* fence_helper = device_queue_->GetFenceHelper();
+  auto* fence_helper = globals_->device_queue->GetFenceHelper();
   VkFence vk_fence = VK_NULL_HANDLE;
   auto result = fence_helper->GetFence(&vk_fence);
   DCHECK(result == VK_SUCCESS);
diff --git a/android_webview/browser/gfx/aw_vulkan_context_provider.h b/android_webview/browser/gfx/aw_vulkan_context_provider.h
index deb291415cb36f..3b0ddf8b94df14 100644
--- a/android_webview/browser/gfx/aw_vulkan_context_provider.h
+++ b/android_webview/browser/gfx/aw_vulkan_context_provider.h
@@ -42,8 +42,8 @@ class AwVulkanContextProvider final : public viz::VulkanContextProvider {
     DISALLOW_COPY_AND_ASSIGN(ScopedSecondaryCBDraw);
   };
 
-  static scoped_refptr<AwVulkanContextProvider> GetOrCreateInstance(
-      AwDrawFn_InitVkParams* params = nullptr);
+  static scoped_refptr<AwVulkanContextProvider> Create(
+      AwDrawFn_InitVkParams* params);
 
   // viz::VulkanContextProvider implementation:
   gpu::VulkanImplementation* GetVulkanImplementation() override;
@@ -54,13 +54,8 @@ class AwVulkanContextProvider final : public viz::VulkanContextProvider {
       std::vector<VkSemaphore> semaphores) override;
   void EnqueueSecondaryCBPostSubmitTask(base::OnceClosure closure) override;
 
-  VkPhysicalDevice physical_device() {
-    return device_queue_->GetVulkanPhysicalDevice();
-  }
-  VkDevice device() { return device_queue_->GetVulkanDevice(); }
-  VkQueue queue() { return device_queue_->GetVulkanQueue(); }
-  gpu::VulkanImplementation* implementation() { return implementation_.get(); }
-  GrDirectContext* gr_context() { return gr_context_.get(); }
+  VkDevice device() { return globals_->device_queue->GetVulkanDevice(); }
+  VkQueue queue() { return globals_->device_queue->GetVulkanQueue(); }
 
  private:
   friend class base::RefCounted<AwVulkanContextProvider>;
@@ -72,9 +67,24 @@ class AwVulkanContextProvider final : public viz::VulkanContextProvider {
   void SecondaryCBDrawBegin(sk_sp<GrVkSecondaryCBDrawContext> draw_context);
   void SecondaryCMBDrawSubmitted();
 
-  std::unique_ptr<gpu::VulkanImplementation> implementation_;
-  std::unique_ptr<gpu::VulkanDeviceQueue> device_queue_;
-  sk_sp<GrDirectContext> gr_context_;
+  struct Globals : base::RefCountedThreadSafe<Globals> {
+    static scoped_refptr<Globals> GetOrCreateInstance(
+        AwDrawFn_InitVkParams* params);
+
+    Globals();
+    bool Initialize(AwDrawFn_InitVkParams* params);
+
+    std::unique_ptr<gpu::VulkanImplementation> implementation;
+    std::unique_ptr<gpu::VulkanDeviceQueue> device_queue;
+    sk_sp<GrDirectContext> gr_context;
+
+   private:
+    friend base::RefCountedThreadSafe<Globals>;
+    ~Globals();
+  };
+  static Globals* g_globals;
+
+  scoped_refptr<Globals> globals_;
   sk_sp<GrVkSecondaryCBDrawContext> draw_context_;
   std::vector<base::OnceClosure> post_submit_tasks_;
   std::vector<VkSemaphore> post_submit_semaphores_;
diff --git a/android_webview/browser/gfx/hardware_renderer_single_thread.cc b/android_webview/browser/gfx/hardware_renderer_single_thread.cc
index 5c8914c2efccea..585ec24facbfec 100644
--- a/android_webview/browser/gfx/hardware_renderer_single_thread.cc
+++ b/android_webview/browser/gfx/hardware_renderer_single_thread.cc
@@ -51,8 +51,7 @@ HardwareRendererSingleThread::~HardwareRendererSingleThread() {
 
 void HardwareRendererSingleThread::DrawAndSwap(
     HardwareRendererDrawParams* params) {
-  TRACE_EVENT1("android_webview", "HardwareRendererSingleThread::DrawAndSwap",
-               "vulkan", surfaces_->is_using_vulkan());
+  TRACE_EVENT0("android_webview", "HardwareRendererSingleThread::DrawAndSwap");
 
   bool submitted_new_frame = false;
   uint32_t frame_token = 0u;
diff --git a/android_webview/browser/gfx/hardware_renderer_viz.cc b/android_webview/browser/gfx/hardware_renderer_viz.cc
index a862df4e90fbf6..6a771e9b882879 100644
--- a/android_webview/browser/gfx/hardware_renderer_viz.cc
+++ b/android_webview/browser/gfx/hardware_renderer_viz.cc
@@ -271,8 +271,9 @@ HardwareRendererViz::OnViz::GetPreferredFrameIntervalForFrameSinkId(
 
 HardwareRendererViz::HardwareRendererViz(
     RenderThreadManager* state,
-    RootFrameSinkGetter root_frame_sink_getter)
-    : HardwareRenderer(state) {
+    RootFrameSinkGetter root_frame_sink_getter,
+    AwVulkanContextProvider* context_provider)
+    : HardwareRenderer(state), output_surface_provider_(context_provider) {
   DCHECK_CALLED_ON_VALID_THREAD(render_thread_checker_);
   DCHECK(output_surface_provider_.renderer_settings().use_skia_renderer);
 
diff --git a/android_webview/browser/gfx/hardware_renderer_viz.h b/android_webview/browser/gfx/hardware_renderer_viz.h
index ed772501eaee2c..539912b8d841d9 100644
--- a/android_webview/browser/gfx/hardware_renderer_viz.h
+++ b/android_webview/browser/gfx/hardware_renderer_viz.h
@@ -16,10 +16,13 @@
 
 namespace android_webview {
 
+class AwVulkanContextProvider;
+
 class HardwareRendererViz : public HardwareRenderer {
  public:
   HardwareRendererViz(RenderThreadManager* state,
-                      RootFrameSinkGetter root_frame_sink_getter);
+                      RootFrameSinkGetter root_frame_sink_getter,
+                      AwVulkanContextProvider* context_provider);
   ~HardwareRendererViz() override;
 
   // HardwareRenderer overrides.
diff --git a/android_webview/browser/gfx/output_surface_provider_webview.cc b/android_webview/browser/gfx/output_surface_provider_webview.cc
index 9345092a680110..245e81ed726768 100644
--- a/android_webview/browser/gfx/output_surface_provider_webview.cc
+++ b/android_webview/browser/gfx/output_surface_provider_webview.cc
@@ -40,7 +40,9 @@ void OnContextLost(bool synthetic_loss) {
 
 }  // namespace
 
-OutputSurfaceProviderWebview::OutputSurfaceProviderWebview() {
+OutputSurfaceProviderWebview::OutputSurfaceProviderWebview(
+    AwVulkanContextProvider* vulkan_context_provider)
+    : vulkan_context_provider_(vulkan_context_provider) {
   // Should be kept in sync with compositor_impl_android.cc.
   renderer_settings_.allow_antialiasing = false;
   renderer_settings_.highp_threshold_min = 2048;
@@ -52,6 +54,8 @@ OutputSurfaceProviderWebview::OutputSurfaceProviderWebview() {
 
   auto* command_line = base::CommandLine::ForCurrentProcess();
   enable_vulkan_ = command_line->HasSwitch(switches::kWebViewEnableVulkan);
+  DCHECK(!enable_vulkan_ || vulkan_context_provider_);
+
   enable_shared_image_ =
       base::FeatureList::IsEnabled(features::kEnableSharedImageForWebview);
   LOG_IF(FATAL, enable_vulkan_ && !enable_shared_image_)
@@ -90,15 +94,11 @@ void OutputSurfaceProviderWebview::InitializeContext() {
         share_group.get(), gl_surface_.get(), gl::GLContextAttribs());
     gl_context->MakeCurrent(gl_surface_.get());
 
-    auto vulkan_context_provider =
-        enable_vulkan_ ? AwVulkanContextProvider::GetOrCreateInstance()
-                       : nullptr;
-
     shared_context_state_ = base::MakeRefCounted<gpu::SharedContextState>(
         share_group, gl_surface_, std::move(gl_context),
         false /* use_virtualized_gl_contexts */, base::BindOnce(&OnContextLost),
         GpuServiceWebView::GetInstance()->gpu_preferences().gr_context_type,
-        vulkan_context_provider.get());
+        vulkan_context_provider_);
     if (!enable_vulkan_) {
       auto feature_info = base::MakeRefCounted<gpu::gles2::FeatureInfo>(
           workarounds, GpuServiceWebView::GetInstance()->gpu_feature_info());
diff --git a/android_webview/browser/gfx/output_surface_provider_webview.h b/android_webview/browser/gfx/output_surface_provider_webview.h
index 3d629f5707d03d..dabb686900099d 100644
--- a/android_webview/browser/gfx/output_surface_provider_webview.h
+++ b/android_webview/browser/gfx/output_surface_provider_webview.h
@@ -23,9 +23,13 @@ class OutputSurface;
 
 namespace android_webview {
 
+class AwVulkanContextProvider;
+
+// Effectively a data struct to pass pointers from render thread to viz thread.
 class OutputSurfaceProviderWebview {
  public:
-  OutputSurfaceProviderWebview();
+  explicit OutputSurfaceProviderWebview(
+      AwVulkanContextProvider* vulkan_context_provider);
   ~OutputSurfaceProviderWebview();
 
   std::unique_ptr<viz::OutputSurface> CreateOutputSurface();
@@ -45,8 +49,9 @@ class OutputSurfaceProviderWebview {
  private:
   void InitializeContext();
 
+  AwVulkanContextProvider* const vulkan_context_provider_;
   // The member variables are effectively const after constructor, so it's safe
-  // to call accessors on different threads
+  // to call accessors on different threads.
   viz::RendererSettings renderer_settings_;
   viz::DebugRendererSettings debug_settings_;
   scoped_refptr<AwGLSurface> gl_surface_;
diff --git a/android_webview/browser/gfx/render_thread_manager.cc b/android_webview/browser/gfx/render_thread_manager.cc
index fa11fa61dc25f0..69a8669018524b 100644
--- a/android_webview/browser/gfx/render_thread_manager.cc
+++ b/android_webview/browser/gfx/render_thread_manager.cc
@@ -172,6 +172,12 @@ void RenderThreadManager::CommitFrameOnRT() {
     hardware_renderer_->CommitFrame();
 }
 
+void RenderThreadManager::SetVulkanContextProviderOnRT(
+    AwVulkanContextProvider* context_provider) {
+  DCHECK(!hardware_renderer_);
+  vulkan_context_provider_ = context_provider;
+}
+
 void RenderThreadManager::UpdateViewTreeForceDarkStateOnRT(
     bool view_tree_force_dark_state) {
   if (view_tree_force_dark_state_ == view_tree_force_dark_state)
@@ -199,8 +205,8 @@ void RenderThreadManager::DrawOnRT(bool save_restore,
         getter = root_frame_sink_getter_;
       }
       DCHECK(getter);
-      hardware_renderer_.reset(
-          new HardwareRendererViz(this, std::move(getter)));
+      hardware_renderer_.reset(new HardwareRendererViz(
+          this, std::move(getter), vulkan_context_provider_));
     } else {
       hardware_renderer_.reset(new HardwareRendererSingleThread(this));
     }
diff --git a/android_webview/browser/gfx/render_thread_manager.h b/android_webview/browser/gfx/render_thread_manager.h
index 5df11f0a3bec83..9f9a4bad31dab9 100644
--- a/android_webview/browser/gfx/render_thread_manager.h
+++ b/android_webview/browser/gfx/render_thread_manager.h
@@ -21,6 +21,7 @@
 
 namespace android_webview {
 
+class AwVulkanContextProvider;
 class ChildFrame;
 class CompositorFrameProducer;
 
@@ -60,6 +61,7 @@ class RenderThreadManager : public CompositorFrameConsumer {
       uint32_t layer_tree_frame_sink_id);
 
   void CommitFrameOnRT();
+  void SetVulkanContextProviderOnRT(AwVulkanContextProvider* context_provider);
   void UpdateViewTreeForceDarkStateOnRT(bool view_tree_force_dark_state);
   void DrawOnRT(bool save_restore, HardwareRendererDrawParams* params);
   void DestroyHardwareRendererOnRT(bool save_restore);
@@ -108,6 +110,7 @@ class RenderThreadManager : public CompositorFrameConsumer {
   // Accessed by RT thread.
   std::unique_ptr<HardwareRenderer> hardware_renderer_;
   bool view_tree_force_dark_state_ = false;
+  AwVulkanContextProvider* vulkan_context_provider_ = nullptr;
 
   // Accessed by both UI and RT thread.
   mutable base::Lock lock_;
diff --git a/android_webview/browser/gfx/surfaces_instance.cc b/android_webview/browser/gfx/surfaces_instance.cc
index 5d495a0fc8118a..f42e086a1ff96d 100644
--- a/android_webview/browser/gfx/surfaces_instance.cc
+++ b/android_webview/browser/gfx/surfaces_instance.cc
@@ -9,7 +9,6 @@
 #include <utility>
 
 #include "android_webview/browser/gfx/aw_render_thread_context_provider.h"
-#include "android_webview/browser/gfx/aw_vulkan_context_provider.h"
 #include "android_webview/browser/gfx/deferred_gpu_command_service.h"
 #include "android_webview/browser/gfx/gpu_service_web_view.h"
 #include "android_webview/browser/gfx/output_surface_provider_webview.h"
@@ -61,7 +60,8 @@ scoped_refptr<SurfacesInstance> SurfacesInstance::GetOrCreateInstance() {
 
 SurfacesInstance::SurfacesInstance()
     : frame_sink_id_allocator_(kDefaultClientId),
-      frame_sink_id_(AllocateFrameSinkId()) {
+      frame_sink_id_(AllocateFrameSinkId()),
+      output_surface_provider_(nullptr) {
   // The SharedBitmapManager is null as we do not support or use software
   // compositing on Android.
   frame_sink_manager_ = std::make_unique<viz::FrameSinkManagerImpl>(
diff --git a/android_webview/browser/gfx/surfaces_instance.h b/android_webview/browser/gfx/surfaces_instance.h
index ea3433a81d4cc4..7d8ef4f1d82d58 100644
--- a/android_webview/browser/gfx/surfaces_instance.h
+++ b/android_webview/browser/gfx/surfaces_instance.h
@@ -55,10 +55,6 @@ class SurfacesInstance : public base::RefCounted<SurfacesInstance>,
 
   void AddChildId(const viz::SurfaceId& child_id);
   void RemoveChildId(const viz::SurfaceId& child_id);
-  bool is_using_vulkan() const {
-    return output_surface_provider_.shared_context_state() &&
-           output_surface_provider_.shared_context_state()->GrContextIsVulkan();
-  }
 
  private:
   friend class base::RefCounted<SurfacesInstance>;