Added support for new CefResourceHandler API

This upgrades the JCEF wrapper classes for CefResourceHandler to also
include the newer Open/Skip/Read API. The new API methods have been
added in addition to the old ProcessRequest/ReadResponse methods in the
same way as this was done in the original CEF interface, thereby allowing for
the same backwards compatibility to be provided by default, while enabling
JCEF-based applications to use the new API in order to implement features
that the old API doesn't allow for, such as correct handling of Range requests.

Author: S1artie

java/org/cef/callback/CefResourceReadCallback.java

@@ -0,0 +1,25 @@
+// Copyright (c) 2024 The Chromium Embedded Framework 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.cef.callback;
+
+/**
+ * Callback interface used for asynchronous resource reading.
+ */
+public interface CefResourceReadCallback {
+    /**
+     * Callback for asynchronous continuation of Read(). If |bytes_read| == 0
+     * the response will be considered complete. If |bytes_read| > 0 then Read()
+     * will be called again until the request is complete (based on either the
+     * result or the expected content length). If |bytes_read| < 0 then the
+     * request will fail and the |bytes_read| value will be treated as the error
+     * code.
+     */
+    void Continue(int bytes_read);
+
+    /**
+     * Returns the byte buffer to write data into before calling #Continue(int).
+     */
+    public byte[] getBuffer();
+}

java/org/cef/callback/CefResourceReadCallback_N.java

@@ -0,0 +1,46 @@
+// Copyright (c) 2024 The Chromium Embedded Framework 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.cef.callback;
+
+class CefResourceReadCallback_N extends CefNativeAdapter implements CefResourceReadCallback {
+    // The native buffer where to copy the data to.
+    private long N_NativeBufferRef;
+
+    // The Java buffer which the application is expected to fill with data.
+    private byte[] N_JavaBuffer;
+
+    CefResourceReadCallback_N() {}
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+
+    public void setBufferRefs(long nativeBufferRef, byte[] javaBuffer) {
+        N_NativeBufferRef = nativeBufferRef;
+        N_JavaBuffer = javaBuffer;
+    }
+
+    @Override
+    public byte[] getBuffer() {
+        return N_JavaBuffer;
+    }
+
+    @Override
+    public void Continue(int bytes_read) {
+        try {
+            if (N_NativeBufferRef != 0 && N_JavaBuffer != null) {
+                N_Continue(getNativeRef(null), bytes_read, N_NativeBufferRef, N_JavaBuffer);
+                N_NativeBufferRef = 0;
+                N_JavaBuffer = null;
+            }
+        } catch (UnsatisfiedLinkError ule) {
+            ule.printStackTrace();
+        }
+    }
+
+    private final native void N_Continue(
+            long self, int bytes_read, long nativeBufferRef, byte[] javaBuffer);
+}

java/org/cef/callback/CefResourceSkipCallback.java

@@ -0,0 +1,18 @@
+// Copyright (c) 2024 The Chromium Embedded Framework 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.cef.callback;
+
+/**
+ * Callback interface used for asynchronous resource skipping.
+ */
+public interface CefResourceSkipCallback {
+    /**
+     * Callback for asynchronous continuation of Skip(). If |bytes_skipped| > 0
+     * then either Skip() will be called again until the requested number of
+     * bytes have been skipped or the request will proceed. If |bytes_skipped|
+     * <= 0 the request will fail with ERR_REQUEST_RANGE_NOT_SATISFIABLE.
+     */
+    void Continue(long bytes_skipped);
+}

java/org/cef/callback/CefResourceSkipCallback_N.java

@@ -0,0 +1,25 @@
+// Copyright (c) 2024 The Chromium Embedded Framework 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.cef.callback;
+
+class CefResourceSkipCallback_N extends CefNativeAdapter implements CefResourceSkipCallback {
+    CefResourceSkipCallback_N() {}
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+
+    @Override
+    public void Continue(long bytes_skipped) {
+        try {
+            N_Continue(getNativeRef(null), bytes_skipped);
+        } catch (UnsatisfiedLinkError ule) {
+            ule.printStackTrace();
+        }
+    }
+
+    private final native void N_Continue(long self, long bytes_skipped);
+}

java/org/cef/handler/CefResourceHandler.java

@@ -5,15 +5,21 @@
 package org.cef.handler;
 
 import org.cef.callback.CefCallback;
+import org.cef.callback.CefResourceReadCallback;
+import org.cef.callback.CefResourceSkipCallback;
+import org.cef.misc.BoolRef;
 import org.cef.misc.IntRef;
+import org.cef.misc.LongRef;
 import org.cef.misc.StringRef;
 import org.cef.network.CefCookie;
 import org.cef.network.CefRequest;
 import org.cef.network.CefResponse;
 
 /**
- * Implement this interface to handle custom resource requests. The methods of
- * this class will always be called on the IO thread.
+ * Implement this interface to handle custom resource requests. This interface is a "new" API and an
+ * old API in one: the deprecated methods are part of the old API. The new API allows for parallel
+ * processing of requests, because it does not channel all reads through a dedicated IO thread, and
+ * it allows for skipping of bytes as part of handling Range requests.
  */
 public interface CefResourceHandler {
     /**
@@ -23,9 +29,22 @@ public interface CefResourceHandler {
      * @param callback Callback to continue or cancel the request.
      * @return True to handle the request and call CefCallback.Continue() once the response header
      *         information is available.
+     * @deprecated Use open() instead
      */
     boolean processRequest(CefRequest request, CefCallback callback);
 
+    /**
+     * Open the response stream. This and related (getResponseHeaders, read, skip) methods will be
+     * called in sequence but not from a dedicated thread. <p> For backwards compatibility set
+     * |handleRequest| to false and return false and the processRequest() method will be called.
+     * @param request The request itself. Cannot be modified in this callback. Instance only valid
+     *         within the scope of this method.
+     * @param handleRequest Set to true to handle/cancel the request immediately
+     * @param callback Callback to continue or cancel the request at a later time
+     * @return True to handle the request
+     */
+    boolean open(CefRequest request, BoolRef handleRequest, CefCallback callback);
+
     /**
      * Retrieve response header information. If the response length is not known set
      * |responseLength| to -1 and readResponse() will be called until it returns false. If the
@@ -49,9 +68,41 @@ public interface CefResourceHandler {
      * @param bytesRead Number of bytes written to the buffer.
      * @param callback Callback to execute if data will be available asynchronously.
      * @return True if more data is or will be available.
+     * @deprecated Use read() instead
      */
     boolean readResponse(byte[] dataOut, int bytesToRead, IntRef bytesRead, CefCallback callback);
 
+    /**
+     * Read response data. If data is available immediately copy up to |bytesToRead| bytes into
+     * |dataOut|, set |bytesRead| to the number of bytes copied, and return true. To read the data
+     * at a later time store |dataOut|, set |bytesRead| to 0, return true and call the callback when
+     * the data is available. To indicate response completion set |bytesRead| to 0 and return false.
+     * To indicate failure set |bytesRead| to <0 (e.g. -2 for ERR_FAILED) and return false. <p> For
+     * backwards compatibility set |bytesRead| to -1 and return false and the readResponse() method
+     * will be called.
+     * @param dataOut Write data to this buffer. Buffer remains valid until either an immediate
+     *         response is delivered (return true) or the callback is called later when data is
+     *         available (return false).
+     * @param bytesToRead Size of the buffer.
+     * @param bytesRead Number of bytes written to the buffer.
+     * @param callback Callback to execute if data will be available asynchronously.
+     * @return True if more data is or will be available.
+     */
+    boolean read(
+            byte[] dataOut, int bytesToRead, IntRef bytesRead, CefResourceReadCallback callback);
+
+    /**
+     * Skip response data when requested by a Range header. Skip over and discard |bytesToSkip|
+     * bytes of response data. If data is available immediately set |bytesSkipped| to the number of
+     * bytes skipped and return true. To read the data at a later time set |bytesSkipped| to 0,
+     * return true and execute |callback| when the data is available. To indicate failure set
+     * |bytesSkipped| to < 0 (e.g. -2 for ERR_FAILED) and return false.
+     * @param bytesToSkip Number of bytes to skip.
+     * @param bytesSkipped Number of bytes skipped.
+     * @param callback Callback to execute if data will be skipped asynchronously.
+     */
+    boolean skip(long bytesToSkip, LongRef bytesSkipped, CefResourceSkipCallback callback);
+
     /**
      * Request processing has been canceled.
      */

java/org/cef/handler/CefResourceHandlerAdapter.java

@@ -5,7 +5,11 @@
 package org.cef.handler;
 
 import org.cef.callback.CefCallback;
+import org.cef.callback.CefResourceReadCallback;
+import org.cef.callback.CefResourceSkipCallback;
+import org.cef.misc.BoolRef;
 import org.cef.misc.IntRef;
+import org.cef.misc.LongRef;
 import org.cef.misc.StringRef;
 import org.cef.network.CefCookie;
 import org.cef.network.CefRequest;
@@ -22,6 +26,13 @@ public boolean processRequest(CefRequest request, CefCallback callback) {
         return false;
     }
 
+    @Override
+    public boolean open(CefRequest request, BoolRef handleRequest, CefCallback callback) {
+        // Enables backwards compatibility by default by calling processRequest.
+        handleRequest.set(false);
+        return false;
+    }
+
     @Override
     public void getResponseHeaders(
             CefResponse response, IntRef responseLength, StringRef redirectUrl) {}
@@ -32,6 +43,20 @@ public boolean readResponse(
         return false;
     }
 
+    @Override
+    public boolean read(
+            byte[] dataOut, int bytesToRead, IntRef bytesRead, CefResourceReadCallback callback) {
+        // Enables backwards compatibility by default by calling readResponse.
+        bytesRead.set(-1);
+        return false;
+    }
+
+    @Override
+    public boolean skip(long bytesToSkip, LongRef bytesSkipped, CefResourceSkipCallback callback) {
+        bytesSkipped.set(-2);
+        return false;
+    }
+
     @Override
     public void cancel() {}
 }

java/org/cef/misc/LongRef.java

@@ -0,0 +1,26 @@
+// Copyright (c) 2024 The Chromium Embedded Framework 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.cef.misc;
+
+/**
+ * Helper class for passing long values by reference.
+ */
+public class LongRef {
+    private long value_;
+
+    public LongRef() {}
+
+    public LongRef(long value) {
+        value_ = value;
+    }
+
+    public void set(long value) {
+        value_ = value;
+    }
+
+    public long get() {
+        return value_;
+    }
+}

java/tests/detailed/handler/ClientSchemeHandler.java

@@ -5,7 +5,9 @@
 package tests.detailed.handler;
 
 import org.cef.callback.CefCallback;
+import org.cef.callback.CefResourceReadCallback;
 import org.cef.handler.CefResourceHandlerAdapter;
+import org.cef.misc.BoolRef;
 import org.cef.misc.IntRef;
 import org.cef.misc.StringRef;
 import org.cef.network.CefRequest;
@@ -33,7 +35,8 @@ public ClientSchemeHandler() {
     }
 
     @Override
-    public synchronized boolean processRequest(CefRequest request, CefCallback callback) {
+    public synchronized boolean open(
+            CefRequest request, BoolRef handleRequest, CefCallback callback) {
         boolean handled = false;
         String url = request.getURL();
         if (url.indexOf("handler.html") != -1) {
@@ -77,9 +80,10 @@ public synchronized boolean processRequest(CefRequest request, CefCallback callb
             }
         }
 
+        // All requests are handled immediately
+        handleRequest.set(true);
+
         if (handled) {
-            // Indicate the headers are available.
-            callback.Continue();
             return true;
         }
 
@@ -97,8 +101,8 @@ public void getResponseHeaders(
     }
 
     @Override
-    public synchronized boolean readResponse(
-            byte[] data_out, int bytes_to_read, IntRef bytes_read, CefCallback callback) {
+    public synchronized boolean read(byte[] data_out, int bytes_to_read, IntRef bytes_read,
+            CefResourceReadCallback callback) {
         boolean has_data = false;
 
         if (offset_ < data_.length) {

java/tests/detailed/handler/ResourceHandler.java

@@ -1,8 +1,10 @@
 package tests.detailed.handler;
 
 import org.cef.callback.CefCallback;
+import org.cef.callback.CefResourceReadCallback;
 import org.cef.handler.CefLoadHandler;
 import org.cef.handler.CefResourceHandlerAdapter;
+import org.cef.misc.BoolRef;
 import org.cef.misc.IntRef;
 import org.cef.misc.StringRef;
 import org.cef.network.CefRequest;
@@ -25,11 +27,11 @@ public class ResourceHandler extends CefResourceHandlerAdapter {
             + "</html>");
 
     @Override
-    public boolean processRequest(CefRequest request, CefCallback callback) {
+    public boolean open(CefRequest request, BoolRef handleRequest, CefCallback callback) {
         System.out.println("processRequest: " + request);
 
         startPos = 0;
-        callback.Continue();
+        handleRequest.set(true);
         return true;
     }
 
@@ -44,8 +46,8 @@ public void getResponseHeaders(
     }
 
     @Override
-    public boolean readResponse(
-            byte[] data_out, int bytes_to_read, IntRef bytes_read, CefCallback callback) {
+    public boolean read(byte[] data_out, int bytes_to_read, IntRef bytes_read,
+            CefResourceReadCallback callback) {
         int length = html.length();
         if (startPos >= length) return false;
 

java/tests/detailed/handler/ResourceSetErrorHandler.java

@@ -3,16 +3,17 @@
 import org.cef.callback.CefCallback;
 import org.cef.handler.CefLoadHandler.ErrorCode;
 import org.cef.handler.CefResourceHandlerAdapter;
+import org.cef.misc.BoolRef;
 import org.cef.misc.IntRef;
 import org.cef.misc.StringRef;
 import org.cef.network.CefRequest;
 import org.cef.network.CefResponse;
 
 public class ResourceSetErrorHandler extends CefResourceHandlerAdapter {
     @Override
-    public boolean processRequest(CefRequest request, CefCallback callback) {
+    public boolean open(CefRequest request, BoolRef handleRequest, CefCallback callback) {
         System.out.println("processRequest: " + request);
-        callback.Continue();
+        handleRequest.set(true);
         return true;
     }