Correct serializable issues and test that components can be serialized

Change-Id: Iac8f0f48806c0a7c3030bd406e2e533104f26753

server/src/main/java/com/vaadin/data/BeanBinder.java

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Objects;
-import java.util.function.Function;
-import java.util.function.Predicate;
 
 import com.vaadin.data.util.BeanUtil;
 import com.vaadin.data.util.converter.Converter;
 import com.vaadin.data.validator.BeanValidator;
+import com.vaadin.server.SerializableBiConsumer;
+import com.vaadin.server.SerializableFunction;
+import com.vaadin.server.SerializablePredicate;
 import com.vaadin.util.ReflectTools;
 
 /**
 
         @Override
         public default BeanBinding<BEAN, FIELDVALUE, TARGET> withValidator(
-                Predicate<? super TARGET> predicate, String message) {
+                SerializablePredicate<? super TARGET> predicate,
+                String message) {
             return (BeanBinding<BEAN, FIELDVALUE, TARGET>) Binding.super.withValidator(
                     predicate, message);
         }
 
         @Override
         public default <NEWTARGET> BeanBinding<BEAN, FIELDVALUE, NEWTARGET> withConverter(
-                Function<TARGET, NEWTARGET> toModel,
-                Function<NEWTARGET, TARGET> toPresentation) {
+                SerializableFunction<TARGET, NEWTARGET> toModel,
+                SerializableFunction<NEWTARGET, TARGET> toPresentation) {
             return (BeanBinding<BEAN, FIELDVALUE, NEWTARGET>) Binding.super.withConverter(
                     toModel, toPresentation);
         }
 
         @Override
         public default <NEWTARGET> BeanBinding<BEAN, FIELDVALUE, NEWTARGET> withConverter(
-                Function<TARGET, NEWTARGET> toModel,
-                Function<NEWTARGET, TARGET> toPresentation,
+                SerializableFunction<TARGET, NEWTARGET> toModel,
+                SerializableFunction<NEWTARGET, TARGET> toPresentation,
                 String errorMessage) {
             return (BeanBinding<BEAN, FIELDVALUE, NEWTARGET>) Binding.super.withConverter(
                     toModel, toPresentation, errorMessage);
          * @throws IllegalArgumentException
          *             if the property has no accessible getter
          *
-         * @see Binding#bind(Function, java.util.function.BiConsumer)
+         * @see Binding#bind(SerializableFunction, SerializableBiConsumer)
          */
         public void bind(String propertyName);
     }
      * @throws IllegalArgumentException
      *             if the property has no accessible getter
      *
-     * @see #bind(HasValue, java.util.function.Function,
-     *      java.util.function.BiConsumer)
+     * @see #bind(HasValue, SerializableFunction, SerializableBiConsumer)
      */
     public <FIELDVALUE> void bind(HasValue<FIELDVALUE> field,
             String propertyName) {

server/src/main/java/com/vaadin/data/Binder.java

 import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiConsumer;
-import java.util.function.Function;
-import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import com.vaadin.data.util.converter.Converter;
 import com.vaadin.data.util.converter.ValueContext;
 import com.vaadin.event.EventRouter;
 import com.vaadin.server.ErrorMessage;
+import com.vaadin.server.SerializableBiConsumer;
+import com.vaadin.server.SerializableFunction;
+import com.vaadin.server.SerializablePredicate;
 import com.vaadin.server.UserError;
 import com.vaadin.shared.Registration;
 import com.vaadin.ui.AbstractComponent;
          * @throws IllegalStateException
          *             if {@code bind} has already been called on this binding
          */
-        public void bind(Function<BEAN, TARGET> getter,
-                BiConsumer<BEAN, TARGET> setter);
+        public void bind(SerializableFunction<BEAN, TARGET> getter,
+                com.vaadin.server.SerializableBiConsumer<BEAN, TARGET> setter);
 
         /**
          * Adds a validator to this binding. Validators are applied, in
 
         /**
          * A convenience method to add a validator to this binding using the
-         * {@link Validator#from(Predicate, String)} factory method.
+         * {@link Validator#from(SerializablePredicate, String)} factory method.
          * <p>
          * Validators are applied, in registration order, when the field value
          * is saved to the backing property. If any validator returns a failure,
          * the property value is not updated.
          *
          * @see #withValidator(Validator)
-         * @see Validator#from(Predicate, String)
+         * @see Validator#from(SerializablePredicate, String)
          *
          * @param predicate
          *            the predicate performing validation, not null
          *             if {@code bind} has already been called
          */
         public default Binding<BEAN, FIELDVALUE, TARGET> withValidator(
-                Predicate<? super TARGET> predicate, String message) {
+                SerializablePredicate<? super TARGET> predicate,
+                String message) {
             return withValidator(Validator.from(predicate, message));
         }
 
          * which must match the current target data type of the binding, and a
          * model type, which can be any data type and becomes the new target
          * type of the binding. When invoking
-         * {@link #bind(Function, BiConsumer)}, the target type of the binding
-         * must match the getter/setter types.
+         * {@link #bind(SerializableFunction, SerializableBiConsumer)}, the
+         * target type of the binding must match the getter/setter types.
          * <p>
          * For instance, a {@code TextField} can be bound to an integer-typed
          * property using an appropriate converter such as a
          * type, which must match the current target data type of the binding,
          * and a model type, which can be any data type and becomes the new
          * target type of the binding. When invoking
-         * {@link #bind(Function, BiConsumer)}, the target type of the binding
-         * must match the getter/setter types.
+         * {@link #bind(SerializableFunction, SerializableBiConsumer)}, the
+         * target type of the binding must match the getter/setter types.
          * <p>
          * For instance, a {@code TextField} can be bound to an integer-typed
          * property using appropriate functions such as:
          *             if {@code bind} has already been called
          */
         public default <NEWTARGET> Binding<BEAN, FIELDVALUE, NEWTARGET> withConverter(
-                Function<TARGET, NEWTARGET> toModel,
-                Function<NEWTARGET, TARGET> toPresentation) {
+                SerializableFunction<TARGET, NEWTARGET> toModel,
+                SerializableFunction<NEWTARGET, TARGET> toPresentation) {
             return withConverter(Converter.from(toModel, toPresentation,
                     exception -> exception.getMessage()));
         }
          * type, which must match the current target data type of the binding,
          * and a model type, which can be any data type and becomes the new
          * target type of the binding. When invoking
-         * {@link #bind(Function, BiConsumer)}, the target type of the binding
-         * must match the getter/setter types.
+         * {@link #bind(SerializableFunction, SerializableBiConsumer)}, the
+         * target type of the binding must match the getter/setter types.
          * <p>
          * For instance, a {@code TextField} can be bound to an integer-typed
          * property using appropriate functions such as:
          *             if {@code bind} has already been called
          */
         public default <NEWTARGET> Binding<BEAN, FIELDVALUE, NEWTARGET> withConverter(
-                Function<TARGET, NEWTARGET> toModel,
-                Function<NEWTARGET, TARGET> toPresentation,
+                SerializableFunction<TARGET, NEWTARGET> toModel,
+                SerializableFunction<NEWTARGET, TARGET> toPresentation,
                 String errorMessage) {
             return withConverter(Converter.from(toModel, toPresentation,
                     exception -> errorMessage));
         private ValidationStatusHandler statusHandler;
         private boolean isStatusHandlerChanged;
 
-        private Function<BEAN, TARGET> getter;
-        private BiConsumer<BEAN, TARGET> setter;
+        private SerializableFunction<BEAN, TARGET> getter;
+        private SerializableBiConsumer<BEAN, TARGET> setter;
 
         /**
          * Contains all converters and validators chained together in the
         }
 
         @Override
-        public void bind(Function<BEAN, TARGET> getter,
-                BiConsumer<BEAN, TARGET> setter) {
+        public void bind(SerializableFunction<BEAN, TARGET> getter,
+                SerializableBiConsumer<BEAN, TARGET> setter) {
             checkUnbound();
             Objects.requireNonNull(getter, "getter cannot be null");
 
 
     /**
      * Creates a new binding for the given field. The returned binding may be
-     * further configured before invoking
+     * further configured before invoking <<<<<<< Upstream, based on master
      * {@link Binding#bind(Function, BiConsumer) Binding.bind} which completes
      * the binding. Until {@code Binding.bind} is called, the binding has no
      * effect.
      * automatically change {@code null} to a null representation provided by
      * {@link HasValue#getEmptyValue()}. This conversion is one-way only, if you
      * want to have a two-way mapping back to {@code null}, use
-     * {@link Binding#withNullRepresentation(Object))}.
+     * {@link Binding#withNullRepresentation(Object))}. =======
+     * {@link Binding#bind(SerializableFunction, SerializableBiConsumer)
+     * Binding.bind} which completes the binding. Until {@code Binding.bind} is
+     * called, the binding has no effect. >>>>>>> 7d541b5 Correct serializable
+     * issues and test that components can be serialized
      *
      * @param <FIELDVALUE>
      *            the value type of the field
      *            the field to be bound, not null
      * @return the new binding
      *
-     * @see #bind(HasValue, Function, BiConsumer)
+     * @see #bind(HasValue, SerializableFunction, SerializableBiConsumer)
      */
     public <FIELDVALUE> Binding<BEAN, FIELDVALUE, FIELDVALUE> forField(
             HasValue<FIELDVALUE> field) {
      *            if read-only
      */
     public <FIELDVALUE> void bind(HasValue<FIELDVALUE> field,
-            Function<BEAN, FIELDVALUE> getter,
-            BiConsumer<BEAN, FIELDVALUE> setter) {
+            SerializableFunction<BEAN, FIELDVALUE> getter,
+            SerializableBiConsumer<BEAN, FIELDVALUE> setter) {
         forField(field).bind(getter, setter);
     }
 
      * <li>{@link #load(Object)} is called
      * <li>{@link #bind(Object)} is called
      * <li>{@link #unbind(Object)} is called
-     * <li>{@link Binding#bind(Function, BiConsumer)} is called
+     * <li>{@link Binding#bind(SerializableFunction, SerializableBiConsumer)} is
+     * called
      * <li>{@link Binder#validate()} or {@link Binding#validate()} is called
      * </ul>
      *

server/src/main/java/com/vaadin/data/Validator.java

 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import com.vaadin.server.SerializablePredicate;
+
 /**
  * A functional interface for validating user input or other potentially invalid
  * data. When a validator instance is applied to a value of the corresponding
      *            the message returned if validation fails, not null
      * @return the new validator using the function
      */
-    public static <T> Validator<T> from(Predicate<T> guard,
+    public static <T> Validator<T> from(SerializablePredicate<T> guard,
             String errorMessage) {
         Objects.requireNonNull(guard, "guard cannot be null");
         Objects.requireNonNull(errorMessage, "errorMessage cannot be null");

server/src/main/java/com/vaadin/data/util/converter/Converter.java

 
 import com.vaadin.data.Binder.Binding;
 import com.vaadin.data.Result;
+import com.vaadin.server.SerializableFunction;
 
 /**
  * Interface that implements conversion between a model and a presentation type.
      * @see Result
      * @see Function
      */
-    public static <P, M> Converter<P, M> from(Function<P, M> toModel,
-            Function<M, P> toPresentation,
-            Function<Exception, String> onError) {
+    public static <P, M> Converter<P, M> from(
+            SerializableFunction<P, M> toModel,
+            SerializableFunction<M, P> toPresentation,
+            SerializableFunction<Exception, String> onError) {
 
         return from(val -> Result.of(() -> toModel.apply(val), onError),
                 toPresentation);
      *
      * @see Function
      */
-    public static <P, M> Converter<P, M> from(Function<P, Result<M>> toModel,
-            Function<M, P> toPresentation) {
+    public static <P, M> Converter<P, M> from(
+            SerializableFunction<P, Result<M>> toModel,
+            SerializableFunction<M, P> toPresentation) {
         return new Converter<P, M>() {
 
             @Override

server/src/main/java/com/vaadin/data/validator/AbstractValidator.java

 package com.vaadin.data.validator;
 
 import java.util.Objects;
-import java.util.function.Function;
 
 import com.vaadin.data.Result;
 import com.vaadin.data.Validator;
+import com.vaadin.server.SerializableFunction;
 
 /**
  * An abstract base class for typed validators.
  */
 public abstract class AbstractValidator<T> implements Validator<T> {
 
-    private Function<T, String> messageProvider;
+    private SerializableFunction<T, String> messageProvider;
 
     /**
      * Constructs a validator with the given error message. The substring "{0}"

server/src/main/java/com/vaadin/server/SerializableBiConsumer.java

+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * 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.
+ */
+package com.vaadin.server;
+
+import java.io.Serializable;
+import java.util.function.BiConsumer;
+
+/**
+ * A {@link BiConsumer} that is also {@link Serializable}.
+ * 
+ * @see {@link BiConsumer}
+ * @param <T>
+ *            the type of the first argument to the operation
+ * @param <U>
+ *            the type of the second argument to the operation
+ * 
+ * @since 8.0
+ * @author Vaadin Ltd
+ *
+ */
+@FunctionalInterface
+public interface SerializableBiConsumer<T, U>
+        extends BiConsumer<T, U>, Serializable {
+    // Only method inherited from BiConsumer
+}

server/src/main/java/com/vaadin/server/SerializableComparator.java

+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * 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.
+ */
+package com.vaadin.server;
+
+import java.io.Serializable;
+import java.util.Comparator;
+
+/**
+ * A {@link Comparator} that is also {@link Serializable}.
+ * 
+ * @author Vaadin Ltd
+ * @param <T>
+ *            the type of objects that may be compared by this comparator
+ * @since 8.0
+ *
+ */
+@FunctionalInterface
+public interface SerializableComparator<T> extends Comparator<T>, Serializable {
+
+    /**
+     * Returns a {@link SerializableComparator} instance which delegates its
+     * logic to the provided {@code comparator}.
+     * 
+     * @param comparator
+     *            comparator to convert
+     * @param <T>
+     *            the type of objects that may be compared by this comparator
+     * @param <C>
+     *            the comparator type
+     * @return a SerializableComparator view of the {@code comparator}
+     */
+    static <C extends Comparator<T> & Serializable, T> SerializableComparator<T> asInstance(
+            C comparator) {
+        return (arg1, arg2) -> comparator.compare(arg1, arg2);
+    }
+}

server/src/main/java/com/vaadin/server/SerializableFunction.java

+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * 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.
+ */
+package com.vaadin.server;
+
+import java.io.Serializable;
+import java.util.function.Function;
+
+/**
+ * A {@link Function} that is also {@link Serializable}.
+ *
+ * @see Function
+ * @author Vaadin Ltd
+ * @since 8.0
+ * @param <T>
+ *            the type of the input to the function
+ * @param <R>
+ *            the type of the result of the function
+ */
+@FunctionalInterface
+public interface SerializableFunction<T, R>
+        extends Function<T, R>, Serializable {
+    /**
+     * Returns a function that always returns its input argument.
+     *
+     * @param <T>
+     *            the type of the input and output objects to the function
+     * @return a function that always returns its input argument
+     */
+    static <T> SerializableFunction<T, T> identity() {
+        return t -> t;
+    }
+
+}

server/src/main/java/com/vaadin/server/SerializablePredicate.java

+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * 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.
+ */
+package com.vaadin.server;
+
+import java.io.Serializable;
+import java.util.function.Predicate;
+
+/**
+ * A {@link Predicate} that is also {@link Serializable}.
+ * 
+ * @author Vaadin Ltd
+ * @since 8.0
+ * @param <T>
+ *            the type of the input to the predicate
+ *
+ */
+public interface SerializablePredicate<T> extends Predicate<T>, Serializable {
+    // Only method inherited from Function
+}

server/src/main/java/com/vaadin/server/data/BackEndDataSource.java

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
-import java.util.function.Function;
 import java.util.stream.Stream;
 
+import com.vaadin.server.SerializableFunction;
+
 /**
  * A {@link DataSource} for any back end.
  *
  */
 public class BackEndDataSource<T> extends AbstractDataSource<T> {
 
-    private Function<Query, Stream<T>> request;
-    private Function<Query, Integer> sizeCallback;
+    private SerializableFunction<Query, Stream<T>> request;
+    private SerializableFunction<Query, Integer> sizeCallback;
 
     /**
      * Constructs a new DataSource to request data from an arbitrary back end
      * @param sizeCallback
      *            function that return the amount of data in back end for query
      */
-    public BackEndDataSource(Function<Query, Stream<T>> request,
-            Function<Query, Integer> sizeCallback) {
+    public BackEndDataSource(SerializableFunction<Query, Stream<T>> request,
+            SerializableFunction<Query, Integer> sizeCallback) {
         Objects.requireNonNull(request, "Request function can't be null");
         Objects.requireNonNull(sizeCallback, "Size callback can't be null");
         this.request = request;

server/src/main/java/com/vaadin/server/data/DataCommunicator.java

 
 import com.vaadin.server.AbstractExtension;
 import com.vaadin.server.KeyMapper;
+import com.vaadin.server.SerializablePredicate;
 import com.vaadin.shared.Range;
 import com.vaadin.shared.Registration;
 import com.vaadin.shared.data.DataCommunicatorClientRpc;
     private Range pushRows = Range.withLength(0, 40);
 
     private Comparator<T> inMemorySorting;
-    private Predicate<T> inMemoryFilter;
+    private SerializablePredicate<T> inMemoryFilter;
     private List<SortOrder<String>> backEndSorting = new ArrayList<>();
     private DataCommunicatorClientRpc rpc;
 
      * @param predicate
      *            predicate used to filter data
      */
-    public void setInMemoryFilter(Predicate<T> predicate) {
+    public void setInMemoryFilter(SerializablePredicate<T> predicate) {
         inMemoryFilter = predicate;
         reset();
     }

server/src/main/java/com/vaadin/ui/AbstractMultiSelect.java

 import com.vaadin.event.selection.MultiSelectionListener;
 import com.vaadin.server.Resource;
 import com.vaadin.server.ResourceReference;
+import com.vaadin.server.SerializablePredicate;
 import com.vaadin.server.data.DataGenerator;
 import com.vaadin.shared.Registration;
 import com.vaadin.shared.data.selection.MultiSelectServerRpc;
      * The item enabled status provider. It is up to the implementing class to
      * support this or not.
      */
-    private Predicate<T> itemEnabledProvider = item -> true;
+    private SerializablePredicate<T> itemEnabledProvider = item -> true;
 
     /**
      * Creates a new multi select with an empty data source.
      * Returns the item enabled provider for this multiselect.
      * <p>
      * <em>Implementation note:</em> Override this method and
-     * {@link #setItemEnabledProvider(Predicate)} as {@code public} and invoke
-     * {@code super} methods to support this feature in the multiselect
-     * component.
+     * {@link #setItemEnabledProvider(SerializablePredicate)} as {@code public}
+     * and invoke {@code super} methods to support this feature in the
+     * multiselect component.
      *
      * @return the item enabled provider, not {@code null}
      * @see #setItemEnabledProvider(Predicate)
      */
-    protected Predicate<T> getItemEnabledProvider() {
+    protected SerializablePredicate<T> getItemEnabledProvider() {
         return itemEnabledProvider;
     }
 
      * @param itemEnabledProvider
      *            the item enabled provider to set, not {@code null}
      */
-    protected void setItemEnabledProvider(Predicate<T> itemEnabledProvider) {
+    protected void setItemEnabledProvider(
+            SerializablePredicate<T> itemEnabledProvider) {
         Objects.requireNonNull(itemEnabledProvider);
         this.itemEnabledProvider = itemEnabledProvider;
     }

server/src/main/java/com/vaadin/ui/CheckBoxGroup.java

 package com.vaadin.ui;
 
 import java.util.Collection;
-import java.util.function.Predicate;
 
 import com.vaadin.data.Listing;
+import com.vaadin.server.SerializablePredicate;
 import com.vaadin.server.data.DataSource;
 import com.vaadin.shared.ui.optiongroup.CheckBoxGroupState;
 
     }
 
     @Override
-    public Predicate<T> getItemEnabledProvider() {
+    public SerializablePredicate<T> getItemEnabledProvider() {
         return super.getItemEnabledProvider();
     }
 
     @Override
-    public void setItemEnabledProvider(Predicate<T> itemEnabledProvider) {
+    public void setItemEnabledProvider(
+            SerializablePredicate<T> itemEnabledProvider) {
         super.setItemEnabledProvider(itemEnabledProvider);
     }
 }

server/src/main/java/com/vaadin/ui/Grid.java

 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import com.vaadin.event.EventListener;
 import com.vaadin.server.EncodeResult;
 import com.vaadin.server.JsonCodec;
+import com.vaadin.server.SerializableComparator;
+import com.vaadin.server.SerializableFunction;
 import com.vaadin.server.data.SortOrder;
 import com.vaadin.shared.MouseEventDetails;
 import com.vaadin.shared.Registration;
      */
     @FunctionalInterface
     public interface DescriptionGenerator<T>
-            extends Function<T, String>, Serializable {
+            extends SerializableFunction<T, String> {
     }
 
     /**
 
             // Set sort orders
             // In-memory comparator
-            Comparator<T> comparator = sortOrder.stream()
+            BinaryOperator<SerializableComparator<T>> operator = (comparator1,
+                    comparator2) -> SerializableComparator.asInstance(
+                            (Comparator<T> & Serializable) comparator1
+                                    .thenComparing(comparator2));
+            SerializableComparator<T> comparator = sortOrder.stream()
                     .map(order -> order.getSorted()
                             .getComparator(order.getDirection()))
-                    .reduce((x, y) -> 0, Comparator::thenComparing);
+                    .reduce((x, y) -> 0, operator);
             getDataCommunicator().setInMemorySorting(comparator);
 
             // Back-end sort properties
      */
     public static class Column<T, V> extends AbstractGridExtension<T> {
 
-        private final Function<T, ? extends V> valueProvider;
+        private final SerializableFunction<T, ? extends V> valueProvider;
 
-        private Function<SortDirection, Stream<SortOrder<String>>> sortOrderProvider;
-        private Comparator<T> comparator;
+        private SerializableFunction<SortDirection, Stream<SortOrder<String>>> sortOrderProvider;
+        private SerializableComparator<T> comparator;
         private StyleGenerator<T> styleGenerator = item -> null;
         private DescriptionGenerator<T> descriptionGenerator;
 
          * @param renderer
          *            the type of value
          */
-        protected Column(String caption, Function<T, ? extends V> valueProvider,
+        protected Column(String caption,
+                SerializableFunction<T, ? extends V> valueProvider,
                 Renderer<V> renderer) {
             Objects.requireNonNull(caption, "Header caption can't be null");
             Objects.requireNonNull(valueProvider,
          *            the comparator to use when sorting data in this column
          * @return this column
          */
-        public Column<T, V> setComparator(Comparator<T> comparator) {
+        public Column<T, V> setComparator(
+                SerializableComparator<T> comparator) {
             Objects.requireNonNull(comparator, "Comparator can't be null");
             this.comparator = comparator;
             return this;
          *            the direction this column is sorted by
          * @return comparator for this column
          */
-        public Comparator<T> getComparator(SortDirection sortDirection) {
+        public SerializableComparator<T> getComparator(
+                SortDirection sortDirection) {
             Objects.requireNonNull(comparator,
                     "No comparator defined for sorted column.");
             boolean reverse = sortDirection != SortDirection.ASCENDING;
-            return reverse ? comparator.reversed() : comparator;
+            return reverse ? (t1, t2) -> comparator.reversed().compare(t1, t2)
+                    : comparator;
         }
 
         /**
          * @return this column
          */
         public Column<T, V> setSortOrderProvider(
-                Function<SortDirection, Stream<SortOrder<String>>> provider) {
+                SerializableFunction<SortDirection, Stream<SortOrder<String>>> provider) {
             Objects.requireNonNull(provider,
                     "Sort order provider can't be null");
             sortOrderProvider = provider;
      * @see {@link AbstractRenderer}
      */
     public <V> Column<T, V> addColumn(String identifier,
-            Function<T, ? extends V> valueProvider,
+            SerializableFunction<T, ? extends V> valueProvider,
             AbstractRenderer<? super T, V> renderer)
             throws IllegalArgumentException {
         if (columnKeys.containsKey(identifier)) {
      *             if the same identifier is used for multiple columns
      */
     public Column<T, String> addColumn(String identifier,
-            Function<T, String> valueProvider) {
+            SerializableFunction<T, String> valueProvider) {
         return addColumn(identifier, valueProvider, new TextRenderer());
     }
 
      *
      * @return the new column
      */
-    public Column<T, String> addColumn(Function<T, String> valueProvider) {
+    public Column<T, String> addColumn(
+            SerializableFunction<T, String> valueProvider) {
         return addColumn(getGeneratedIdentifier(), valueProvider,
                 new TextRenderer());
     }
      *
      * @see {@link AbstractRenderer}
      */
-    public <V> Column<T, V> addColumn(Function<T, ? extends V> valueProvider,
+    public <V> Column<T, V> addColumn(
+            SerializableFunction<T, ? extends V> valueProvider,
             AbstractRenderer<? super T, V> renderer) {
         return addColumn(getGeneratedIdentifier(), valueProvider, renderer);
     }
             boolean userOriginated) {
         fireEvent(new ColumnResizeEvent(this, column, userOriginated));
     }
+
 }

server/src/main/java/com/vaadin/ui/IconGenerator.java

  */
 package com.vaadin.ui;
 
-import java.io.Serializable;
-import java.util.function.Function;
-
 import com.vaadin.server.Resource;
+import com.vaadin.server.SerializableFunction;
 
 /**
  * A callback interface for generating icons for an item.
  *            item type for which the icon is generated
  */
 @FunctionalInterface
-public interface IconGenerator<T> extends Function<T, Resource>, Serializable {
+public interface IconGenerator<T> extends SerializableFunction<T, Resource> {
 
     /**
      * Gets an icon resource for the {@code item}.

server/src/main/java/com/vaadin/ui/ItemCaptionGenerator.java

  */
 package com.vaadin.ui;
 
-import java.io.Serializable;
-import java.util.function.Function;
+import com.vaadin.server.SerializableFunction;
 
 /**
  * {@link ItemCaptionGenerator} can be used to customize the string shown to the
  */
 @FunctionalInterface
 public interface ItemCaptionGenerator<T>
-        extends Function<T, String>, Serializable {
+        extends SerializableFunction<T, String> {
 
     /**
      * Gets a caption for the {@code item}.

server/src/main/java/com/vaadin/ui/RadioButtonGroup.java

 
 import java.util.Collection;
 import java.util.Objects;
-import java.util.function.Predicate;
 
 import com.vaadin.data.Listing;
 import com.vaadin.server.Resource;
 import com.vaadin.server.ResourceReference;
+import com.vaadin.server.SerializablePredicate;
 import com.vaadin.server.data.DataGenerator;
 import com.vaadin.server.data.DataSource;
 import com.vaadin.shared.ui.ListingJsonConstants;
 
     private ItemCaptionGenerator<T> itemCaptionGenerator = String::valueOf;
 
-    private Predicate<T> itemEnabledProvider = item -> true;
+    private SerializablePredicate<T> itemEnabledProvider = item -> true;
 
     /**
      * Constructs a new RadioButtonGroup with caption.
      * @return the item enabled predicate
      * @see #setItemEnabledProvider
      */
-    public Predicate<T> getItemEnabledProvider() {
+    public SerializablePredicate<T> getItemEnabledProvider() {
         return itemEnabledProvider;
     }
 
      * @param itemEnabledProvider
      *            the item enable predicate, not null
      */
-    public void setItemEnabledProvider(Predicate<T> itemEnabledProvider) {
+    public void setItemEnabledProvider(
+            SerializablePredicate<T> itemEnabledProvider) {
         Objects.requireNonNull(itemEnabledProvider);
         this.itemEnabledProvider = itemEnabledProvider;
     }

server/src/main/java/com/vaadin/ui/StyleGenerator.java

  */
 package com.vaadin.ui;
 
-import java.io.Serializable;
-import java.util.function.Function;
+import com.vaadin.server.SerializableFunction;
 
 /**
  * A callback interface for generating custom CSS class names for items.
  * @author Vaadin Ltd
  */
 @FunctionalInterface
-public interface StyleGenerator<T> extends Function<T, String>, Serializable {
+public interface StyleGenerator<T> extends SerializableFunction<T, String> {
 
     /**
      * Gets a class name for the {@code item}.

server/src/test/java/com/vaadin/data/BinderConverterValidatorTest.java

 
 import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Predicate;
 
 import org.junit.Assert;
 import org.junit.Before;
 import com.vaadin.data.validator.NotEmptyValidator;
 import com.vaadin.server.AbstractErrorMessage;
 import com.vaadin.server.ErrorMessage;
+import com.vaadin.server.SerializablePredicate;
 import com.vaadin.server.UserError;
 import com.vaadin.tests.data.bean.Person;
 import com.vaadin.ui.Label;
     @Test
     public void binderLoad_withCrossFieldValidation_clearsErrors() {
         TextField lastNameField = new TextField();
-        final Predicate<String> lengthPredicate = v -> v.length() > 2;
+        final SerializablePredicate<String> lengthPredicate = v -> v
+                .length() > 2;
 
         Binding<Person, String, String> firstNameBinding = binder
                 .forField(nameField).withValidator(lengthPredicate, "length");

server/src/test/java/com/vaadin/tests/data/converter/ConverterTest.java

 package com.vaadin.tests.data.converter;
 
-import java.util.function.Function;
-
 import org.junit.Assert;
 import org.junit.Test;
 
 import com.vaadin.data.Result;
 import com.vaadin.data.util.converter.Converter;
 import com.vaadin.data.util.converter.ValueContext;
+import com.vaadin.server.SerializableFunction;
 
 public class ConverterTest {
 
-    Function<String, Result<String>> toModel = presentation -> {
+    SerializableFunction<String, Result<String>> toModel = presentation -> {
         if (presentation.startsWith("presentation-")) {
             return Result.ok(presentation.substring("presentation-".length()));
         } else {
         }
     };
 
-    Function<String, String> toPresentation = model -> "presentation-" + model;
+    SerializableFunction<String, String> toPresentation = model -> "presentation-"
+            + model;
 
     Converter<String, String> converter = Converter.from(toModel,
             toPresentation);

server/src/test/java/com/vaadin/tests/server/ClassesSerializableTest.java

 package com.vaadin.tests.server;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.io.Serializable;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Optional;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.junit.Assert;
 import org.junit.Test;
 
+import com.vaadin.ui.Component;
+
 public class ClassesSerializableTest {
 
     /**
             classes.addAll(findServerClasses(location));
         }
 
+        ArrayList<Field> nonSerializableFunctionFields = new ArrayList<>();
+
         ArrayList<Class<?>> nonSerializableClasses = new ArrayList<>();
         for (String className : classes) {
             Class<?> cls = Class.forName(className);
+            // Don't add classes that have a @Ignore annotation on the class
+            if (isTestClass(cls)) {
+                continue;
+            }
+
+            // report fields that use lambda types that won't be serializable
+            // (also in syntehtic classes)
+            Stream.of(cls.getDeclaredFields())
+                    .filter(field -> isFunctionalType(field.getGenericType()))
+                    .forEach(nonSerializableFunctionFields::add);
+
             // skip annotations and synthetic classes
             if (cls.isAnnotation() || cls.isSynthetic()) {
                 continue;
             }
-            // Don't add classes that have a @Ignore annotation on the class
-            if (isTestClass(cls)) {
-                continue;
+
+            if (Component.class.isAssignableFrom(cls) && !cls.isInterface()
+                    && !Modifier.isAbstract(cls.getModifiers())) {
+                serializeAndDeserialize(cls);
             }
 
             // report non-serializable classes and interfaces
         // useful failure message including all non-serializable classes and
         // interfaces
         if (!nonSerializableClasses.isEmpty()) {
-            String nonSerializableString = "";
-            Iterator<Class<?>> it = nonSerializableClasses.iterator();
-            while (it.hasNext()) {
-                Class c = it.next();
-                nonSerializableString += ", " + c.getName();
-                if (c.isAnonymousClass()) {
-                    nonSerializableString += "(super: ";
-                    nonSerializableString += c.getSuperclass().getName();
-                    nonSerializableString += ", interfaces: ";
-                    for (Class i : c.getInterfaces()) {
-                        nonSerializableString += i.getName();
-                        nonSerializableString += ",";
-                    }
-                    nonSerializableString += ")";
+            failSerializableClasses(nonSerializableClasses);
+        }
+
+        if (!nonSerializableFunctionFields.isEmpty()) {
+            failSerializableFields(nonSerializableFunctionFields);
+        }
+    }
+
+    private void serializeAndDeserialize(Class<?> clazz)
+            throws IOException, ClassNotFoundException, InstantiationException,
+            IllegalAccessException, IllegalArgumentException,
+            InvocationTargetException {
+        Optional<Constructor<?>> defaultCtor = Stream
+                .of(clazz.getDeclaredConstructors())
+                .filter(ctor -> ctor.getParameterCount() == 0).findFirst();
+        if (!defaultCtor.isPresent()) {
+            return;
+        }
+        defaultCtor.get().setAccessible(true);
+        Object instance = defaultCtor.get().newInstance();
+        ByteArrayOutputStream bs = new ByteArrayOutputStream();
+        ObjectOutputStream out = new ObjectOutputStream(bs);
+        out.writeObject(instance);
+        byte[] data = bs.toByteArray();
+        ObjectInputStream in = new ObjectInputStream(
+                new ByteArrayInputStream(data));
+        in.readObject();
+    }
+
+    private void failSerializableFields(
+            ArrayList<Field> nonSerializableFunctionFields) {
+        String nonSerializableString = nonSerializableFunctionFields.stream()
+                .map(field -> String.format("%s.%s",
+                        field.getDeclaringClass().getName(), field.getName()))
+                .collect(Collectors.joining(", "));
+
+        Assert.fail("Fields with functional types that are not serializable: "
+                + nonSerializableString);
+    }
+
+    private void failSerializableClasses(
+            ArrayList<Class<?>> nonSerializableClasses) {
+        String nonSerializableString = "";
+        Iterator<Class<?>> it = nonSerializableClasses.iterator();
+        while (it.hasNext()) {
+            Class<?> c = it.next();
+            nonSerializableString += ", " + c.getName();
+            if (c.isAnonymousClass()) {
+                nonSerializableString += "(super: ";
+                nonSerializableString += c.getSuperclass().getName();
+                nonSerializableString += ", interfaces: ";
+                for (Class<?> i : c.getInterfaces()) {
+                    nonSerializableString += i.getName();
+                    nonSerializableString += ",";
                 }
+                nonSerializableString += ")";
             }
-            Assert.fail(
-                    "Serializable not implemented by the following classes and interfaces: "
-                            + nonSerializableString);
         }
+        Assert.fail(
+                "Serializable not implemented by the following classes and interfaces: "
+                        + nonSerializableString);
+    }
+
+    private static boolean isFunctionalType(Type type) {
+        return type.getTypeName().contains("java.util.function");
     }
 
     private boolean isTestClass(Class<?> cls) {
      *
      * @return List of class path segment strings
      */
-    //
     private final static List<String> getRawClasspathEntries() {
         // try to keep the order of the classpath
         List<String> locations = new ArrayList<>();

server/src/test/java/com/vaadin/tests/server/component/grid/GridDefaultHeaderTest.java

 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 
-import java.util.function.Function;
-
 import org.junit.Before;
 import org.junit.Test;
 
+import com.vaadin.server.SerializableFunction;
 import com.vaadin.ui.Grid;
 import com.vaadin.ui.Grid.Column;
 import com.vaadin.ui.Grid.HeaderRow;
     public void setUp() {
         grid = new Grid<>();
 
-        column1 = grid.addColumn("First", Function.identity());
-        column2 = grid.addColumn("Second", Function.identity());
+        column1 = grid.addColumn("First", SerializableFunction.identity());
+        column2 = grid.addColumn("Second", SerializableFunction.identity());
     }
 
     @Test
     public void initialState_updateColumnCaption_defaultHeaderUpdated() {
         column1.setCaption("1st");
 
-        assertEquals("1st", grid.getDefaultHeaderRow().getCell(column1)
-                .getText());
+        assertEquals("1st",
+                grid.getDefaultHeaderRow().getCell(column1).getText());
     }
 
     @Test
         grid.setDefaultHeaderRow(grid.appendHeaderRow());
         column1.setCaption("1st");
 
-        assertEquals("1st", grid.getDefaultHeaderRow().getCell(column1)
-                .getText());
+        assertEquals("1st",
+                grid.getDefaultHeaderRow().getCell(column1).getText());
         assertEquals("First", grid.getHeaderRow(0).getCell(column1).getText());
     }
 
         grid.setDefaultHeaderRow(null);
         column1.setCaption("1st");
 
-        assertEquals("First", grid.getHeaderRow(0).getCell(column1)
-                .getText());
+        assertEquals("First", grid.getHeaderRow(0).getCell(column1).getText());
     }
 }

server/src/test/java/com/vaadin/tests/server/component/grid/GridHeaderFooterTest.java

 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.fail;
 
-import java.util.function.Function;
-
 import org.junit.Before;
 import org.junit.Test;
 
+import com.vaadin.server.SerializableFunction;
 import com.vaadin.ui.Grid;
 import com.vaadin.ui.Grid.Column;
 import com.vaadin.ui.Grid.HeaderRow;
 
     @Test
     public void addColumn_headerCellAdded() {
-        Column<?, ?> column = grid.addColumn("Col", Function.identity());
+        Column<?, ?> column = grid.addColumn("Col",
+                SerializableFunction.identity());
 
         assertNotNull(grid.getHeaderRow(0).getCell(column));
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void removeColumn_headerCellRemoved() {
-        Column<String, ?> column = grid.addColumn("Col", Function.identity());
+        Column<String, ?> column = grid.addColumn("Col",
+                SerializableFunction.identity());
         grid.removeColumn(column);
 
         grid.getHeaderRow(0).getCell(column);

server/src/test/java/com/vaadin/tests/server/component/grid/GridTest.java

 
 import static org.junit.Assert.assertEquals;
 
-import java.util.function.Function;
-
 import org.junit.Before;
 import org.junit.Test;
 
+import com.vaadin.server.SerializableFunction;
 import com.vaadin.shared.ui.grid.HeightMode;
 import com.vaadin.ui.Grid;
 import com.vaadin.ui.renderers.NumberRenderer;
     @Before
     public void setUp() {
         grid = new Grid<>();
-        grid.addColumn("foo", Function.identity());
+        grid.addColumn("foo", SerializableFunction.identity());
         grid.addColumn(String::length, new NumberRenderer());
-        grid.addColumn("randomColumnId", Function.identity());
+        grid.addColumn("randomColumnId", SerializableFunction.identity());
     }
 
     @Test

uitest/src/main/java/com/vaadin/tests/components/grid/GridApplyFilterWhenScrolledDown.java

 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.function.Function;
 
+import com.vaadin.server.SerializableFunction;
 import com.vaadin.server.VaadinRequest;
 import com.vaadin.server.data.DataSource;
 import com.vaadin.tests.components.AbstractTestUI;
     protected void setup(VaadinRequest request) {
         Grid<String> grid = new Grid<>();
 
-        grid.addColumn("Name", Function.identity());
+        grid.addColumn("Name", SerializableFunction.identity());
 
         List<String> data = new ArrayList<>();
         for (int i = 0; i < 1000; i++) {