content: Add public context creation API.

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 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.
 
 #include "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 #include <unordered_set>
@@ skipping 166 matching lines @@
     // -1.
     attributes.alpha_size = 0;
     attributes.red_size = 5;
     attributes.green_size = 6;
     attributes.blue_size = 5;
   }
 
   return attributes;
 }
 
+void CreateContextProviderAfterGpuChannelEstablished(
+    gpu::SurfaceHandle handle,
+    gpu::gles2::ContextCreationAttribHelper attributes,
+    gpu::SharedMemoryLimits shared_memory_limits,
+    Compositor::ContextProviderCallback callback,
+    scoped_refptr<gpu::GpuChannelHost> gpu_channel_host) {
+  if (!gpu_channel_host)
+    callback.Run(nullptr);
+
+  constexpr bool automatic_flushes = false;
+  constexpr bool support_locking = false;
+  scoped_refptr<ui::ContextProviderCommandBuffer> context_provider =
+      new ui::ContextProviderCommandBuffer(
+          std::move(gpu_channel_host), gpu::GPU_STREAM_DEFAULT,
+          gpu::GpuStreamPriority::NORMAL, handle,
+          GURL(std::string("chrome://gpu/Compositor::CreateContextProvider")),
+          automatic_flushes, support_locking, shared_memory_limits, attributes,
+          nullptr /* shared_context */,
+          ui::command_buffer_metrics::CONTEXT_TYPE_UNKNOWN);
+  callback.Run(std::move(context_provider));
+}
+
 class AndroidOutputSurface : public cc::OutputSurface {
  public:
   AndroidOutputSurface(
       scoped_refptr<ui::ContextProviderCommandBuffer> context_provider,
       base::Closure swap_buffers_callback)
       : cc::OutputSurface(std::move(context_provider)),
         swap_buffers_callback_(std::move(swap_buffers_callback)),
         overlay_candidate_validator_(
             new display_compositor::
                 CompositorOverlayCandidateValidatorAndroid()),
@@ skipping 151 matching lines @@
   return client ? new CompositorImpl(client, root_window) : NULL;
 }
 
 // static
 void Compositor::Initialize() {
   DCHECK(!CompositorImpl::IsInitialized());
   g_initialized = true;
 }
 
 // static
+void Compositor::CreateContextProvider(
+    gpu::SurfaceHandle handle,
+    gpu::gles2::ContextCreationAttribHelper attributes,
+    gpu::SharedMemoryLimits shared_memory_limits,
+    ContextProviderCallback callback) {
+  BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
+      base::Bind(&CreateContextProviderAfterGpuChannelEstablished, handle,
+                 attributes, shared_memory_limits, callback));
+}
+
+// static
 cc::SurfaceManager* CompositorImpl::GetSurfaceManager() {
   return &g_compositor_dependencies.Get().surface_manager;
 }
 
 // static
 cc::FrameSinkId CompositorImpl::AllocateFrameSinkId() {
   return g_compositor_dependencies.Get()
       .frame_sink_id_allocator.NextFrameSinkId();
 }
 
@@ skipping 453 matching lines @@
   }
   GetSurfaceManager()->UnregisterFrameSinkHierarchy(frame_sink_id_,
                                                     frame_sink_id);
 }
 
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content