aw: Switch instrumentation shell to SurfaceView

Also refactor the fake draw_fn implementation. This is to prepare for
adding a vulkan draw_fn implementation.

Split draw_fn implementation into:
allocator.cc/h: Controls functor data lifetime
context_manager: Effectively global. Responsible for owning the surface
                 and EGL context. Calls sync/draw/context_destroyed on
                 functor and responsible for owning the "impl reference"
                 to functor data.

context_manager uses EGL bindings from ui/gl, but nothing else
to avoid conflicting with chromium side implementations, and to avoid
initializing a TaskRunner on render thread. Only GLES call is
glReadPixels after draw, which relies on chromium implementation not
releasing its bindings after draw.

Refactor and simplify the java side by explicitly adding a thread to
post tasks and a WaitableEvent; this avoids saving state and using
a Lock object.

Cq-Include-Trybots: luci.chromium.try:gpu-fyi-try-android-m-nexus-5x-64
Bug: 1141687
Change-Id: I71752b31f401fdb277062fe1347dfa826a20bb81
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2587238
Auto-Submit: Bo <boliu@chromium.org>
Commit-Queue: Jonathan Backer <backer@chromium.org>
Reviewed-by: Jonathan Backer <backer@chromium.org>
Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#837094}

android_webview/test/BUILD.gn

@@ -74,7 +74,7 @@ android_apk("webview_instrumentation_apk") {
     "shell/src/org/chromium/android_webview/shell/AwShellApplication.java",
     "shell/src/org/chromium/android_webview/shell/AwShellResourceProvider.java",
     "shell/src/org/chromium/android_webview/shell/AwShellSwitches.java",
-    "shell/src/org/chromium/android_webview/shell/DrawFn.java",
+    "shell/src/org/chromium/android_webview/shell/ContextManager.java",
     "shell/src/org/chromium/android_webview/test/AwJUnit4ClassRunner.java",
     "shell/src/org/chromium/android_webview/test/AwTestContainerView.java",
     "shell/src/org/chromium/android_webview/test/AwTestRunnerActivity.java",
@@ -137,12 +137,24 @@ android_assets("webview_instrumentation_apk_assets") {
   }
 }
 
+generate_jni("draw_fn_impl_jni_headers") {
+  sources =
+      [ "shell/src/org/chromium/android_webview/shell/ContextManager.java" ]
+}
+
 shared_library("libstandalonelibwebviewchromium") {
   testonly = true
-  sources = [ "shell/src/draw_gl/draw_fn.cc" ]
+  sources = [
+    "shell/src/draw_fn/allocator.cc",
+    "shell/src/draw_fn/allocator.h",
+    "shell/src/draw_fn/context_manager.cc",
+    "shell/src/draw_fn/context_manager.h",
+  ]
   ldflags = [ "-Wl,-shared,-Bsymbolic" ]
   deps = [
+    ":draw_fn_impl_jni_headers",
     ":webview_instrumentation_test_native_jni_impl",
+    "//android_webview/browser/gfx",
     "//android_webview/lib",
     "//android_webview/lib:webview_entry_point",
     "//android_webview/nonembedded",
@@ -151,7 +163,9 @@ shared_library("libstandalonelibwebviewchromium") {
     "//components/autofill/android/provider/test_support:component_autofill_provider_native_test_support",
     "//components/heap_profiling/multi_process:test_support",
     "//content/public/test/android:content_native_test_support",
+    "//ui/gl",
   ]
+  libs = [ "android" ]
   configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
   configs += [ "//build/config/android:hide_all_but_jni" ]
 }

android_webview/test/shell/src/draw_fn/DEPS

+include_rules = [
+  "-android_webview",
+  "+android_webview/public/browser",
+  "+android_webview/test/draw_fn_impl_jni_headers",
+  "+android_webview/test/shell/src/draw_fn",
+
+  # For initializing GL bindings
+  "+android_webview/browser/gfx/gpu_service_web_view.h",
+
+  # For EGL bindings
+  "+ui/gl/gl_bindings.h",
+]

android_webview/test/shell/src/draw_fn/allocator.cc

+// Copyright 2018 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 "android_webview/test/shell/src/draw_fn/allocator.h"
+
+#include "android_webview/public/browser/draw_fn.h"
+#include "base/logging.h"
+#include "base/notreached.h"
+
+namespace draw_fn {
+
+namespace {
+
+AwDrawFnRenderMode QueryRenderMode() {
+  return AW_DRAW_FN_RENDER_MODE_OPENGL_ES;
+}
+
+int CreateFunctor(void* data, AwDrawFnFunctorCallbacks* functor_callbacks) {
+  NOTREACHED();
+  return 0;
+}
+
+int CreateFunctor_v3(void* data,
+                     int version,
+                     AwDrawFnFunctorCallbacks* functor_callbacks) {
+  DCHECK_EQ(version, 3);
+  return Allocator::Get()->allocate(data, functor_callbacks);
+}
+
+void ReleaseFunctor(int functor) {
+  Allocator::Get()->MarkReleasedByFunctor(functor);
+}
+
+}  // namespace
+
+AwDrawFnFunctionTable* GetDrawFnFunctionTable() {
+  static AwDrawFnFunctionTable table{kAwDrawFnVersion, &QueryRenderMode,
+                                     &CreateFunctor, &ReleaseFunctor,
+                                     &CreateFunctor_v3};
+  return &table;
+}
+
+// static
+Allocator* Allocator::Get() {
+  static base::NoDestructor<Allocator> map;
+  return map.get();
+}
+
+Allocator::Allocator() = default;
+Allocator::~Allocator() = default;
+
+int Allocator::allocate(void* data,
+                        AwDrawFnFunctorCallbacks* functor_callbacks) {
+  base::AutoLock lock(lock_);
+  int functor = next_functor_++;
+  map_.emplace(functor, FunctorData{functor, data, functor_callbacks});
+  return functor;
+}
+
+FunctorData Allocator::get(int functor) {
+  base::AutoLock lock(lock_);
+  auto itr = map_.find(functor);
+  DCHECK(itr != map_.end());
+  return itr->second;
+}
+
+void Allocator::MarkReleasedByFunctor(int functor) {
+  base::AutoLock lock(lock_);
+  auto itr = map_.find(functor);
+  DCHECK(itr != map_.end());
+  DCHECK(!itr->second.released_by_functor);
+  itr->second.released_by_functor = true;
+  MaybeReleaseFunctorAlreadyLocked(functor);
+}
+
+void Allocator::MarkReleasedByManager(int functor) {
+  base::AutoLock lock(lock_);
+  auto itr = map_.find(functor);
+  DCHECK(itr != map_.end());
+  DCHECK(!itr->second.released_by_manager);
+  MaybeReleaseFunctorAlreadyLocked(functor);
+}
+
+void Allocator::MaybeReleaseFunctorAlreadyLocked(int functor) {
+  lock_.AssertAcquired();
+  auto itr = map_.find(functor);
+  const FunctorData& data = itr->second;
+  if (data.released_by_functor && data.released_by_manager) {
+    data.functor_callbacks->on_destroyed(data.functor, data.data);
+    map_.erase(itr);
+  }
+}
+
+}  // namespace draw_fn

android_webview/test/shell/src/draw_fn/allocator.h

+// Copyright 2020 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 ANDROID_WEBVIEW_TEST_SHELL_SRC_DRAW_FN_ALLOCATOR_H_
+#define ANDROID_WEBVIEW_TEST_SHELL_SRC_DRAW_FN_ALLOCATOR_H_
+
+#include "android_webview/public/browser/draw_fn.h"
+#include "base/containers/flat_map.h"
+#include "base/no_destructor.h"
+#include "base/synchronization/lock.h"
+
+namespace draw_fn {
+
+AwDrawFnFunctionTable* GetDrawFnFunctionTable();
+
+struct FunctorData {
+  int functor = 0;
+  void* data = nullptr;
+  AwDrawFnFunctorCallbacks* functor_callbacks = nullptr;
+  bool released_by_functor = false;
+  bool released_by_manager = false;
+};
+
+class Allocator {
+ public:
+  static Allocator* Get();
+
+  int allocate(void* data, AwDrawFnFunctorCallbacks* functor_callbacks);
+  FunctorData get(int functor);
+  void MarkReleasedByFunctor(int functor);
+  void MarkReleasedByManager(int functor);
+
+ private:
+  friend base::NoDestructor<Allocator>;
+
+  void MaybeReleaseFunctorAlreadyLocked(int functor);
+
+  Allocator();
+  ~Allocator();
+
+  base::Lock lock_;
+  base::flat_map<int, FunctorData> map_;
+  int next_functor_ = 1;
+};
+
+}  // namespace draw_fn
+
+#endif  // ANDROID_WEBVIEW_TEST_SHELL_SRC_DRAW_FN_ALLOCATOR_H_

android_webview/test/shell/src/draw_fn/context_manager.cc

+// Copyright 2020 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 "android_webview/test/shell/src/draw_fn/context_manager.h"
+
+#include <android/native_window_jni.h>
+
+#include "android_webview/browser/gfx/gpu_service_web_view.h"
+#include "android_webview/public/browser/draw_fn.h"
+#include "android_webview/test/draw_fn_impl_jni_headers/ContextManager_jni.h"
+#include "android_webview/test/shell/src/draw_fn/allocator.h"
+#include "base/android/jni_array.h"
+#include "base/logging.h"
+#include "base/notreached.h"
+#include "ui/gl/gl_bindings.h"
+
+namespace draw_fn {
+
+static jlong JNI_ContextManager_GetDrawFnFunctionTable(JNIEnv* env) {
+  return reinterpret_cast<intptr_t>(draw_fn::GetDrawFnFunctionTable());
+}
+
+static jlong JNI_ContextManager_Init(JNIEnv* env) {
+  return reinterpret_cast<intptr_t>(new ContextManager);
+}
+
+ContextManager::ContextManager() = default;
+
+ContextManager::~ContextManager() {
+  DestroyContext();
+}
+
+void ContextManager::SetSurface(
+    JNIEnv* env,
+    const base::android::JavaRef<jobject>& surface) {
+  if (!java_surface_.is_null()) {
+    DestroyContext();
+  }
+  if (!surface.is_null()) {
+    CreateContext(env, surface);
+  }
+}
+
+void ContextManager::Sync(JNIEnv* env, int functor, bool apply_force_dark) {
+  if (current_functor_ && current_functor_ != functor) {
+    FunctorData data = Allocator::Get()->get(current_functor_);
+    data.functor_callbacks->on_context_destroyed(data.functor, data.data);
+    Allocator::Get()->MarkReleasedByManager(current_functor_);
+  }
+  current_functor_ = functor;
+
+  FunctorData data = Allocator::Get()->get(current_functor_);
+  AwDrawFn_OnSyncParams params{kAwDrawFnVersion, apply_force_dark};
+  data.functor_callbacks->on_sync(current_functor_, data.data, &params);
+}
+
+namespace {
+
+ASurfaceControl* GetSurfaceControl() {
+  NOTREACHED();
+  return nullptr;
+}
+
+void MergeTransaction(ASurfaceTransaction* transaction) {
+  NOTREACHED();
+}
+
+EGLDisplay GetDisplay() {
+  static EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  CHECK_NE(display, EGL_NO_DISPLAY);
+  return display;
+}
+
+int rgbaToArgb(GLubyte* bytes) {
+  return (bytes[3] & 0xff) << 24 | (bytes[0] & 0xff) << 16 |
+         (bytes[1] & 0xff) << 8 | (bytes[2] & 0xff);
+}
+
+}  // namespace
+
+base::android::ScopedJavaLocalRef<jintArray> ContextManager::Draw(
+    JNIEnv* env,
+    int width,
+    int height,
+    int scroll_x,
+    int scroll_y,
+    jboolean readback_quadrants) {
+  int results[] = {0, 0, 0, 0};
+  if (!context_ || !current_functor_) {
+    LOG(ERROR) << "Draw failed. context:" << context_
+               << " functor:" << current_functor_;
+    return readback_quadrants ? base::android::ToJavaIntArray(env, results)
+                              : nullptr;
+  }
+
+  MakeCurrent();
+
+  FunctorData data = Allocator::Get()->get(current_functor_);
+  AwDrawFn_DrawGLParams params{kAwDrawFnVersion};
+  params.width = width;
+  params.height = height;
+  params.clip_left = 0;
+  params.clip_top = 0;
+  params.clip_bottom = height;
+  params.clip_right = width;
+  params.transform[0] = 1.0;
+  params.transform[1] = 0.0;
+  params.transform[2] = 0.0;
+  params.transform[3] = 0.0;
+
+  params.transform[4] = 0.0;
+  params.transform[5] = 1.0;
+  params.transform[6] = 0.0;
+  params.transform[7] = 0.0;
+
+  params.transform[8] = 0.0;
+  params.transform[9] = 0.0;
+  params.transform[10] = 1.0;
+  params.transform[11] = 0.0;
+
+  params.transform[12] = -scroll_x;
+  params.transform[13] = -scroll_y;
+  params.transform[14] = 0.0;
+  params.transform[15] = 1.0;
+
+  // Hard coded value for sRGB.
+  params.transfer_function_g = 2.4f;
+  params.transfer_function_a = 0.947867f;
+  params.transfer_function_b = 0.0521327f;
+  params.transfer_function_c = 0.0773994f;
+  params.transfer_function_d = 0.0404499f;
+  params.transfer_function_e = 0.f;
+  params.transfer_function_f = 0.f;
+  params.color_space_toXYZD50[0] = 0.436028f;
+  params.color_space_toXYZD50[1] = 0.385101f;
+  params.color_space_toXYZD50[2] = 0.143091f;
+  params.color_space_toXYZD50[3] = 0.222479f;
+  params.color_space_toXYZD50[4] = 0.716897f;
+  params.color_space_toXYZD50[5] = 0.0606241f;
+  params.color_space_toXYZD50[6] = 0.0139264f;
+  params.color_space_toXYZD50[7] = 0.0970921f;
+  params.color_space_toXYZD50[8] = 0.714191;
+
+  params.overlays_mode = AW_DRAW_FN_OVERLAYS_MODE_DISABLED;
+  params.get_surface_control = GetSurfaceControl;
+  params.merge_transaction = MergeTransaction;
+
+  data.functor_callbacks->draw_gl(current_functor_, data.data, &params);
+
+  if (readback_quadrants) {
+    int quarter_width = width / 4;
+    int quarter_height = height / 4;
+    GLubyte bytes[4] = {};
+    glReadPixels(quarter_width, quarter_height * 3, 1, 1, GL_RGBA,
+                 GL_UNSIGNED_BYTE, bytes);
+    results[0] = rgbaToArgb(bytes);
+    glReadPixels(quarter_width * 3, quarter_height * 3, 1, 1, GL_RGBA,
+                 GL_UNSIGNED_BYTE, bytes);
+    results[1] = rgbaToArgb(bytes);
+    glReadPixels(quarter_width, quarter_height, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+                 bytes);
+    results[2] = rgbaToArgb(bytes);
+    glReadPixels(quarter_width * 3, quarter_height, 1, 1, GL_RGBA,
+                 GL_UNSIGNED_BYTE, bytes);
+    results[3] = rgbaToArgb(bytes);
+  }
+
+  CHECK(eglSwapBuffers(GetDisplay(), surface_));
+
+  return readback_quadrants ? base::android::ToJavaIntArray(env, results)
+                            : nullptr;
+}
+
+namespace {
+
+EGLConfig GetConfig(bool* out_use_es3) {
+  static EGLConfig config = nullptr;
+  static bool use_es3 = false;
+  if (config) {
+    *out_use_es3 = use_es3;
+    return config;
+  }
+
+  for (bool try_es3 : std::vector<bool>{true, false}) {
+    EGLint config_attribs[] = {
+        EGL_BUFFER_SIZE,
+        32,
+        EGL_ALPHA_SIZE,
+        8,
+        EGL_BLUE_SIZE,
+        8,
+        EGL_GREEN_SIZE,
+        8,
+        EGL_RED_SIZE,
+        8,
+        EGL_SAMPLES,
+        -1,
+        EGL_DEPTH_SIZE,
+        -1,
+        EGL_STENCIL_SIZE,
+        -1,
+        EGL_RENDERABLE_TYPE,
+        try_es3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT,
+        EGL_SURFACE_TYPE,
+        EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
+        EGL_NONE};
+    EGLint num_configs = 0;
+    if (!eglChooseConfig(GetDisplay(), config_attribs, nullptr, 0,
+                         &num_configs) ||
+        num_configs == 0) {
+      continue;
+    }
+
+    CHECK(eglChooseConfig(GetDisplay(), config_attribs, &config, 1,
+                          &num_configs));
+    use_es3 = try_es3;
+    break;
+  }
+
+  CHECK(config);
+  *out_use_es3 = use_es3;
+  return config;
+}
+}  // namespace
+
+void ContextManager::CreateContext(
+    JNIEnv* env,
+    const base::android::JavaRef<jobject>& surface) {
+  // Initialize bindings.
+  android_webview::GpuServiceWebView::GetInstance();
+
+  java_surface_.Reset(surface);
+  if (java_surface_.is_null())
+    return;
+
+  native_window_ = ANativeWindow_fromSurface(env, surface.obj());
+  CHECK(native_window_);
+
+  bool use_es3 = false;
+  {
+    std::vector<EGLint> egl_window_attributes;
+    egl_window_attributes.push_back(EGL_NONE);
+    surface_ =
+        eglCreateWindowSurface(GetDisplay(), GetConfig(&use_es3),
+                               native_window_, &egl_window_attributes[0]);
+    CHECK(surface_);
+  }
+
+  {
+    std::vector<EGLint> context_attributes;
+    context_attributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
+    context_attributes.push_back(use_es3 ? 3 : 2);
+    context_attributes.push_back(EGL_NONE);
+
+    CHECK(eglBindAPI(EGL_OPENGL_ES_API));
+
+    context_ = eglCreateContext(GetDisplay(), GetConfig(&use_es3), nullptr,
+                                context_attributes.data());
+    CHECK(context_);
+  }
+}
+
+void ContextManager::DestroyContext() {
+  if (java_surface_.is_null())
+    return;
+
+  if (current_functor_) {
+    MakeCurrent();
+    FunctorData data = Allocator::Get()->get(current_functor_);
+    data.functor_callbacks->on_context_destroyed(data.functor, data.data);
+  }
+
+  DCHECK(context_);
+  CHECK(eglDestroyContext(GetDisplay(), context_));
+  context_ = nullptr;
+
+  DCHECK(surface_);
+  CHECK(eglDestroySurface(GetDisplay(), surface_));
+  surface_ = nullptr;
+  ANativeWindow_release(native_window_);
+  java_surface_.Reset();
+}
+
+void ContextManager::MakeCurrent() {
+  DCHECK(surface_);
+  DCHECK(context_);
+  CHECK(eglMakeCurrent(GetDisplay(), surface_, surface_, context_));
+}
+
+}  // namespace draw_fn

android_webview/test/shell/src/draw_fn/context_manager.h

+// Copyright 2020 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 ANDROID_WEBVIEW_TEST_SHELL_SRC_DRAW_FN_CONTEXT_MANAGER_H_
+#define ANDROID_WEBVIEW_TEST_SHELL_SRC_DRAW_FN_CONTEXT_MANAGER_H_
+
+#include <android/native_window.h>
+#include <jni.h>
+
+#include "base/android/scoped_java_ref.h"
+
+typedef void* EGLContext;
+typedef void* EGLSurface;
+
+namespace draw_fn {
+
+class ContextManager {
+ public:
+  ContextManager();
+  ~ContextManager();
+
+  void SetSurface(JNIEnv* env, const base::android::JavaRef<jobject>& surface);
+  void Sync(JNIEnv* env, int functor, bool apply_force_dark);
+  base::android::ScopedJavaLocalRef<jintArray> Draw(
+      JNIEnv* env,
+      int width,
+      int height,
+      int scroll_x,
+      int scroll_y,
+      jboolean readback_quadrants);
+
+ private:
+  void CreateContext(JNIEnv* env,
+                     const base::android::JavaRef<jobject>& surface);
+  void DestroyContext();
+  void MakeCurrent();
+
+  base::android::ScopedJavaGlobalRef<jobject> java_surface_;
+  ANativeWindow* native_window_ = nullptr;
+  EGLSurface surface_ = nullptr;
+  EGLContext context_ = nullptr;
+
+  int current_functor_ = 0;
+};
+
+}  // namespace draw_fn
+
+#endif  // ANDROID_WEBVIEW_TEST_SHELL_SRC_DRAW_FN_CONTEXT_MANAGER_H_

android_webview/test/shell/src/draw_gl/DEPS

-include_rules = [
-  # draw_gl compiles its own shared library for a single entry point
-  # for testing. Therefore it cannot depend on any other module,
-  # except for shared definitions.
-  "-android_webview",
-  "+android_webview/public/browser",
-]

android_webview/test/shell/src/draw_gl/draw_fn.cc

-// Copyright 2018 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 <jni.h>
-
-#include "android_webview/public/browser/draw_fn.h"
-#include "base/containers/flat_map.h"
-#include "base/logging.h"
-#include "base/no_destructor.h"
-#include "base/notreached.h"
-#include "base/synchronization/lock.h"
-
-namespace {
-
-struct FunctorData {
-  int functor = 0;
-  void* data = nullptr;
-  AwDrawFnFunctorCallbacks* functor_callbacks = nullptr;
-  bool released = false;
-};
-
-class FunctorMap {
- public:
-  int allocate(void* data, AwDrawFnFunctorCallbacks* functor_callbacks) {
-    base::AutoLock lock(lock_);
-    int functor = next_functor_++;
-    map_.emplace(functor, FunctorData{functor, data, functor_callbacks});
-    return functor;
-  }
-
-  FunctorData get(int functor) {
-    base::AutoLock lock(lock_);
-    auto itr = map_.find(functor);
-    DCHECK(itr != map_.end());
-    return itr->second;
-  }
-
-  void mark_released(int functor) {
-    base::AutoLock lock(lock_);
-    auto itr = map_.find(functor);
-    DCHECK(itr != map_.end());
-    DCHECK(!itr->second.released);
-    itr->second.released = true;
-  }
-
-  void destroy_released() {
-    base::AutoLock lock(lock_);
-    for (auto itr = map_.begin(); itr != map_.end();) {
-      FunctorData& data = itr->second;
-      if (data.released) {
-        // Holding lock here, but not too terrible.
-        data.functor_callbacks->on_context_destroyed(data.functor, data.data);
-        data.functor_callbacks->on_destroyed(data.functor, data.data);
-        itr = map_.erase(itr);
-      } else {
-        DLOG(ERROR) << "Functor not released. Possibly leaking instead";
-        ++itr;
-      }
-    }
-  }
-
-  static FunctorMap* Get() {
-    static base::NoDestructor<FunctorMap> map;
-    return map.get();
-  }
-
- private:
-  base::Lock lock_;
-  base::flat_map<int, FunctorData> map_;
-  int next_functor_ = 1;
-};
-
-AwDrawFnRenderMode QueryRenderMode() {
-  return AW_DRAW_FN_RENDER_MODE_OPENGL_ES;
-}
-
-int CreateFunctor(void* data, AwDrawFnFunctorCallbacks* functor_callbacks) {
-  DCHECK(false);
-  NOTREACHED();
-  return 0;
-}
-
-int CreateFunctor_v3(void* data,
-                     int version,
-                     AwDrawFnFunctorCallbacks* functor_callbacks) {
-  DCHECK_EQ(version, 3);
-  return FunctorMap::Get()->allocate(data, functor_callbacks);
-}
-
-void ReleaseFunctor(int functor) {
-  FunctorMap::Get()->mark_released(functor);
-}
-
-ASurfaceControl* GetSurfaceControl() {
-  NOTREACHED();
-  return nullptr;
-}
-
-void MergeTransaction(ASurfaceTransaction* transaction) {
-  NOTREACHED();
-}
-
-}  // namespace
-
-extern "C" {
-
-JNIEXPORT jlong JNICALL
-Java_org_chromium_android_1webview_shell_DrawFn_nativeGetDrawFnFunctionTable(
-    JNIEnv*,
-    jclass) {
-  static AwDrawFnFunctionTable table{kAwDrawFnVersion, &QueryRenderMode,
-                                     &CreateFunctor, &ReleaseFunctor,
-                                     &CreateFunctor_v3};
-  return reinterpret_cast<intptr_t>(&table);
-}
-
-JNIEXPORT void JNICALL
-Java_org_chromium_android_1webview_shell_DrawFn_nativeSync(
-    JNIEnv*,
-    jclass,
-    jint functor,
-    jboolean force_apply_dark) {
-  FunctorData data = FunctorMap::Get()->get(functor);
-  AwDrawFn_OnSyncParams params{kAwDrawFnVersion, force_apply_dark};
-  data.functor_callbacks->on_sync(functor, data.data, &params);
-}
-
-JNIEXPORT void JNICALL
-Java_org_chromium_android_1webview_shell_DrawFn_nativeDestroyReleased(JNIEnv*,
-                                                                      jclass) {
-  FunctorMap::Get()->destroy_released();
-}
-
-JNIEXPORT void JNICALL
-Java_org_chromium_android_1webview_shell_DrawFn_nativeDestroyed(JNIEnv*,
-                                                                jclass,
-                                                                jint functor) {}
-
-JNIEXPORT void JNICALL
-Java_org_chromium_android_1webview_shell_DrawFn_nativeDrawGL(JNIEnv*,
-                                                             jclass,
-                                                             jint functor,
-                                                             jint width,
-                                                             jint height,
-                                                             jint scroll_x,
-                                                             jint scroll_y) {
-  FunctorData data = FunctorMap::Get()->get(functor);
-  AwDrawFn_DrawGLParams params{kAwDrawFnVersion};
-  params.width = width;
-  params.height = height;
-  params.clip_left = 0;
-  params.clip_top = 0;
-  params.clip_bottom = height;
-  params.clip_right = width;
-  params.transform[0] = 1.0;
-  params.transform[1] = 0.0;
-  params.transform[2] = 0.0;
-  params.transform[3] = 0.0;
-
-  params.transform[4] = 0.0;
-  params.transform[5] = 1.0;
-  params.transform[6] = 0.0;
-  params.transform[7] = 0.0;
-
-  params.transform[8] = 0.0;
-  params.transform[9] = 0.0;
-  params.transform[10] = 1.0;
-  params.transform[11] = 0.0;
-
-  params.transform[12] = -scroll_x;
-  params.transform[13] = -scroll_y;
-  params.transform[14] = 0.0;
-  params.transform[15] = 1.0;
-
-  // Hard coded value for sRGB.
-  params.transfer_function_g = 2.4f;
-  params.transfer_function_a = 0.947867f;
-  params.transfer_function_b = 0.0521327f;
-  params.transfer_function_c = 0.0773994f;
-  params.transfer_function_d = 0.0404499f;
-  params.transfer_function_e = 0.f;
-  params.transfer_function_f = 0.f;
-  params.color_space_toXYZD50[0] = 0.436028f;
-  params.color_space_toXYZD50[1] = 0.385101f;
-  params.color_space_toXYZD50[2] = 0.143091f;
-  params.color_space_toXYZD50[3] = 0.222479f;
-  params.color_space_toXYZD50[4] = 0.716897f;
-  params.color_space_toXYZD50[5] = 0.0606241f;
-  params.color_space_toXYZD50[6] = 0.0139264f;
-  params.color_space_toXYZD50[7] = 0.0970921f;
-  params.color_space_toXYZD50[8] = 0.714191;
-
-  params.overlays_mode = AW_DRAW_FN_OVERLAYS_MODE_DISABLED;
-  params.get_surface_control = GetSurfaceControl;
-  params.merge_transaction = MergeTransaction;
-
-  data.functor_callbacks->draw_gl(functor, data.data, &params);
-}
-
-}  // extern "C"

android_webview/test/shell/src/org/chromium/android_webview/shell/ContextManager.java

+// Copyright 2018 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.
+
+package org.chromium.android_webview.shell;
+
+import android.view.Surface;
+
+import org.chromium.base.annotations.JNINamespace;
+
+/** draw_fn framework side implementation for tests. */
+@JNINamespace("draw_fn")
+public class ContextManager {
+    public static long getDrawFnFunctionTable() {
+        return nativeGetDrawFnFunctionTable();
+    }
+
+    private final long mNativeContextManager;
+
+    public ContextManager() {
+        mNativeContextManager = nativeInit();
+    }
+
+    public void setSurface(Surface surface) {
+        nativeSetSurface(mNativeContextManager, surface);
+    }
+
+    public void sync(int functor, boolean applyForceDark) {
+        nativeSync(mNativeContextManager, functor, applyForceDark);
+    }
+
+    // Uses functor from last sync.
+    public int[] draw(int width, int height, int scrollX, int scrollY, boolean readbackQuadrants) {
+        return nativeDraw(
+                mNativeContextManager, width, height, scrollX, scrollY, readbackQuadrants);
+    }
+
+    private static native long nativeGetDrawFnFunctionTable();
+    private static native long nativeInit();
+    private static native void nativeSetSurface(long nativeContextManager, Surface surface);
+    private static native void nativeSync(
+            long nativeContextManager, int functor, boolean applyForceDark);
+    private static native int[] nativeDraw(long nativeContextManager, int width, int height,
+            int scrollX, int scrollY, boolean readbackQuadrants);
+}

android_webview/test/shell/src/org/chromium/android_webview/shell/DrawFn.java

-// Copyright 2018 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.
-
-package org.chromium.android_webview.shell;
-
-/** draw_fn framework side implementation for tests. */
-public class DrawFn {
-    public static long getDrawFnFunctionTable() {
-        return nativeGetDrawFnFunctionTable();
-    }
-
-    public static void sync(int functor, boolean applyForceDark) {
-        nativeSync(functor, applyForceDark);
-    }
-
-    public static void destroyReleased() {
-        nativeDestroyReleased();
-    }
-
-    public static void drawGL(int functor, int width, int height, int scrollX, int scrollY) {
-        nativeDrawGL(functor, width, height, scrollX, scrollY);
-    }
-
-    private static native long nativeGetDrawFnFunctionTable();
-    private static native void nativeSync(int functor, boolean applyForceDark);
-    private static native void nativeDestroyReleased();
-    private static native void nativeDrawGL(
-            int functor, int width, int height, int scrollX, int scrollY);
-}