android_webview: Remove dependency on webkit's ContextProviderInProcess.

android_webview/browser/context_provider_in_process.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 "android_webview/browser/context_provider_in_process.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.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 "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/gl/SkNullGLContext.h"
 
 using gpu_blink::WebGraphicsContext3DInProcessCommandBufferImpl;
 
-namespace webkit {
-namespace gpu {
+namespace android_webview {
 
 class ContextProviderInProcess::LostContextCallbackProxy
     : public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback {
  public:
   explicit LostContextCallbackProxy(ContextProviderInProcess* provider)
       : provider_(provider) {
     provider_->context3d_->setContextLostCallback(this);
   }
 
   virtual ~LostContextCallbackProxy() {
@@ skipping 10 matching lines @@
 
 // static
 scoped_refptr<ContextProviderInProcess> ContextProviderInProcess::Create(
     scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> context3d,
     const std::string& debug_name) {
   if (!context3d)
     return NULL;
   return new ContextProviderInProcess(context3d.Pass(), debug_name);
 }
 
-// static
-scoped_refptr<ContextProviderInProcess>
-ContextProviderInProcess::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(
     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();
 }
@@ skipping 71 matching lines @@
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   return context3d_->GetContextSupport();
 }
 
 class GrContext* ContextProviderInProcess::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();
+  skia::RefPtr<class SkGLContext> gl_context =

[tfarina, 2015/04/13 22:52:28]

I copied this from cc/test/test_context_provide.cc

[boliu, 2015/04/14 00:29:52]

You are creating a *new* context for GrContext, but it should be returning
*this* context, if that makes sense..

+      skia::AdoptRef(SkNullGLContext::Create(kNone_GrGLStandard));
+  gl_context->makeCurrent();
+  gr_context_ = skia::AdoptRef(GrContext::Create(
+      kOpenGL_GrBackend, reinterpret_cast<GrBackendContext>(gl_context->gl())));
+
+  // If GlContext is already lost, also abandon the new GrContext.
+  if (IsContextLost())
+    gr_context_->abandonContext();
+
+  return gr_context_.get();
 }
 
 void ContextProviderInProcess::SetupLock() {
   context3d_->SetLock(&context_lock_);
 }
 
 base::Lock* ContextProviderInProcess::GetLock() {
   return &context_lock_;
 }
 
 bool ContextProviderInProcess::IsContextLost() {
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   return context3d_->isContextLost();
 }
 
 void ContextProviderInProcess::VerifyContexts() {
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (context3d_->isContextLost())
     OnLostContext();
 }
 
 void ContextProviderInProcess::DeleteCachedResources() {
-  DCHECK(context_thread_checker_.CalledOnValidThread());
-
-  if (gr_context_)
-    gr_context_->FreeGpuResources();
 }
 
 void ContextProviderInProcess::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() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   base::AutoLock lock(destroyed_lock_);
   return destroyed_;
 }
 
 void ContextProviderInProcess::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(
     const MemoryPolicyChangedCallback& memory_policy_changed_callback) {
   // There's no memory manager for the in-process implementation.
 }
 
-}  // namespace gpu
-}  // namespace webkit
+}  // namespace android_webview