Merge "Move WebView plat_support from frameworks/webview."

#

# Copyright (C) 2012 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.

#

# This package provides the system interfaces allowing WebView to render.

LOCAL_PATH := $(call my-dir)

# Native support library (libwebviewchromium_plat_support.so) - does NOT link

# any native chromium code.

include $(CLEAR_VARS)

LOCAL_MODULE:= libwebviewchromium_plat_support

LOCAL_SRC_FILES:= \

        draw_gl_functor.cpp \

        jni_entry_point.cpp \

        graphics_utils.cpp \

        graphic_buffer_impl.cpp \

LOCAL_C_INCLUDES:= \

        external/skia/include/core \

        frameworks/base/core/jni/android/graphics \

        frameworks/native/include/ui \

LOCAL_SHARED_LIBRARIES += \

        libandroid_runtime \

        liblog \

        libcutils \

        libui \

        libutils \

        libhwui \

        libandroidfw

LOCAL_MODULE_TAGS := optional

# To remove warnings from skia header files

LOCAL_CFLAGS := -Wno-unused-parameter

include $(BUILD_SHARED_LIBRARY)

// Copyright 2014 The Chromium Authors. All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//    * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//    * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//    * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Copyright 2012 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_GL_H_

#define ANDROID_WEBVIEW_PUBLIC_BROWSER_DRAW_GL_H_

#ifdef __cplusplus

extern "C" {

#endif

// 1 is L/L MR1

//

// 2 starts at M, and added an imperfect workaround for complex clipping by

// elevating the WebView into an FBO layer. If any transform, clip, or outline

// clip occurs that would either likely use the stencil buffer for clipping, or

// require shader based clipping in HWUI, the WebView is drawn into an FBO (if

// it fits).

// This is a temporary workaround for a lack of WebView support for stencil/

// shader based round rect clipping, and should be removed when webview is

// capable of supporting these clips internally when drawing.

//

// 3 starts during development of P, when android defaults from HWUI to skia as

// the GL renderer. Skia already maintains and restores its GL state, so there

// is no need for WebView to restore this state. Skia also no longer promises

// GL state on entering draw, such as no vertex array buffer binding.

static const int kAwDrawGLInfoVersion = 3;

// Holds the information required to trigger an OpenGL drawing operation.

struct AwDrawGLInfo {

  int version;  // The AwDrawGLInfo this struct was built with.

  // Input: tells the draw function what action to perform.

  enum Mode {

    kModeDraw = 0,

    kModeProcess,

    kModeProcessNoContext,

    kModeSync,

  } mode;

  // Input: current clip rect in surface coordinates. Reflects the current state

  // of the OpenGL scissor rect. Both the OpenGL scissor rect and viewport are

  // set by the caller of the draw function and updated during View animations.

  int clip_left;

  int clip_top;

  int clip_right;

  int clip_bottom;

  // Input: current width/height of destination surface.

  int width;

  int height;

  // Input: is the View rendered into an independent layer.

  // If false, the surface is likely to hold to the full screen contents, with

  // the scissor box set by the caller to the actual View location and size.

  // Also the transformation matrix will contain at least a translation to the

  // position of the View to render, plus any other transformations required as

  // part of any ongoing View animation. View translucency (alpha) is ignored,

  // although the framework will set is_layer to true for non-opaque cases.

  // Can be requested via the View.setLayerType(View.LAYER_TYPE_NONE, ...)

  // Android API method.

  //

  // If true, the surface is dedicated to the View and should have its size.

  // The viewport and scissor box are set by the caller to the whole surface.

  // Animation transformations are handled by the caller and not reflected in

  // the provided transformation matrix. Translucency works normally.

  // Can be requested via the View.setLayerType(View.LAYER_TYPE_HARDWARE, ...)

  // Android API method.

  bool is_layer;

  // Input: current transformation matrix in surface pixels.

  // Uses the column-based OpenGL matrix format.

  float transform[16];

};

// Function to invoke a direct GL draw into the client's pre-configured

// GL context. Obtained via AwContents.getDrawGLFunction() (static).

// |view_context| is an opaque identifier that was returned by the corresponding

// call to AwContents.getAwDrawGLViewContext().

// |draw_info| carries the in and out parameters for this draw.

// |spare| ignored; pass NULL.

typedef void (AwDrawGLFunction)(long view_context,

                                AwDrawGLInfo* draw_info,

                                void* spare);

enum AwMapMode {

  MAP_READ_ONLY,

  MAP_WRITE_ONLY,

  MAP_READ_WRITE,

};

// Called to create a GraphicBuffer

typedef long AwCreateGraphicBufferFunction(int w, int h);

// Called to release a GraphicBuffer

typedef void AwReleaseGraphicBufferFunction(long buffer_id);

// Called to map a GraphicBuffer in |mode|.

typedef int AwMapFunction(long buffer_id, AwMapMode mode, void** vaddr);

// Called to unmap a GraphicBuffer

typedef int AwUnmapFunction(long buffer_id);

// Called to get a native buffer pointer

typedef void* AwGetNativeBufferFunction(long buffer_id);

// Called to get the stride of the buffer

typedef unsigned int AwGetStrideFunction(long buffer_id);

static const int kAwDrawGLFunctionTableVersion = 1;

// Set of functions used in rendering in hardware mode

struct AwDrawGLFunctionTable {

  int version;

  AwCreateGraphicBufferFunction* create_graphic_buffer;

  AwReleaseGraphicBufferFunction* release_graphic_buffer;

  AwMapFunction* map;

  AwUnmapFunction* unmap;

  AwGetNativeBufferFunction* get_native_buffer;

  AwGetStrideFunction* get_stride;

};

#ifdef __cplusplus

}  // extern "C"

#endif

#endif  // ANDROID_WEBVIEW_PUBLIC_BROWSER_DRAW_GL_H_

/*

 * Copyright (C) 2012 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

// GL Functor data types into the types the chromium stack expects, and back.

#define LOG_TAG "webviewchromium_plat_support"

#include "draw_gl.h"

#include <Properties.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>

#define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0])))

#define COMPILE_ASSERT(expr, err) \

__unused static const char (err)[(expr) ? 1 : -1] = "";

namespace android {

namespace {

AwDrawGLFunction* g_aw_drawgl_function = NULL;

class DrawGLFunctor : public Functor {

 public:

  explicit DrawGLFunctor(jlong view_context) : view_context_(view_context) {}

  virtual ~DrawGLFunctor() {}

  // Functor

  virtual status_t operator ()(int what, void* data) {

    using uirenderer::DrawGlInfo;

    if (!g_aw_drawgl_function) {

      ALOGE("Cannot draw: no DrawGL Function installed");

      return DrawGlInfo::kStatusDone;

    }

    AwDrawGLInfo aw_info;

    // TODO(boliu): Remove property check once OpenGL fallback is removed.

    auto render_pipeline_type =

        android::uirenderer::Properties::getRenderPipelineType();

    aw_info.version = (render_pipeline_type ==

                       android::uirenderer::RenderPipelineType::OpenGL)

                          ? 2

                          : kAwDrawGLInfoVersion;

    switch (what) {

      case DrawGlInfo::kModeDraw: {

        aw_info.mode = AwDrawGLInfo::kModeDraw;

        DrawGlInfo* gl_info = reinterpret_cast<DrawGlInfo*>(data);

        // Map across the input values.

        aw_info.clip_left = gl_info->clipLeft;

        aw_info.clip_top = gl_info->clipTop;

        aw_info.clip_right = gl_info->clipRight;

        aw_info.clip_bottom = gl_info->clipBottom;

        aw_info.width = gl_info->width;

        aw_info.height = gl_info->height;

        aw_info.is_layer = gl_info->isLayer;

        COMPILE_ASSERT(NELEM(aw_info.transform) == NELEM(gl_info->transform),

                       mismatched_transform_matrix_sizes);

        for (int i = 0; i < NELEM(aw_info.transform); ++i) {

          aw_info.transform[i] = gl_info->transform[i];

        }

        break;

      }

      case DrawGlInfo::kModeProcess:

        aw_info.mode = AwDrawGLInfo::kModeProcess;

        break;

      case DrawGlInfo::kModeProcessNoContext:

        aw_info.mode = AwDrawGLInfo::kModeProcessNoContext;

        break;

      case DrawGlInfo::kModeSync:

        aw_info.mode = AwDrawGLInfo::kModeSync;

        break;

      default:

        ALOGE("Unexpected DrawGLInfo type %d", what);

        return DrawGlInfo::kStatusDone;

    }

    // Invoke the DrawGL method.

    g_aw_drawgl_function(view_context_, &aw_info, NULL);

    return DrawGlInfo::kStatusDone;

  }

 private:

  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));

}

void DestroyGLFunctor(JNIEnv*, jclass, jlong functor) {

  delete reinterpret_cast<DrawGLFunctor*>(functor);

}

void SetChromiumAwDrawGLFunction(JNIEnv*, jclass, jlong draw_function) {

  g_aw_drawgl_function = reinterpret_cast<AwDrawGLFunction*>(draw_function);

}

const char kClassName[] = "com/android/webview/chromium/DrawGLFunctor";

const JNINativeMethod kJniMethods[] = {

    { "nativeCreateGLFunctor", "(J)J",

        reinterpret_cast<void*>(CreateGLFunctor) },

    { "nativeDestroyGLFunctor", "(J)V",

        reinterpret_cast<void*>(DestroyGLFunctor) },

    { "nativeSetChromiumAwDrawGLFunction", "(J)V",

        reinterpret_cast<void*>(SetChromiumAwDrawGLFunction) },

};

}  // namespace

void RegisterDrawGLFunctor(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

// Copyright (c) 2012 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_SW_H_

#define ANDROID_WEBVIEW_PUBLIC_BROWSER_DRAW_SW_H_

#include <jni.h>

#include <stddef.h>

#ifndef __cplusplus

#error "Can't mix C and C++ when using jni.h"

#endif

class SkCanvasState;

class SkPicture;

static const int kAwPixelInfoVersion = 3;

// Holds the information required to implement the SW draw to system canvas.

struct AwPixelInfo {

  int version;          // The kAwPixelInfoVersion this struct was built with.

  SkCanvasState* state; // The externalize state in skia format.

  // NOTE: If you add more members, bump kAwPixelInfoVersion.

};

// Function that can be called to fish out the underlying native pixel data

// from a Java canvas object, for optimized rendering path.

// Returns the pixel info on success, which must be freed via a call to

// AwReleasePixelsFunction, or NULL.

typedef AwPixelInfo* (AwAccessPixelsFunction)(JNIEnv* env, jobject canvas);

// Must be called to balance every *successful* call to AwAccessPixelsFunction

// (i.e. that returned true).

typedef void (AwReleasePixelsFunction)(AwPixelInfo* pixels);

// Called to create an Android Picture object encapsulating a native SkPicture.

typedef jobject (AwCreatePictureFunction)(JNIEnv* env, SkPicture* picture);

// Method that returns the current Skia function.

typedef void (SkiaVersionFunction)(int* major, int* minor, int* patch);

// Called to verify if the Skia versions are compatible.

typedef bool (AwIsSkiaVersionCompatibleFunction)(SkiaVersionFunction function);

static const int kAwDrawSWFunctionTableVersion = 1;

// "vtable" for the functions declared in this file. An instance must be set via

// AwContents.setAwDrawSWFunctionTable

struct AwDrawSWFunctionTable {

  int version;

  AwAccessPixelsFunction* access_pixels;

  AwReleasePixelsFunction* release_pixels;

};

#endif  // ANDROID_WEBVIEW_PUBLIC_BROWSER_DRAW_SW_H_