diff options
| -rw-r--r-- | libs/hwui/Android.bp | 1 | ||||
| -rw-r--r-- | libs/hwui/pipeline/skia/SkiaRecordingCanvas.cpp | 3 | ||||
| -rw-r--r-- | libs/hwui/pipeline/skia/VkFunctorDrawable.cpp | 84 | ||||
| -rw-r--r-- | libs/hwui/pipeline/skia/VkFunctorDrawable.h | 66 | ||||
| -rw-r--r-- | libs/hwui/private/hwui/DrawVkInfo.h | 107 | ||||
| -rw-r--r-- | native/webview/plat_support/Android.bp | 3 | ||||
| -rw-r--r-- | native/webview/plat_support/draw_gl_functor.cpp | 27 | ||||
| -rw-r--r-- | native/webview/plat_support/draw_vk.h | 125 | ||||
| -rw-r--r-- | native/webview/plat_support/draw_vk_functor.cpp | 141 | ||||
| -rw-r--r-- | native/webview/plat_support/functor_utils.cpp | 45 | ||||
| -rw-r--r-- | native/webview/plat_support/functor_utils.h | 25 |
11 files changed, 602 insertions, 25 deletions
diff --git a/libs/hwui/Android.bp b/libs/hwui/Android.bp index da77b99e6e53..ed7d5e578693 100644 --- a/libs/hwui/Android.bp +++ b/libs/hwui/Android.bp @@ -171,6 +171,7 @@ cc_defaults { "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 b682ab0256dd..b56c3ef94791 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 @@ void SkiaRecordingCanvas::callDrawGLFunction(Functor* functor, 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 000000000000..71ad5e17301a --- /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 000000000000..5cd131405d15 --- /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 000000000000..019950fcbc02 --- /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 d8c5ac969128..96c9c1c85a60 100644 --- a/native/webview/plat_support/Android.bp +++ b/native/webview/plat_support/Android.bp @@ -23,6 +23,8 @@ cc_library_shared { 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 @@ cc_library_shared { "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 e3e52b1ea1f1..be36b6742037 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 @@ class DrawGLFunctor : public Functor { 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 000000000000..6b7d8d0b9118 --- /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 000000000000..1ba559d9afdf --- /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 000000000000..235762dc2679 --- /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 000000000000..76c0bb67d275 --- /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 |