diff --git a/libs/hwui/Android.bp b/libs/hwui/Android.bp
index da77b99..ed7d5e5 100644
--- a/libs/hwui/Android.bp
+++ b/libs/hwui/Android.bp
@@ -171,6 +171,7 @@
         "pipeline/skia/SkiaRecordingCanvas.cpp",
         "pipeline/skia/SkiaVulkanPipeline.cpp",
         "pipeline/skia/VectorDrawableAtlas.cpp",
+        "pipeline/skia/VkFunctorDrawable.cpp",
         "pipeline/skia/VkInteropFunctorDrawable.cpp",
         "renderstate/RenderState.cpp",
         "renderthread/CacheManager.cpp",
diff --git a/libs/hwui/pipeline/skia/SkiaRecordingCanvas.cpp b/libs/hwui/pipeline/skia/SkiaRecordingCanvas.cpp
index b682ab0..b56c3ef 100644
--- a/libs/hwui/pipeline/skia/SkiaRecordingCanvas.cpp
+++ b/libs/hwui/pipeline/skia/SkiaRecordingCanvas.cpp
@@ -25,6 +25,7 @@
 #include "pipeline/skia/AnimatedDrawables.h"
 #include "pipeline/skia/GLFunctorDrawable.h"
 #include "pipeline/skia/VkInteropFunctorDrawable.h"
+#include "pipeline/skia/VkFunctorDrawable.h"
 
 namespace android {
 namespace uirenderer {
@@ -124,6 +125,8 @@
                                              uirenderer::GlFunctorLifecycleListener* listener) {
     FunctorDrawable* functorDrawable;
     if (Properties::getRenderPipelineType() == RenderPipelineType::SkiaVulkan) {
+        // TODO(cblume) use VkFunctorDrawable instead of VkInteropFunctorDrawable here when the
+        // interop is disabled/moved.
         functorDrawable = mDisplayList->allocateDrawable<VkInteropFunctorDrawable>(functor,
                 listener, asSkCanvas());
     } else {
diff --git a/libs/hwui/pipeline/skia/VkFunctorDrawable.cpp b/libs/hwui/pipeline/skia/VkFunctorDrawable.cpp
new file mode 100644
index 0000000..71ad5e1
--- /dev/null
+++ b/libs/hwui/pipeline/skia/VkFunctorDrawable.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "VkFunctorDrawable.h"
+#include <private/hwui/DrawVkInfo.h>
+
+#include "thread/ThreadBase.h"
+#include "utils/TimeUtils.h"
+#include <GrBackendDrawableInfo.h>
+#include <thread>
+#include <utils/Color.h>
+#include <utils/Trace.h>
+#include <utils/TraceUtils.h>
+#include <SkImage.h>
+#include <vk/GrVkTypes.h>
+
+namespace android {
+namespace uirenderer {
+namespace skiapipeline {
+
+VkFunctorDrawHandler::VkFunctorDrawHandler(Functor *functor)
+    : INHERITED()
+    , mFunctor(functor) {}
+
+VkFunctorDrawHandler::~VkFunctorDrawHandler() {
+    // TODO(cblume) Fill in the DrawVkInfo parameters.
+    (*mFunctor)(DrawVkInfo::kModePostComposite, nullptr);
+}
+
+void VkFunctorDrawHandler::draw(const GrBackendDrawableInfo& info) {
+    ATRACE_CALL();
+
+    GrVkDrawableInfo vulkan_info;
+    if (!info.getVkDrawableInfo(&vulkan_info)) {
+        return;
+    }
+
+    DrawVkInfo draw_vk_info;
+    // TODO(cblume) Fill in the rest of the parameters and test the actual call.
+    draw_vk_info.isLayer = true;
+
+    (*mFunctor)(DrawVkInfo::kModeComposite, &draw_vk_info);
+}
+
+VkFunctorDrawable::VkFunctorDrawable(Functor* functor, GlFunctorLifecycleListener* listener,
+                                     SkCanvas* canvas)
+    : FunctorDrawable(functor, listener, canvas) {}
+
+VkFunctorDrawable::~VkFunctorDrawable() = default;
+
+void VkFunctorDrawable::syncFunctor() const {
+    (*mFunctor)(DrawVkInfo::kModeSync, nullptr);
+}
+
+void VkFunctorDrawable::onDraw(SkCanvas* /*canvas*/) {
+    LOG_ALWAYS_FATAL("VkFunctorDrawable::onDraw() should never be called.");
+    // Instead of calling onDraw(), the call should come from onSnapGpuDrawHandler.
+}
+
+std::unique_ptr<FunctorDrawable::GpuDrawHandler> VkFunctorDrawable::onSnapGpuDrawHandler(
+    GrBackendApi backendApi, const SkMatrix& matrix) {
+    if (backendApi != GrBackendApi::kVulkan) {
+        return nullptr;
+    }
+    std::unique_ptr<VkFunctorDrawHandler> draw(new VkFunctorDrawHandler(mFunctor));
+    return std::move(draw);
+}
+
+}  // namespace skiapipeline
+}  // namespace uirenderer
+}  // namespace android
diff --git a/libs/hwui/pipeline/skia/VkFunctorDrawable.h b/libs/hwui/pipeline/skia/VkFunctorDrawable.h
new file mode 100644
index 0000000..5cd1314
--- /dev/null
+++ b/libs/hwui/pipeline/skia/VkFunctorDrawable.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "FunctorDrawable.h"
+
+#include <utils/RefBase.h>
+#include <ui/GraphicBuffer.h>
+#include <SkImageInfo.h>
+
+namespace android {
+namespace uirenderer {
+namespace skiapipeline {
+
+/**
+ * This draw handler will be returned by VkFunctorDrawable's onSnapGpuDrawHandler. It allows us to
+ * issue Vulkan commands while the command buffer is being flushed.
+ */
+class VkFunctorDrawHandler : public FunctorDrawable::GpuDrawHandler {
+public:
+    explicit VkFunctorDrawHandler(Functor* functor);
+    ~VkFunctorDrawHandler() override;
+
+    void draw(const GrBackendDrawableInfo& info) override;
+private:
+    typedef GpuDrawHandler INHERITED;
+
+    Functor* mFunctor;
+};
+
+/**
+ * This drawable wraps a Vulkan functor enabling it to be recorded into a list of Skia drawing
+ * commands.
+ */
+class VkFunctorDrawable : public FunctorDrawable {
+public:
+    VkFunctorDrawable(Functor* functor, GlFunctorLifecycleListener* listener,
+            SkCanvas* canvas);
+    ~VkFunctorDrawable() override;
+
+    void syncFunctor() const override;
+
+protected:
+    // SkDrawable functions:
+    void onDraw(SkCanvas* canvas) override;
+    std::unique_ptr<FunctorDrawable::GpuDrawHandler> onSnapGpuDrawHandler(GrBackendApi backendApi,
+            const SkMatrix& matrix) override;
+};
+
+}  // namespace skiapipeline
+}  // namespace uirenderer
+}  // namespace android
diff --git a/libs/hwui/private/hwui/DrawVkInfo.h b/libs/hwui/private/hwui/DrawVkInfo.h
new file mode 100644
index 0000000..019950f
--- /dev/null
+++ b/libs/hwui/private/hwui/DrawVkInfo.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_HWUI_DRAW_VK_INFO_H
+#define ANDROID_HWUI_DRAW_VK_INFO_H
+
+#include <vulkan/vulkan.h>
+
+namespace android {
+namespace uirenderer {
+
+/**
+ * Structure used by VulkanRenderer::callDrawVKFunction() to pass and receive data from Vulkan
+ * functors.
+ */
+struct DrawVkInfo {
+    // Input: current width/height of destination surface
+    int width;
+    int height;
+
+    // Input: is the render target an FBO
+    bool isLayer;
+
+    // Input: current transform matrix, in OpenGL format
+    float transform[16];
+
+    // Input: WebView should do its main compositing draws into this. It cannot do anything that
+    // would require stopping the render pass.
+    VkCommandBuffer secondaryCommandBuffer;
+
+    // Input: The main color attachment index where secondaryCommandBuffer will eventually be
+    // submitted.
+    uint32_t colorAttachmentIndex;
+
+    // Input: A render pass which will be compatible to the one which the secondaryCommandBuffer
+    // will be submitted into.
+    VkRenderPass compatibleRenderPass;
+
+    // Input: Format of the destination surface.
+    VkFormat format;
+
+    // Input: Color space transfer params
+    float G;
+    float A;
+    float B;
+    float C;
+    float D;
+    float E;
+    float F;
+
+    // Input: Color space transformation from linear RGB to D50-adapted XYZ
+    float matrix[9];
+
+    // Input: current clip rect
+    int clipLeft;
+    int clipTop;
+    int clipRight;
+    int clipBottom;
+
+    /**
+     * Values used as the "what" parameter of the functor.
+     */
+    enum Mode {
+        // Called once at WebView start
+        kModeInit,
+        // Called when things need to be re-created
+        kModeReInit,
+        // Notifies the app that the composite functor will be called soon. This allows WebView to
+        // begin work early.
+        kModePreComposite,
+        // Do the actual composite work
+        kModeComposite,
+        // This allows WebView to begin using the previously submitted objects in future work.
+        kModePostComposite,
+        // Invoked every time the UI thread pushes over a frame to the render thread and the owning
+        // view has a dirty display list*. This is a signal to sync any data that needs to be
+        // shared between the UI thread and the render thread. During this time the UI thread is
+        // blocked.
+        kModeSync
+    };
+
+    /**
+     * Values used by Vulkan functors to tell the framework what to do next.
+     */
+    enum Status {
+        // The functor is done
+        kStatusDone = 0x0,
+    };
+};  // struct DrawVkInfo
+
+}  // namespace uirenderer
+}  // namespace android
+
+#endif  // ANDROID_HWUI_DRAW_VK_INFO_H
diff --git a/native/webview/plat_support/Android.bp b/native/webview/plat_support/Android.bp
index d8c5ac9..96c9c1c 100644
--- a/native/webview/plat_support/Android.bp
+++ b/native/webview/plat_support/Android.bp
@@ -23,6 +23,8 @@
 
     srcs: [
         "draw_gl_functor.cpp",
+        "draw_vk_functor.cpp",
+        "functor_utils.cpp",
         "jni_entry_point.cpp",
         "graphics_utils.cpp",
         "graphic_buffer_impl.cpp",
@@ -36,6 +38,7 @@
         "liblog",
         "libui",
         "libutils",
+        "libvulkan",
     ],
 
     // To remove warnings from skia header files
diff --git a/native/webview/plat_support/draw_gl_functor.cpp b/native/webview/plat_support/draw_gl_functor.cpp
index e3e52b1..be36b67 100644
--- a/native/webview/plat_support/draw_gl_functor.cpp
+++ b/native/webview/plat_support/draw_gl_functor.cpp
@@ -21,15 +21,13 @@
 
 #include "draw_gl.h"
 
-#include <errno.h>
 #include <jni.h>
 #include <private/hwui/DrawGlInfo.h>
-#include <string.h>
-#include <sys/resource.h>
-#include <sys/time.h>
 #include <utils/Functor.h>
 #include <utils/Log.h>
 
+#include "functor_utils.h"
+
 #define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0])))
 #define COMPILE_ASSERT(expr, err) \
 __unused static const char (err)[(expr) ? 1 : -1] = "";
@@ -98,27 +96,6 @@
   intptr_t view_context_;
 };
 
-// Raise the file handle soft limit to the hard limit since gralloc buffers
-// uses file handles.
-void RaiseFileNumberLimit() {
-  static bool have_raised_limit = false;
-  if (have_raised_limit)
-    return;
-
-  have_raised_limit = true;
-  struct rlimit limit_struct;
-  limit_struct.rlim_cur = 0;
-  limit_struct.rlim_max = 0;
-  if (getrlimit(RLIMIT_NOFILE, &limit_struct) == 0) {
-    limit_struct.rlim_cur = limit_struct.rlim_max;
-    if (setrlimit(RLIMIT_NOFILE, &limit_struct) != 0) {
-      ALOGE("setrlimit failed: %s", strerror(errno));
-    }
-  } else {
-    ALOGE("getrlimit failed: %s", strerror(errno));
-  }
-}
-
 jlong CreateGLFunctor(JNIEnv*, jclass, jlong view_context) {
   RaiseFileNumberLimit();
   return reinterpret_cast<jlong>(new DrawGLFunctor(view_context));
diff --git a/native/webview/plat_support/draw_vk.h b/native/webview/plat_support/draw_vk.h
new file mode 100644
index 0000000..6b7d8d0
--- /dev/null
+++ b/native/webview/plat_support/draw_vk.h
@@ -0,0 +1,125 @@
+// 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.
+//
+//******************************************************************************
+// This is a copy of the coresponding android_webview/public/browser header.
+// Any changes to the interface should be made there.
+//
+// The purpose of having the copy is twofold:
+//  - it removes the need to have Chromium sources present in the tree in order
+//    to build the plat_support library,
+//  - it captures API that the corresponding Android release supports.
+//******************************************************************************
+
+#ifndef ANDROID_WEBVIEW_PUBLIC_BROWSER_DRAW_VK_H_
+#define ANDROID_WEBVIEW_PUBLIC_BROWSER_DRAW_VK_H_
+
+#include <vulkan/vulkan.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static const int kAwDrawVKInfoVersion = 1;
+
+// Holds the information required to trigger initialization of the Vulkan
+// functor.
+struct InitParams {
+  // All params are input
+  VkInstance instance;
+  VkPhysicalDevice physical_device;
+  VkDevice device;
+  VkQueue queue;
+  uint32_t graphics_queue_index;
+  uint32_t instance_version;
+  const char* const* enabled_extension_names;
+  // Only one of device_features and device_features_2 should be non-null.
+  // If both are null then no features are enabled.
+  VkPhysicalDeviceFeatures* device_features;
+  VkPhysicalDeviceFeatures2* device_features_2;
+};
+
+// Holds the information required to trigger an Vulkan composite operation.
+struct CompositeParams {
+  // Input: current width/height of destination surface.
+  int width;
+  int height;
+
+  // Input: is the render target a FBO
+  bool is_layer;
+
+  // Input: current transform matrix
+  float transform[16];
+
+  // Input WebView should do its main compositing draws into this. It cannot do
+  // anything that would require stopping the render pass.
+  VkCommandBuffer secondary_command_buffer;
+
+  // Input: The main color attachment index where secondary_command_buffer will
+  // eventually be submitted.
+  uint32_t color_attachment_index;
+
+  // Input: A render pass which will be compatible to the one which the
+  // secondary_command_buffer will be submitted into.
+  VkRenderPass compatible_render_pass;
+
+  // Input: Format of the destination surface.
+  VkFormat format;
+
+  // Input: Color space transfer params
+  float G;
+  float A;
+  float B;
+  float C;
+  float D;
+  float E;
+  float F;
+
+  // Input: Color space transformation from linear RGB to D50-adapted XYZ
+  float matrix[9];
+
+  // Input: current clip rect
+  int clip_left;
+  int clip_top;
+  int clip_right;
+  int clip_bottom;
+};
+
+// Holds the information for the post-submission callback of main composite
+// draw.
+struct PostCompositeParams {
+  // Input: Fence for the composite command buffer to signal it has finished its
+  // work on the GPU.
+  int fd;
+};
+
+// Holds the information required to trigger an Vulkan operation.
+struct AwDrawVKInfo {
+  int version;  // The AwDrawVKInfo this struct was built with.
+
+  // Input: tells the draw function what action to perform.
+  enum Mode {
+    kModeInit = 0,
+    kModeReInit = 1,
+    kModePreComposite = 2,
+    kModeComposite = 3,
+    kModePostComposite = 4,
+    kModeSync = 5,
+  } mode;
+
+  // Input: The parameters for the functor being called
+  union ParamUnion {
+    struct InitParams init_params;
+    struct CompositeParams composite_params;
+    struct PostCompositeParams post_composite_params;
+  } info;
+};
+
+typedef void(AwDrawVKFunction)(long view_context, AwDrawVKInfo* draw_info);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // ANDROID_WEBVIEW_PUBLIC_BROWSER_DRAW_VK_H_
diff --git a/native/webview/plat_support/draw_vk_functor.cpp b/native/webview/plat_support/draw_vk_functor.cpp
new file mode 100644
index 0000000..1ba559d
--- /dev/null
+++ b/native/webview/plat_support/draw_vk_functor.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Provides a webviewchromium glue layer adapter from the internal Android
+// Vulkan Functor data types into the types the chromium stack expects, and
+// back.
+
+#define LOG_TAG "webviewchromium_plat_support"
+
+#include "draw_vk.h"
+
+#include <jni.h>
+#include <private/hwui/DrawVkInfo.h>
+#include <utils/Functor.h>
+#include <utils/Log.h>
+
+#include "functor_utils.h"
+
+#define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0])))
+
+namespace android {
+namespace {
+
+AwDrawVKFunction* g_aw_drawvk_function = NULL;
+
+class DrawVKFunctor : public Functor {
+ public:
+  explicit DrawVKFunctor(jlong view_context) : view_context_(view_context) {}
+  ~DrawVKFunctor() override {}
+
+  // Functor
+  status_t operator ()(int what, void* data) override {
+    using uirenderer::DrawVkInfo;
+    if (!g_aw_drawvk_function) {
+      ALOGE("Cannot draw: no DrawVK Function installed");
+      return DrawVkInfo::kStatusDone;
+    }
+
+    AwDrawVKInfo aw_info;
+    aw_info.version = kAwDrawVKInfoVersion;
+    switch (what) {
+      case DrawVkInfo::kModeComposite: {
+        aw_info.mode = AwDrawVKInfo::kModeComposite;
+        DrawVkInfo* vk_info = reinterpret_cast<DrawVkInfo*>(data);
+
+        // Map across the input values.
+        CompositeParams& params = aw_info.info.composite_params;
+        params.width = vk_info->width;
+        params.height = vk_info->height;
+        params.is_layer = vk_info->isLayer;
+        for (size_t i = 0; i < 16; i++) {
+            params.transform[i] = vk_info->transform[i];
+        }
+        params.secondary_command_buffer = vk_info->secondaryCommandBuffer;
+        params.color_attachment_index = vk_info->colorAttachmentIndex;
+        params.compatible_render_pass = vk_info->compatibleRenderPass;
+        params.format = vk_info->format;
+        params.G = vk_info->G;
+        params.A = vk_info->A;
+        params.B = vk_info->B;
+        params.C = vk_info->C;
+        params.D = vk_info->D;
+        params.E = vk_info->E;
+        params.F = vk_info->F;
+        for (size_t i = 0; i < 9; i++) {
+            params.matrix[i] = vk_info->matrix[i];
+        }
+        params.clip_left = vk_info->clipLeft;
+        params.clip_top = vk_info->clipTop;
+        params.clip_right = vk_info->clipRight;
+        params.clip_bottom = vk_info->clipBottom;
+
+        break;
+      }
+      case DrawVkInfo::kModePostComposite:
+        break;
+      case DrawVkInfo::kModeSync:
+        aw_info.mode = AwDrawVKInfo::kModeSync;
+        break;
+      default:
+        ALOGE("Unexpected DrawVKInfo type %d", what);
+        return DrawVkInfo::kStatusDone;
+    }
+
+    // Invoke the DrawVK method.
+    g_aw_drawvk_function(view_context_, &aw_info);
+
+    return DrawVkInfo::kStatusDone;
+  }
+
+ private:
+  intptr_t view_context_;
+};
+
+jlong CreateVKFunctor(JNIEnv*, jclass, jlong view_context) {
+  RaiseFileNumberLimit();
+  return reinterpret_cast<jlong>(new DrawVKFunctor(view_context));
+}
+
+void DestroyVKFunctor(JNIEnv*, jclass, jlong functor) {
+  delete reinterpret_cast<DrawVKFunctor*>(functor);
+}
+
+void SetChromiumAwDrawVKFunction(JNIEnv*, jclass, jlong draw_function) {
+  g_aw_drawvk_function = reinterpret_cast<AwDrawVKFunction*>(draw_function);
+}
+
+const char kClassName[] = "com/android/webview/chromium/DrawVKFunctor";
+const JNINativeMethod kJniMethods[] = {
+    { "nativeCreateVKFunctor", "(J)J",
+        reinterpret_cast<void*>(CreateVKFunctor) },
+    { "nativeDestroyVKFunctor", "(J)V",
+        reinterpret_cast<void*>(DestroyVKFunctor) },
+    { "nativeSetChromiumAwDrawVKFunction", "(J)V",
+        reinterpret_cast<void*>(SetChromiumAwDrawVKFunction) },
+};
+
+}  // namespace
+
+void RegisterDrawVKFunctor(JNIEnv* env) {
+  jclass clazz = env->FindClass(kClassName);
+  LOG_ALWAYS_FATAL_IF(!clazz, "Unable to find class '%s'", kClassName);
+
+  int res = env->RegisterNatives(clazz, kJniMethods, NELEM(kJniMethods));
+  LOG_ALWAYS_FATAL_IF(res < 0, "register native methods failed: res=%d", res);
+}
+
+}  // namespace android
diff --git a/native/webview/plat_support/functor_utils.cpp b/native/webview/plat_support/functor_utils.cpp
new file mode 100644
index 0000000..235762d
--- /dev/null
+++ b/native/webview/plat_support/functor_utils.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "functor_utils.h"
+
+#include <errno.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <utils/Log.h>
+
+namespace android {
+
+void RaiseFileNumberLimit() {
+  static bool have_raised_limit = false;
+  if (have_raised_limit)
+    return;
+
+  have_raised_limit = true;
+  struct rlimit limit_struct;
+  limit_struct.rlim_cur = 0;
+  limit_struct.rlim_max = 0;
+  if (getrlimit(RLIMIT_NOFILE, &limit_struct) == 0) {
+    limit_struct.rlim_cur = limit_struct.rlim_max;
+    if (setrlimit(RLIMIT_NOFILE, &limit_struct) != 0) {
+      ALOGE("setrlimit failed: %s", strerror(errno));
+    }
+  } else {
+    ALOGE("getrlimit failed: %s", strerror(errno));
+  }
+}
+
+}  // namespace android
diff --git a/native/webview/plat_support/functor_utils.h b/native/webview/plat_support/functor_utils.h
new file mode 100644
index 0000000..76c0bb6
--- /dev/null
+++ b/native/webview/plat_support/functor_utils.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace android {
+
+// Raise the file handle soft limit to the hard limit since gralloc buffers
+// uses file handles.
+void RaiseFileNumberLimit();
+
+}  // namespace android