API refactor based on review (#11733)

ServerMessageHandler -> MessageHandler
ServerCommunicationHandler -> MessageSender
State -> ApplicationState
CommunicationProblemHandler -> ConnectionStateHandler
CommunicationProblemEvent -> XhrConnectionError

Change-Id: I2eccfea9cf6a275eba02ac605b6a172e496bd004

client/src/com/vaadin/client/ApplicationConnection.java

 import com.google.gwt.user.client.ui.HasWidgets;
 import com.google.gwt.user.client.ui.Widget;
 import com.vaadin.client.ApplicationConfiguration.ErrorMessage;
+import com.vaadin.client.ApplicationConnection.ApplicationStoppedEvent;
 import com.vaadin.client.ResourceLoader.ResourceLoadEvent;
 import com.vaadin.client.ResourceLoader.ResourceLoadListener;
-import com.vaadin.client.communication.CommunicationProblemHandler;
+import com.vaadin.client.communication.ConnectionStateHandler;
+import com.vaadin.client.communication.DefaultConnectionStateHandler;
 import com.vaadin.client.communication.Heartbeat;
-import com.vaadin.client.communication.ReconnectingCommunicationProblemHandler;
+import com.vaadin.client.communication.MessageHandler;
+import com.vaadin.client.communication.MessageSender;
 import com.vaadin.client.communication.RpcManager;
-import com.vaadin.client.communication.ServerCommunicationHandler;
-import com.vaadin.client.communication.ServerMessageHandler;
 import com.vaadin.client.communication.ServerRpcQueue;
 import com.vaadin.client.componentlocator.ComponentLocator;
 import com.vaadin.client.metadata.ConnectorBundleLoader;
     /** Event bus for communication events */
     private EventBus eventBus = GWT.create(SimpleEventBus.class);
 
-    public enum State {
+    public enum ApplicationState {
         INITIALIZING, RUNNING, TERMINATED;
     }
 
-    private State state = State.INITIALIZING;
+    private ApplicationState applicationState = ApplicationState.INITIALIZING;
 
     /**
      * The communication handler methods are called at certain points during
         loadingIndicator.setConnection(this);
         serverRpcQueue = GWT.create(ServerRpcQueue.class);
         serverRpcQueue.setConnection(this);
-        communicationProblemHandler = GWT
-                .create(ReconnectingCommunicationProblemHandler.class);
-        communicationProblemHandler.setConnection(this);
-        serverMessageHandler = GWT.create(ServerMessageHandler.class);
-        serverMessageHandler.setConnection(this);
-        serverCommunicationHandler = GWT
-                .create(ServerCommunicationHandler.class);
-        serverCommunicationHandler.setConnection(this);
+        connectionStateHandler = GWT
+                .create(DefaultConnectionStateHandler.class);
+        connectionStateHandler.setConnection(this);
+        messageHandler = GWT.create(MessageHandler.class);
+        messageHandler.setConnection(this);
+        messageSender = GWT.create(MessageSender.class);
+        messageSender.setConnection(this);
     }
 
     public void init(WidgetSet widgetSet, ApplicationConfiguration cnf) {
         String jsonText = configuration.getUIDL();
         if (jsonText == null) {
             // initial UIDL not in DOM, request from server
-            getServerCommunicationHandler().resynchronize();
+            getMessageSender().resynchronize();
         } else {
             // initial UIDL provided in DOM, continue as if returned by request
 
             // Hack to avoid logging an error in endRequest()
-            getServerCommunicationHandler().startRequest();
-            getServerMessageHandler().handleMessage(
-                    ServerMessageHandler.parseJson(jsonText));
+            getMessageSender().startRequest();
+            getMessageHandler().handleMessage(
+                    MessageHandler.parseJson(jsonText));
         }
 
         // Tooltip can't be created earlier because the
      * @return true if the client has some work to be done, false otherwise
      */
     private boolean isActive() {
-        return !getServerMessageHandler().isInitialUidlHandled()
-                || isWorkPending()
-                || getServerCommunicationHandler().hasActiveRequest()
+        return !getMessageHandler().isInitialUidlHandled() || isWorkPending()
+                || getMessageSender().hasActiveRequest()
                 || isExecutingDeferredCommands();
     }
 
         }
 
         client.getProfilingData = $entry(function() {
-            var smh = ap.@com.vaadin.client.ApplicationConnection::getServerMessageHandler();
+            var smh = ap.@com.vaadin.client.ApplicationConnection::getMessageHandler();
             var pd = [
-                smh.@com.vaadin.client.communication.ServerMessageHandler::lastProcessingTime,
-                    smh.@com.vaadin.client.communication.ServerMessageHandler::totalProcessingTime
+                smh.@com.vaadin.client.communication.MessageHandler::lastProcessingTime,
+                    smh.@com.vaadin.client.communication.MessageHandler::totalProcessingTime
                 ];
-            pd = pd.concat(smh.@com.vaadin.client.communication.ServerMessageHandler::serverTimingInfo);
-            pd[pd.length] = smh.@com.vaadin.client.communication.ServerMessageHandler::bootstrapTime;
+            pd = pd.concat(smh.@com.vaadin.client.communication.MessageHandler::serverTimingInfo);
+            pd[pd.length] = smh.@com.vaadin.client.communication.MessageHandler::bootstrapTime;
             return pd;
         });
 
     int cssWaits = 0;
 
     protected ServerRpcQueue serverRpcQueue;
-    protected CommunicationProblemHandler communicationProblemHandler;
-    protected ServerMessageHandler serverMessageHandler;
-    protected ServerCommunicationHandler serverCommunicationHandler;
+    protected ConnectionStateHandler connectionStateHandler;
+    protected MessageHandler messageHandler;
+    protected MessageSender messageSender;
 
     static final int MAX_CSS_WAITS = 100;
 
     }
 
     public void setApplicationRunning(boolean applicationRunning) {
-        if (getState() == State.TERMINATED) {
+        if (getApplicationState() == ApplicationState.TERMINATED) {
             if (applicationRunning) {
                 getLogger()
                         .severe("Tried to restart a terminated application. This is not supported");
                                 "Tried to stop a terminated application. This should not be done");
             }
             return;
-        } else if (getState() == State.INITIALIZING) {
+        } else if (getApplicationState() == ApplicationState.INITIALIZING) {
             if (applicationRunning) {
-                state = State.RUNNING;
+                applicationState = ApplicationState.RUNNING;
             } else {
                 getLogger()
                         .warning(
                                 "Tried to stop the application before it has started. This should not be done");
             }
-        } else if (getState() == State.RUNNING) {
+        } else if (getApplicationState() == ApplicationState.RUNNING) {
             if (!applicationRunning) {
-                state = State.TERMINATED;
+                applicationState = ApplicationState.TERMINATED;
                 eventBus.fireEvent(new ApplicationStoppedEvent());
             } else {
                 getLogger()
     }
 
     /**
-     * Checks if the application is in the {@link State#RUNNING} state.
+     * Checks if the application is in the {@link ApplicationState#RUNNING}
+     * state.
      * 
      * @since
      * @return true if the application is in the running state, false otherwise
      */
     public boolean isApplicationRunning() {
-        return state == State.RUNNING;
+        return applicationState == ApplicationState.RUNNING;
     }
 
     public <H extends EventHandler> HandlerRegistration addHandler(
      * application to go back to a previous state, i.e. a stopped application
      * can never be re-started
      * 
-     * @since
+     * @since 7.6
      * @return the current state of this application
      */
-    public State getState() {
-        return state;
+    public ApplicationState getApplicationState() {
+        return applicationState;
     }
 
     /**
      * 
      * @return the server RPC queue
      */
-    public CommunicationProblemHandler getCommunicationProblemHandler() {
-        return communicationProblemHandler;
+    public ConnectionStateHandler getConnectionStateHandler() {
+        return connectionStateHandler;
     }
 
     /**
-     * Gets the server message handler for this application
+     * Gets the (server to client) message handler for this application
      * 
-     * @return the server message handler
+     * @return the message handler
      */
-    public ServerMessageHandler getServerMessageHandler() {
-        return serverMessageHandler;
+    public MessageHandler getMessageHandler() {
+        return messageHandler;
     }
 
     /**
     }
 
     /**
-     * Gets the server communication handler for this application
+     * Gets the (client to server) message sender for this application
      * 
-     * @return the server communication handler
+     * @return the message sender
      */
-    public ServerCommunicationHandler getServerCommunicationHandler() {
-        return serverCommunicationHandler;
+    public MessageSender getMessageSender() {
+        return messageSender;
     }
 
     /**
     }
 
     public int getLastSeenServerSyncId() {
-        return getServerMessageHandler().getLastSeenServerSyncId();
+        return getMessageHandler().getLastSeenServerSyncId();
     }
 
 }

client/src/com/vaadin/client/LayoutManager.java

     };
     private boolean everythingNeedsMeasure = false;
 
+    /**
+     * Sets the application connection this instance is connected to. Called
+     * internally by the framework.
+     *
+     * @param connection
+     *            the application connection this instance is connected to
+     */
     public void setConnection(ApplicationConnection connection) {
         if (this.connection != null) {
             throw new RuntimeException(
                     "Can't start a new layout phase before the previous layout phase ends.");
         }
 
-        if (connection.getServerMessageHandler().isUpdatingState()) {
+        if (connection.getMessageHandler().isUpdatingState()) {
             // If assertions are enabled, throw an exception
             assert false : STATE_CHANGE_MESSAGE;
 

client/src/com/vaadin/client/communication/AtmospherePushConnection.java

         String extraParams = UIConstants.UI_ID_PARAMETER + "="
                 + connection.getConfiguration().getUIId();
 
-        String csrfToken = connection.getServerMessageHandler().getCsrfToken();
+        String csrfToken = connection.getMessageHandler().getCsrfToken();
         if (!csrfToken.equals(ApplicationConstants.CSRF_TOKEN_DEFAULT_VALUE)) {
             extraParams += "&" + ApplicationConstants.CSRF_TOKEN_PARAMETER
                     + "=" + csrfToken;
         }
 
         if (state == State.CONNECT_PENDING) {
-            getCommunicationProblemHandler().pushNotConnected(message);
+            getConnectionStateHandler().pushNotConnected(message);
             return;
         }
 
         switch (state) {
         case CONNECT_PENDING:
             state = State.CONNECTED;
-            getCommunicationProblemHandler().pushOk(this);
+            getConnectionStateHandler().pushOk(this);
             break;
         case DISCONNECT_PENDING:
             // Set state to connected to make disconnect close the connection
 
     protected void onMessage(AtmosphereResponse response) {
         String message = response.getResponseBody();
-        ValueMap json = ServerMessageHandler.parseWrappedJson(message);
+        ValueMap json = MessageHandler.parseWrappedJson(message);
         if (json == null) {
             // Invalid string (not wrapped as expected)
-            getCommunicationProblemHandler().pushInvalidContent(this, message);
+            getConnectionStateHandler().pushInvalidContent(this, message);
             return;
         } else {
             getLogger().info(
                     "Received push (" + getTransportType() + ") message: "
                             + message);
-            connection.getServerMessageHandler().handleMessage(json);
+            connection.getMessageHandler().handleMessage(json);
         }
     }
 
      */
     protected void onError(AtmosphereResponse response) {
         state = State.DISCONNECTED;
-        getCommunicationProblemHandler().pushError(this);
+        getConnectionStateHandler().pushError(this);
     }
 
     protected void onClose(AtmosphereResponse response) {
         state = State.CONNECT_PENDING;
-        getCommunicationProblemHandler().pushClosed(this);
+        getConnectionStateHandler().pushClosed(this);
     }
 
     protected void onClientTimeout(AtmosphereResponse response) {
         state = State.DISCONNECTED;
-        getCommunicationProblemHandler().pushClientTimeout(this);
+        getConnectionStateHandler().pushClientTimeout(this);
     }
 
     protected void onReconnect(JavaScriptObject request,
         if (state == State.CONNECTED) {
             state = State.CONNECT_PENDING;
         }
-        getCommunicationProblemHandler().pushReconnectPending(this);
+        getConnectionStateHandler().pushReconnectPending(this);
     }
 
     public static abstract class AbstractJSO extends JavaScriptObject {
 
                         @Override
                         public void onError(ResourceLoadEvent event) {
-                            getCommunicationProblemHandler()
+                            getConnectionStateHandler()
                                     .pushScriptLoadError(event.getResourceUrl());
                         }
                     });
         return Logger.getLogger(AtmospherePushConnection.class.getName());
     }
 
-    private CommunicationProblemHandler getCommunicationProblemHandler() {
-        return connection.getCommunicationProblemHandler();
+    private ConnectionStateHandler getConnectionStateHandler() {
+        return connection.getConnectionStateHandler();
     }
 
 }

client/src/com/vaadin/client/communication/CommunicationProblemHandler.java → client/src/com/vaadin/client/communication/ConnectionStateHandler.java

 import elemental.json.JsonObject;
 
 /**
- * Interface for handling problems which occur during communication with the
- * server.
+ * Interface for handling problems and other events which occur during
+ * communication with the server.
  * 
  * The handler is responsible for handling any problem in XHR, heartbeat and
  * push connections in a way it sees fit. The default implementation is
- * {@link ReconnectingCommunicationProblemHandler}.
+ * {@link DefaultConnectionStateHandler}.
  * 
  * @since 7.6
  * @author Vaadin Ltd
  */
-public interface CommunicationProblemHandler {
+public interface ConnectionStateHandler {
 
     /**
-     * Sets the application connection this handler is connected to. Called
+     * Sets the application connection this instance is connected to. Called
      * internally by the framework.
      *
      * @param connection
-     *            the application connection this handler is connected to
+     *            the application connection this instance is connected to
      */
     void setConnection(ApplicationConnection connection);
 
      * Called when an exception occurs during an XmlHttpRequest request to the
      * server.
      * 
-     * @param communicationProblemEvent
+     * @param xhrConnectionError
      *            An event containing what was being sent to the server and what
      *            exception occurred
      */
-    void xhrException(CommunicationProblemEvent communicationProblemEvent);
+    void xhrException(XhrConnectionError xhrConnectionError);
 
     /**
      * Called when invalid content (not JSON) was returned from the server as
      *            An event containing what was being sent to the server and what
      *            was returned
      */
-    void xhrInvalidContent(CommunicationProblemEvent communicationProblemEvent);
+    void xhrInvalidContent(XhrConnectionError xhrConnectionError);
 
     /**
      * Called when invalid status code (not 200) was returned by the server as
      *            An event containing what was being sent to the server and what
      *            was returned
      */
-    void xhrInvalidStatusCode(CommunicationProblemEvent problemEvent);
+    void xhrInvalidStatusCode(XhrConnectionError xhrConnectionError);
 
     /**
      * Called whenever a XmlHttpRequest to the server completes successfully

client/src/com/vaadin/client/communication/ReconnectingCommunicationProblemHandler.java → client/src/com/vaadin/client/communication/DefaultConnectionStateHandler.java

 import elemental.json.JsonObject;
 
 /**
- * Default implementation of the communication problem handler.
+ * Default implementation of the connection state handler.
  * <p>
  * Handles temporary errors by showing a reconnect dialog to the user while
  * trying to re-establish the connection to the server and re-send the pending
  * @since 7.6
  * @author Vaadin Ltd
  */
-public class ReconnectingCommunicationProblemHandler implements
-        CommunicationProblemHandler {
+public class DefaultConnectionStateHandler implements ConnectionStateHandler {
 
     private ApplicationConnection connection;
     private ReconnectDialog reconnectDialog = GWT.create(ReconnectDialog.class);
     }
 
     private static Logger getLogger() {
-        return Logger.getLogger(ReconnectingCommunicationProblemHandler.class
-                .getName());
+        return Logger.getLogger(DefaultConnectionStateHandler.class.getName());
     }
 
     /**
     }
 
     @Override
-    public void xhrException(CommunicationProblemEvent event) {
+    public void xhrException(XhrConnectionError xhrConnectionError) {
         debug("xhrException");
-        handleRecoverableError(Type.XHR, event.getPayload());
+        handleRecoverableError(Type.XHR, xhrConnectionError.getPayload());
     }
 
     @Override
         }
         if (payload != null) {
             getLogger().info("Re-sending last message to the server...");
-            getConnection().getServerCommunicationHandler().send(payload);
+            getConnection().getMessageSender().send(payload);
         } else {
             // Use heartbeat
             getLogger().info("Trying to re-establish server connection...");
     }
 
     @Override
-    public void xhrInvalidContent(CommunicationProblemEvent event) {
+    public void xhrInvalidContent(XhrConnectionError xhrConnectionError) {
         debug("xhrInvalidContent");
         endRequest();
 
-        String responseText = event.getResponse().getText();
+        String responseText = xhrConnectionError.getResponse().getText();
         /*
          * A servlet filter or equivalent may have intercepted the request and
          * served non-UIDL content (for instance, a login page if the session
             WidgetUtil.redirect(refreshToken.getGroup(2));
         } else {
             handleUnrecoverableCommunicationError(
-                    "Invalid JSON response from server: " + responseText, event);
+                    "Invalid JSON response from server: " + responseText,
+                    xhrConnectionError);
         }
 
     }
     }
 
     @Override
-    public void xhrInvalidStatusCode(CommunicationProblemEvent event) {
+    public void xhrInvalidStatusCode(XhrConnectionError xhrConnectionError) {
         debug("xhrInvalidStatusCode");
 
-        Response response = event.getResponse();
+        Response response = xhrConnectionError.getResponse();
         int statusCode = response.getStatusCode();
         getLogger().warning("Server returned " + statusCode + " for xhr");
 
         if (statusCode == 401) {
             // Authentication/authorization failed, no need to re-try
             endRequest();
-            handleUnauthorized(event);
+            handleUnauthorized(xhrConnectionError);
             return;
         } else {
             // 404, 408 and other 4xx codes CAN be temporary when you have a
             // proxy between the client and the server and e.g. restart the
             // server
             // 5xx codes may or may not be temporary
-            handleRecoverableError(Type.XHR, event.getPayload());
+            handleRecoverableError(Type.XHR, xhrConnectionError.getPayload());
         }
     }
 
      * @since
      */
     private void endRequest() {
-        getConnection().getServerCommunicationHandler().endRequest();
+        getConnection().getMessageSender().endRequest();
     }
 
-    protected void handleUnauthorized(CommunicationProblemEvent event) {
+    protected void handleUnauthorized(XhrConnectionError xhrConnectionError) {
         /*
          * Authorization has failed (401). Could be that the session has timed
          * out.
     }
 
     private void handleUnrecoverableCommunicationError(String details,
-            CommunicationProblemEvent event) {
+            XhrConnectionError xhrConnectionError) {
         int statusCode = -1;
-        if (event != null) {
-            Response response = event.getResponse();
+        if (xhrConnectionError != null) {
+            Response response = xhrConnectionError.getResponse();
             if (response != null) {
                 statusCode = response.getStatusCode();
             }

client/src/com/vaadin/client/communication/Heartbeat.java

                 int status = response.getStatusCode();
 
                 if (status == Response.SC_OK) {
-                    connection.getCommunicationProblemHandler().heartbeatOk();
+                    connection.getConnectionStateHandler().heartbeatOk();
                 } else {
                     // Handler should stop the application if heartbeat should
                     // no longer be sent
-                    connection.getCommunicationProblemHandler()
+                    connection.getConnectionStateHandler()
                             .heartbeatInvalidStatusCode(request, response);
                 }
 
             public void onError(Request request, Throwable exception) {
                 // Handler should stop the application if heartbeat should no
                 // longer be sent
-                connection.getCommunicationProblemHandler().heartbeatException(
+                connection.getConnectionStateHandler().heartbeatException(
                         request, exception);
                 schedule();
             }

client/src/com/vaadin/client/communication/ServerMessageHandler.java → client/src/com/vaadin/client/communication/MessageHandler.java

 import com.google.gwt.user.client.ui.Widget;
 import com.vaadin.client.ApplicationConfiguration;
 import com.vaadin.client.ApplicationConnection;
+import com.vaadin.client.ApplicationConnection.ApplicationState;
 import com.vaadin.client.ApplicationConnection.MultiStepDuration;
 import com.vaadin.client.ApplicationConnection.ResponseHandlingStartedEvent;
-import com.vaadin.client.ApplicationConnection.State;
 import com.vaadin.client.ComponentConnector;
 import com.vaadin.client.ConnectorHierarchyChangeEvent;
 import com.vaadin.client.ConnectorMap;
 import elemental.json.JsonObject;
 
 /**
- * ServerMessageHandler is responsible for handling all incoming messages (JSON)
+ * A MessageHandler is responsible for handling all incoming messages (JSON)
  * from the server (state changes, RPCs and other updates) and ensuring that the
  * connectors are updated accordingly.
  * 
  * @since 7.6
  * @author Vaadin Ltd
  */
-public class ServerMessageHandler {
+public class MessageHandler {
 
     public static final String JSON_COMMUNICATION_PREFIX = "for(;;);[";
     public static final String JSON_COMMUNICATION_SUFFIX = "]";
     }
 
     /**
-     * Sets the application connection this queue is connected to
+     * Sets the application connection this instance is connected to. Called
+     * internally by the framework.
      *
      * @param connection
-     *            the application connection this queue is connected to
+     *            the application connection this instance is connected to
      */
     public void setConnection(ApplicationConnection connection) {
         this.connection = connection;
     }
 
     private static Logger getLogger() {
-        return Logger.getLogger(ServerMessageHandler.class.getName());
+        return Logger.getLogger(MessageHandler.class.getName());
     }
 
     /**
                             + "Please verify that the server is up-to-date and that the response data has not been modified in transmission.");
         }
 
-        if (connection.getState() == State.RUNNING) {
+        if (connection.getApplicationState() == ApplicationState.RUNNING) {
             handleJSON(json);
-        } else if (connection.getState() == State.INITIALIZING) {
+        } else if (connection.getApplicationState() == ApplicationState.INITIALIZING) {
             // Application is starting up for the first time
             connection.setApplicationRunning(true);
             connection.executeWhenCSSLoaded(new Command() {
         if (json.containsKey(ApplicationConstants.CLIENT_TO_SERVER_ID)) {
             int serverNextExpected = json
                     .getInt(ApplicationConstants.CLIENT_TO_SERVER_ID);
-            getServerCommunicationHandler().setClientToServerMessageId(
-                    serverNextExpected, isResynchronize(json));
+            getMessageSender().setClientToServerMessageId(serverNextExpected,
+                    isResynchronize(json));
         }
 
         if (serverId != -1) {
         if (isResponse(json)) {
             // End the request if the received message was a
             // response, not sent asynchronously
-            getServerCommunicationHandler().endRequest();
+            getMessageSender().endRequest();
         }
     }
 
                 // has been lost
                 // Drop pending messages and resynchronize
                 pendingUIDLMessages.clear();
-                getServerCommunicationHandler().resynchronize();
+                getMessageSender().resynchronize();
             }
         }
     };
         return connection.getRpcManager();
     }
 
-    private ServerCommunicationHandler getServerCommunicationHandler() {
-        return connection.getServerCommunicationHandler();
+    private MessageSender getMessageSender() {
+        return connection.getMessageSender();
     }
 
     /**

client/src/com/vaadin/client/communication/ServerCommunicationHandler.java → client/src/com/vaadin/client/communication/MessageSender.java

 import elemental.json.JsonObject;
 
 /**
- * ServerCommunicationHandler is responsible for sending messages to the server.
- * 
- * Internally either XHR or push is used for communicating, depending on the
- * application configuration.
+ * MessageSender is responsible for sending messages to the server.
+ * <p>
+ * Internally uses {@link XhrConnection} and/or {@link PushConnection} for
+ * delivering messages, depending on the application configuration.
  * 
  * @since 7.6
  * @author Vaadin Ltd
  */
-public class ServerCommunicationHandler {
+public class MessageSender {
 
     private ApplicationConnection connection;
     private boolean hasActiveRequest = false;
     private XhrConnection xhrConnection;
     private PushConnection push;
 
-    public ServerCommunicationHandler() {
+    public MessageSender() {
         xhrConnection = GWT.create(XhrConnection.class);
     }
 
     /**
-     * Sets the application connection this handler is connected to
+     * Sets the application connection this instance is connected to. Called
+     * internally by the framework.
      *
      * @param connection
-     *            the application connection this handler is connected to
+     *            the application connection this instance is connected to
      */
     public void setConnection(ApplicationConnection connection) {
         this.connection = connection;
     }
 
     private static Logger getLogger() {
-        return Logger.getLogger(ServerCommunicationHandler.class.getName());
+        return Logger.getLogger(MessageSender.class.getName());
     }
 
     public void sendInvocationsToServer() {
         startRequest();
 
         JsonObject payload = Json.createObject();
-        String csrfToken = getServerMessageHandler().getCsrfToken();
+        String csrfToken = getMessageHandler().getCsrfToken();
         if (!csrfToken.equals(ApplicationConstants.CSRF_TOKEN_DEFAULT_VALUE)) {
             payload.put(ApplicationConstants.CSRF_TOKEN, csrfToken);
         }
         payload.put(ApplicationConstants.RPC_INVOCATIONS, reqInvocations);
-        payload.put(ApplicationConstants.SERVER_SYNC_ID,
-                getServerMessageHandler().getLastSeenServerSyncId());
+        payload.put(ApplicationConstants.SERVER_SYNC_ID, getMessageHandler()
+                .getLastSeenServerSyncId());
         payload.put(ApplicationConstants.CLIENT_TO_SERVER_ID,
                 clientToServerMessageId++);
 
                 + "server to client: " + serverToClient;
     }
 
-    private CommunicationProblemHandler getCommunicationProblemHandler() {
-        return connection.getCommunicationProblemHandler();
+    private ConnectionStateHandler getConnectionStateHandler() {
+        return connection.getConnectionStateHandler();
     }
 
-    private ServerMessageHandler getServerMessageHandler() {
-        return connection.getServerMessageHandler();
+    private MessageHandler getMessageHandler() {
+        return connection.getMessageHandler();
     }
 
     private VLoadingIndicator getLoadingIndicator() {

client/src/com/vaadin/client/communication/PushConnection.java

      * <p>
      * Implementation detail: If the push connection is not connected and the
      * message can thus not be sent, the implementation must call
-     * {@link CommunicationProblemHandler#pushNotConnected(JsonObject)}, which
+     * {@link ConnectionStateHandler#pushNotConnected(JsonObject)}, which
      * will retry the send later.
      * <p>
      * This method must not be called if the push connection is not

client/src/com/vaadin/client/communication/ServerRpcQueue.java

     }
 
     /**
-     * Sets the application connection this queue is connected to
+     * Sets the application connection this instance is connected to. Called
+     * internally by the framework.
      *
      * @param connection
-     *            the application connection this queue is connected to
+     *            the application connection this instance is connected to
      */
     public void setConnection(ApplicationConnection connection) {
         this.connection = connection;
                 // Somebody else cleared the queue before we had the chance
                 return;
             }
-            connection.getServerCommunicationHandler()
-                    .sendInvocationsToServer();
+            connection.getMessageSender().sendInvocationsToServer();
         }
     };
 

client/src/com/vaadin/client/communication/TranslatedURLReference.java

     private ApplicationConnection connection;
 
     /**
+     * Sets the application connection this instance is connected to. Called
+     * internally by the framework.
+     *
      * @param connection
-     *            the connection to set
+     *            the application connection this instance is connected to
      */
     public void setConnection(ApplicationConnection connection) {
         this.connection = connection;

client/src/com/vaadin/client/communication/XhrConnection.java

     }
 
     /**
-     * Sets the application connection this queue is connected to
+     * Sets the application connection this instance is connected to. Called
+     * internally by the framework.
      *
      * @param connection
-     *            the application connection this queue is connected to
+     *            the application connection this instance is connected to
      */
     public void setConnection(ApplicationConnection connection) {
         this.connection = connection;
 
         @Override
         public void onError(Request request, Throwable exception) {
-            getCommunicationProblemHandler().xhrException(
-                    new CommunicationProblemEvent(request, payload, exception));
-        }
-
-        private ServerCommunicationHandler getServerCommunicationHandler() {
-            return connection.getServerCommunicationHandler();
+            getConnectionStateHandler().xhrException(
+                    new XhrConnectionError(request, payload, exception));
         }
 
         @Override
 
             if (statusCode != 200) {
                 // There was a problem
-                CommunicationProblemEvent problemEvent = new CommunicationProblemEvent(
+                XhrConnectionError problemEvent = new XhrConnectionError(
                         request, payload, response);
 
-                getCommunicationProblemHandler().xhrInvalidStatusCode(
-                        problemEvent);
+                getConnectionStateHandler().xhrInvalidStatusCode(problemEvent);
                 return;
             }
 
             String contentType = response.getHeader("Content-Type");
             if (contentType == null
                     || !contentType.startsWith("application/json")) {
-                getCommunicationProblemHandler().xhrInvalidContent(
-                        new CommunicationProblemEvent(request, payload,
-                                response));
+                getConnectionStateHandler().xhrInvalidContent(
+                        new XhrConnectionError(request, payload, response));
                 return;
             }
 
             // for(;;);["+ realJson +"]"
             String responseText = response.getText();
 
-            ValueMap json = ServerMessageHandler.parseWrappedJson(responseText);
+            ValueMap json = MessageHandler.parseWrappedJson(responseText);
             if (json == null) {
                 // Invalid string (not wrapped as expected or can't parse)
-                getCommunicationProblemHandler().xhrInvalidContent(
-                        new CommunicationProblemEvent(request, payload,
-                                response));
+                getConnectionStateHandler().xhrInvalidContent(
+                        new XhrConnectionError(request, payload, response));
                 return;
             }
 
-            getCommunicationProblemHandler().xhrOk();
+            getConnectionStateHandler().xhrOk();
             getLogger().info("Received xhr message: " + responseText);
-            getServerMessageHandler().handleMessage(json);
+            getMessageHandler().handleMessage(json);
         }
 
         /**
                 }.schedule(retryTimeout);
             }
         } catch (RequestException e) {
-            getCommunicationProblemHandler().xhrException(
-                    new CommunicationProblemEvent(null, payload, e));
+            getConnectionStateHandler().xhrException(
+                    new XhrConnectionError(null, payload, e));
         }
     }
 
 
     }
 
-    private CommunicationProblemHandler getCommunicationProblemHandler() {
-        return connection.getCommunicationProblemHandler();
+    private ConnectionStateHandler getConnectionStateHandler() {
+        return connection.getConnectionStateHandler();
     }
 
-    private ServerMessageHandler getServerMessageHandler() {
-        return connection.getServerMessageHandler();
+    private MessageHandler getMessageHandler() {
+        return connection.getMessageHandler();
     }
 
     private static native boolean resendRequest(Request request)

client/src/com/vaadin/client/communication/CommunicationProblemEvent.java → client/src/com/vaadin/client/communication/XhrConnectionError.java

 import elemental.json.JsonObject;
 
 /**
- * Event describing a problem which took place during communication with the
- * server
+ * XhrConnectionError provides detail about an error which occured during an XHR
+ * request to the server
  * 
  * @since 7.6
  * @author Vaadin Ltd
  */
-public class CommunicationProblemEvent {
+public class XhrConnectionError {
 
     private Throwable exception;
     private Request request;
      * @param exception
      *            the exception describing the problem
      */
-    public CommunicationProblemEvent(Request request, JsonObject payload,
+    public XhrConnectionError(Request request, JsonObject payload,
             Throwable exception) {
         this.request = request;
         this.exception = exception;
      * @param response
      *            the response for the request
      */
-    public CommunicationProblemEvent(Request request, JsonObject payload,
+    public XhrConnectionError(Request request, JsonObject payload,
             Response response) {
         this.request = request;
         this.response = response;

client/src/com/vaadin/client/debug/internal/InfoSection.java

         addRow("Theme", connection.getUIConnector().getActiveTheme());
 
         String communicationMethodInfo = connection
-                .getServerCommunicationHandler().getCommunicationMethodName();
+                .getMessageSender().getCommunicationMethodName();
         int pollInterval = connection.getUIConnector().getState().pollInterval;
         if (pollInterval > 0) {
             communicationMethodInfo += " (poll interval " + pollInterval

client/src/com/vaadin/client/ui/VScrollTable.java

         @Override
         public void run() {
 
-            if (client.getServerCommunicationHandler().hasActiveRequest()
+            if (client.getMessageSender().hasActiveRequest()
                     || navKeyDown) {
                 // if client connection is busy, don't bother loading it more
                 VConsole.log("Postponed rowfetch");

client/src/com/vaadin/client/ui/dd/VDragAndDropManager.java

                     Scheduler.get().scheduleFixedDelay(new RepeatingCommand() {
                         @Override
                         public boolean execute() {
-                            if (!client.getServerCommunicationHandler()
+                            if (!client.getMessageSender()
                                     .hasActiveRequest()) {
                                 removeActiveDragSourceStyleName(dragSource);
                                 return false;

client/src/com/vaadin/client/ui/ui/UIConnector.java

         }
 
         if (stateChangeEvent.hasPropertyChanged("pushConfiguration")) {
-            getConnection().getServerCommunicationHandler().setPushEnabled(
+            getConnection().getMessageSender().setPushEnabled(
                     getState().pushConfiguration.mode.isEnabled());
         }
         if (stateChangeEvent.hasPropertyChanged("reconnectDialogConfiguration")) {
-            getConnection().getCommunicationProblemHandler()
+            getConnection().getConnectionStateHandler()
                     .configurationUpdated();
         }
 

client/tests/src/com/vaadin/client/communication/ServerMessageHandlerTest.java

     @Test
     public void unwrapValidJson() {
         String payload = "{'foo': 'bar'}";
-        Assert.assertEquals(
-                payload,
-                ServerMessageHandler.stripJSONWrapping("for(;;);[" + payload
-                        + "]"));
+        Assert.assertEquals(payload,
+                MessageHandler.stripJSONWrapping("for(;;);[" + payload + "]"));
 
     }
 
     @Test
     public void unwrapUnwrappedJson() {
         String payload = "{'foo': 'bar'}";
-        Assert.assertNull(ServerMessageHandler.stripJSONWrapping(payload));
+        Assert.assertNull(MessageHandler.stripJSONWrapping(payload));
 
     }
 
     @Test
     public void unwrapNull() {
-        Assert.assertNull(ServerMessageHandler.stripJSONWrapping(null));
+        Assert.assertNull(MessageHandler.stripJSONWrapping(null));
 
     }
 
     @Test
     public void unwrapEmpty() {
-        Assert.assertNull(ServerMessageHandler.stripJSONWrapping(""));
+        Assert.assertNull(MessageHandler.stripJSONWrapping(""));
 
     }
 }

uitest/src/com/vaadin/tests/widgetset/client/MockApplicationConnection.java

 
     public MockApplicationConnection() {
         super();
-        serverMessageHandler = new MockServerMessageHandler();
-        serverMessageHandler.setConnection(this);
-        serverCommunicationHandler = new MockServerCommunicationHandler();
-        serverCommunicationHandler.setConnection(this);
+        messageHandler = new MockServerMessageHandler();
+        messageHandler.setConnection(this);
+        messageSender = new MockServerCommunicationHandler();
+        messageSender.setConnection(this);
     }
 
     @Override
-    public MockServerMessageHandler getServerMessageHandler() {
-        return (MockServerMessageHandler) super.getServerMessageHandler();
+    public MockServerMessageHandler getMessageHandler() {
+        return (MockServerMessageHandler) super.getMessageHandler();
     }
 
     @Override
-    public MockServerCommunicationHandler getServerCommunicationHandler() {
+    public MockServerCommunicationHandler getMessageSender() {
         return (MockServerCommunicationHandler) super
-                .getServerCommunicationHandler();
+                .getMessageSender();
     }
 
     /**
      * @see CsrfTokenDisabled
      */
     public String getLastCsrfTokenReceiver() {
-        return getServerMessageHandler().lastCsrfTokenReceiver;
+        return getMessageHandler().lastCsrfTokenReceiver;
     }
 
     /**
      * @see CsrfTokenDisabled
      */
     public String getLastCsrfTokenSent() {
-        return getServerCommunicationHandler().lastCsrfTokenSent;
+        return getMessageSender().lastCsrfTokenSent;
     }
 
 }

uitest/src/com/vaadin/tests/widgetset/client/MockServerCommunicationHandler.java

  */
 package com.vaadin.tests.widgetset.client;
 
-import com.vaadin.client.communication.ServerCommunicationHandler;
+import com.vaadin.client.communication.MessageSender;
 import com.vaadin.shared.ApplicationConstants;
 
 import elemental.json.JsonObject;
 import elemental.json.JsonValue;
 
-public class MockServerCommunicationHandler extends ServerCommunicationHandler {
+public class MockServerCommunicationHandler extends MessageSender {
 
     // The last token sent to the server.
     String lastCsrfTokenSent;

uitest/src/com/vaadin/tests/widgetset/client/MockServerMessageHandler.java

 package com.vaadin.tests.widgetset.client;
 
 import com.vaadin.client.ValueMap;
-import com.vaadin.client.communication.ServerMessageHandler;
+import com.vaadin.client.communication.MessageHandler;
 import com.vaadin.shared.ApplicationConstants;
 
-public class MockServerMessageHandler extends ServerMessageHandler {
+public class MockServerMessageHandler extends MessageHandler {
 
     // The last token received from the server.
     protected String lastCsrfTokenReceiver;

uitest/src/com/vaadin/tests/widgetset/client/csrf/CsrfButtonConnector.java

     }
 
     private String csrfTokenInfo() {
-        return getMockConnection().getServerMessageHandler().getCsrfToken()
+        return getMockConnection().getMessageHandler().getCsrfToken()
                 + ", " + getMockConnection().getLastCsrfTokenReceiver() + ", "
                 + getMockConnection().getLastCsrfTokenSent();
     }