ui/compositor: Provide its own 'in process' ContextProvider.

ui/compositor/test/in_process_context_provider.cc

 // Copyright (c) 2013 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 "webkit/common/gpu/context_provider_in_process.h"
+#include "ui/compositor/test/in_process_context_provider.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/debug/trace_event.h"
+#include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 #include "cc/output/managed_memory_policy.h"
 #include "gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
-#include "webkit/common/gpu/grcontext_for_webgraphicscontext3d.h"
+#include "gpu/command_buffer/client/gles2_lib.h"
+#include "gpu/skia_bindings/gl_bindings_skia_cmd_buffer.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 
 using gpu_blink::WebGraphicsContext3DInProcessCommandBufferImpl;
 
-namespace webkit {
-namespace gpu {
+namespace ui {
 
-class ContextProviderInProcess::LostContextCallbackProxy
+namespace {
+
+// Singleton used to initialize and terminate the gles2 library.
+class GLES2Initializer {
+ public:
+  GLES2Initializer() { gles2::Initialize(); }
+
+  ~GLES2Initializer() { gles2::Terminate(); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(GLES2Initializer);
+};
+
+base::LazyInstance<GLES2Initializer> g_gles2_initializer =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+class InProcessContextProvider::LostContextCallbackProxy
     : public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback {
  public:
-  explicit LostContextCallbackProxy(ContextProviderInProcess* provider)
+  explicit LostContextCallbackProxy(InProcessContextProvider* provider)
       : provider_(provider) {
     provider_->context3d_->setContextLostCallback(this);
   }
 
   virtual ~LostContextCallbackProxy() {
     provider_->context3d_->setContextLostCallback(NULL);
   }
 
   virtual void onContextLost() {
     provider_->OnLostContext();
   }
 
  private:
-  ContextProviderInProcess* provider_;
+  InProcessContextProvider* provider_;
 };
 
 // static
-scoped_refptr<ContextProviderInProcess> ContextProviderInProcess::Create(
+scoped_refptr<InProcessContextProvider> InProcessContextProvider::Create(
     scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> context3d,
     const std::string& debug_name) {
   if (!context3d)
     return NULL;
-  return new ContextProviderInProcess(context3d.Pass(), debug_name);
+  return new InProcessContextProvider(context3d.Pass(), debug_name);
 }
 
 // static
-scoped_refptr<ContextProviderInProcess>
-ContextProviderInProcess::CreateOffscreen(
+scoped_refptr<InProcessContextProvider>
+InProcessContextProvider::CreateOffscreen(
     bool lose_context_when_out_of_memory) {
   blink::WebGraphicsContext3D::Attributes attributes;
   attributes.depth = false;
   attributes.stencil = true;
   attributes.antialias = false;
   attributes.shareResources = true;
   attributes.noAutomaticFlushes = true;
 
   return Create(
       WebGraphicsContext3DInProcessCommandBufferImpl::CreateOffscreenContext(
           attributes, lose_context_when_out_of_memory),
       "Offscreen");
 }
 
-ContextProviderInProcess::ContextProviderInProcess(
+InProcessContextProvider::InProcessContextProvider(
     scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> context3d,
     const std::string& debug_name)
     : context3d_(context3d.Pass()),
       destroyed_(false),
       debug_name_(debug_name) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(context3d_);
   context_thread_checker_.DetachFromThread();
 }
 
-ContextProviderInProcess::~ContextProviderInProcess() {
+InProcessContextProvider::~InProcessContextProvider() {
   DCHECK(main_thread_checker_.CalledOnValidThread() ||
          context_thread_checker_.CalledOnValidThread());
 }
 
-blink::WebGraphicsContext3D* ContextProviderInProcess::WebContext3D() {
-  DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
-  DCHECK(context_thread_checker_.CalledOnValidThread());
-
-  return context3d_.get();
-}
-
-bool ContextProviderInProcess::BindToCurrentThread() {
+bool InProcessContextProvider::BindToCurrentThread() {
   DCHECK(context3d_);
 
   // This is called on the thread the context will be used.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (lost_context_callback_proxy_)
     return true;
 
   if (!context3d_->InitializeOnCurrentThread())
     return false;
 
   InitializeCapabilities();
 
   std::string unique_context_name =
       base::StringPrintf("%s-%p", debug_name_.c_str(), context3d_.get());
   context3d_->traceBeginCHROMIUM("gpu_toplevel",
                                  unique_context_name.c_str());
 
   lost_context_callback_proxy_.reset(new LostContextCallbackProxy(this));
   return true;
 }
 
-void ContextProviderInProcess::InitializeCapabilities() {
+void InProcessContextProvider::InitializeCapabilities() {
   capabilities_.gpu = context3d_->GetImplementation()->capabilities();
 
   size_t mapped_memory_limit = context3d_->GetMappedMemoryLimit();
   capabilities_.max_transfer_buffer_usage_bytes =
       mapped_memory_limit ==
               WebGraphicsContext3DInProcessCommandBufferImpl::kNoLimit
           ? std::numeric_limits<size_t>::max()
           : mapped_memory_limit;
 }
 
 cc::ContextProvider::Capabilities
-ContextProviderInProcess::ContextCapabilities() {
+InProcessContextProvider::ContextCapabilities() {
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
   DCHECK(context_thread_checker_.CalledOnValidThread());
   return capabilities_;
 }
 
-::gpu::gles2::GLES2Interface* ContextProviderInProcess::ContextGL() {
+::gpu::gles2::GLES2Interface* InProcessContextProvider::ContextGL() {
   DCHECK(context3d_);
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   return context3d_->GetGLInterface();
 }
 
-::gpu::ContextSupport* ContextProviderInProcess::ContextSupport() {
+::gpu::ContextSupport* InProcessContextProvider::ContextSupport() {
   DCHECK(context3d_);
   if (!lost_context_callback_proxy_)
     return NULL;  // Not bound to anything.
 
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   return context3d_->GetContextSupport();
 }
 
-class GrContext* ContextProviderInProcess::GrContext() {
+static void BindGrContextCallback(const GrGLInterface* interface) {
+  cc::ContextProvider* context_provider =
+      reinterpret_cast<InProcessContextProvider*>(interface->fCallbackData);
+
+  gles2::SetGLContext(context_provider->ContextGL());
+}
+
+class GrContext* InProcessContextProvider::GrContext() {
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (gr_context_)
-    return gr_context_->get();
+    return gr_context_.get();
 
-  gr_context_.reset(new GrContextForWebGraphicsContext3D(context3d_.get()));
-  return gr_context_->get();
+  // The GrGLInterface factory will make GL calls using the C GLES2 interface.
+  // Make sure the gles2 library is initialized first on exactly one thread.
+  g_gles2_initializer.Get();
+  gles2::SetGLContext(ContextGL());
+
+  skia::RefPtr<GrGLInterface> interface =
+      skia::AdoptRef(skia_bindings::CreateCommandBufferSkiaGLBinding());
+  interface->fCallback = BindGrContextCallback;
+  interface->fCallbackData = reinterpret_cast<GrGLInterfaceCallbackData>(this);
+
+  gr_context_ = skia::AdoptRef(GrContext::Create(
+      kOpenGL_GrBackend, reinterpret_cast<GrBackendContext>(interface.get())));
+
+  return gr_context_.get();
 }
 
-bool ContextProviderInProcess::IsContextLost() {
+bool InProcessContextProvider::IsContextLost() {
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   return context3d_->isContextLost();
 }
 
-void ContextProviderInProcess::VerifyContexts() {
+void InProcessContextProvider::VerifyContexts() {
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (context3d_->isContextLost())
     OnLostContext();
 }
 
-void ContextProviderInProcess::DeleteCachedResources() {
+void InProcessContextProvider::DeleteCachedResources() {
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
-  if (gr_context_)
-    gr_context_->FreeGpuResources();
+  if (gr_context_) {
+    TRACE_EVENT_INSTANT0("gpu", "GrContext::freeGpuResources", \

[piman, 2015/01/21 02:07:36]

nit: no need for \

+        TRACE_EVENT_SCOPE_THREAD);
+    gr_context_->freeGpuResources();
+  }
 }
 
-void ContextProviderInProcess::OnLostContext() {
+void InProcessContextProvider::OnLostContext() {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   {
     base::AutoLock lock(destroyed_lock_);
     if (destroyed_)
       return;
     destroyed_ = true;
   }
   if (!lost_context_callback_.is_null())
     base::ResetAndReturn(&lost_context_callback_).Run();
   if (gr_context_)
-    gr_context_->OnLostContext();
+    gr_context_->abandonContext();
 }
 
-bool ContextProviderInProcess::DestroyedOnMainThread() {
+bool InProcessContextProvider::DestroyedOnMainThread() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   base::AutoLock lock(destroyed_lock_);
   return destroyed_;
 }
 
-void ContextProviderInProcess::SetLostContextCallback(
+void InProcessContextProvider::SetLostContextCallback(
     const LostContextCallback& lost_context_callback) {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   DCHECK(lost_context_callback_.is_null() ||
          lost_context_callback.is_null());
   lost_context_callback_ = lost_context_callback;
 }
 
-void ContextProviderInProcess::SetMemoryPolicyChangedCallback(
+void InProcessContextProvider::SetMemoryPolicyChangedCallback(
     const MemoryPolicyChangedCallback& memory_policy_changed_callback) {
   // There's no memory manager for the in-process implementation.
 }
 
-}  // namespace gpu
-}  // namespace webkit
+}  // namespace ui