Move ChannelHandler.Skip to ChannelHandlerMask.Skip and make it packa… (#8987)

Motivation:

8fdf373557 introduced the @Skip annotation which allows to optimize the way we invoke ChannelHandlers when traversing the pipeline. Now that we moved all the "default" code to the ChannelHandler interface we can make the annotation package-private to guard the user to make any mistakes which will lead to hard to debug issues.

Modifications:

Move ChannelHandler.Skip to ChannelHandlerMask.Skip and make it package-private

Result:

Guard users from introduce hard to debug issues.

transport/src/main/java/io/netty/channel/ChannelHandler.java

@@ -17,6 +17,7 @@ package io.netty.channel;
 
 import io.netty.util.Attribute;
 import io.netty.util.AttributeKey;
+import io.netty.channel.ChannelHandlerMask.Skip;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
@@ -194,32 +195,6 @@ public interface ChannelHandler {
         // no value
     }
 
-    /**
-     * Indicates that the annotated event handler method in {@link ChannelHandler} will not be invoked by
-     * {@link ChannelPipeline}. This annotation is only useful when your handler method implementation
-     * only passes the event through to the next handler, like the following:
-     *
-     * <pre>
-     * {@code @Skip}
-     * {@code @Override}
-     * public void channelActive({@link ChannelHandlerContext} ctx) {
-     *     ctx.fireChannelActive(); // do nothing but passing through to the next handler
-     * }
-     * </pre>
-     *
-     * <p>
-     * Note that this annotation is not {@linkplain Inherited inherited}.  If you override a method annotated with
-     * {@link Skip}, it will not be skipped anymore.  Similarly, you can override a method not annotated with
-     * {@link Skip} and simply pass the event through to the next handler, which reverses the behavior of the
-     * supertype.
-     * </p>
-     */
-    @Target(ElementType.METHOD)
-    @Retention(RetentionPolicy.RUNTIME)
-    @interface Skip {
-        // no value
-    }
-
     /**
      * The {@link Channel} of the {@link ChannelHandlerContext} was registered with its {@link EventLoop}
      */

transport/src/main/java/io/netty/channel/ChannelHandlerMask.java

@@ -18,6 +18,11 @@ package io.netty.channel;
 import io.netty.util.concurrent.FastThreadLocal;
 import io.netty.util.internal.PlatformDependent;
 
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 import java.net.SocketAddress;
 import java.security.AccessController;
 import java.security.PrivilegedExceptionAction;
@@ -163,8 +168,25 @@ final class ChannelHandlerMask {
             final Class<?> handlerType, final String methodName, final Class<?>... paramTypes) throws Exception {
 
         return AccessController.doPrivileged((PrivilegedExceptionAction<Boolean>) () ->
-                handlerType.getMethod(methodName, paramTypes).isAnnotationPresent(ChannelHandler.Skip.class));
+                handlerType.getMethod(methodName, paramTypes).isAnnotationPresent(Skip.class));
     }
 
     private ChannelHandlerMask() { }
+
+    /**
+     * Indicates that the annotated event handler method in {@link ChannelHandler} will not be invoked by
+     * {@link ChannelPipeline} and so <strong>MUST</strong> only be used when the {@link ChannelHandler}
+     * method does nothing except forward to the next {@link ChannelHandler} in the pipeline.
+     * <p>
+     * Note that this annotation is not {@linkplain Inherited inherited}. If a user overrides a method annotated with
+     * {@link Skip}, it will not be skipped anymore. Similarly, the user can override a method not annotated with
+     * {@link Skip} and simply pass the event through to the next handler, which reverses the behavior of the
+     * supertype.
+     * </p>
+     */
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.RUNTIME)
+    @interface Skip {
+        // no value
+    }
 }

transport/src/test/java/io/netty/channel/DefaultChannelPipelineTest.java

@@ -21,6 +21,7 @@ import io.netty.bootstrap.ServerBootstrap;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelHandler.Sharable;
+import io.netty.channel.ChannelHandlerMask.Skip;
 import io.netty.channel.embedded.EmbeddedChannel;
 import io.netty.channel.local.LocalAddress;
 import io.netty.channel.local.LocalChannel;