Format all Java in WebRTC.

webrtc/examples/androidapp/src/org/appspot/apprtc/WebSocketChannelClient.java

 /*
  *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 38 matching lines @@
   private WebSocketConnectionState state;
   private final Object closeEventLock = new Object();
   private boolean closeEvent;
   // WebSocket send queue. Messages are added to the queue when WebSocket
   // client is not registered and are consumed in register() call.
   private final LinkedList<String> wsSendQueue;
 
   /**
    * Possible WebSocket connection states.
    */
-  public enum WebSocketConnectionState {
-    NEW, CONNECTED, REGISTERED, CLOSED, ERROR
-  };
+  public enum WebSocketConnectionState { NEW, CONNECTED, REGISTERED, CLOSED, ERROR }
 
   /**
    * Callback interface for messages delivered on WebSocket.
    * All events are dispatched from a looper executor thread.
    */
   public interface WebSocketChannelEvents {
     void onWebSocketMessage(final String message);
     void onWebSocketClose();
     void onWebSocketError(final String description);
   }
@@ skipping 100 matching lines @@
     checkIfCalledOnValidThread();
     Log.d(TAG, "Disconnect WebSocket. State: " + state);
     if (state == WebSocketConnectionState.REGISTERED) {
       // Send "bye" to WebSocket server.
       send("{\"type\": \"bye\"}");
       state = WebSocketConnectionState.CONNECTED;
       // Send http DELETE to http WebSocket server.
       sendWSSMessage("DELETE", "");
     }
     // Close WebSocket in CONNECTED or ERROR states only.
-    if (state == WebSocketConnectionState.CONNECTED
-        || state == WebSocketConnectionState.ERROR) {
+    if (state == WebSocketConnectionState.CONNECTED || state == WebSocketConnectionState.ERROR) {
       ws.disconnect();
       state = WebSocketConnectionState.CLOSED;
 
       // Wait for websocket close event to prevent websocket library from
       // sending any pending messages to deleted looper thread.
       if (waitForComplete) {
         synchronized (closeEventLock) {
           while (!closeEvent) {
             try {
               closeEventLock.wait(CLOSE_TIMEOUT);
@@ skipping 18 matching lines @@
           events.onWebSocketError(errorMessage);
         }
       }
     });
   }
 
   // Asynchronously send POST/DELETE to WebSocket server.
   private void sendWSSMessage(final String method, final String message) {
     String postUrl = postServerUrl + "/" + roomID + "/" + clientID;
     Log.d(TAG, "WS " + method + " : " + postUrl + " : " + message);
-    AsyncHttpURLConnection httpConnection = new AsyncHttpURLConnection(
-        method, postUrl, message, new AsyncHttpEvents() {
+    AsyncHttpURLConnection httpConnection =
+        new AsyncHttpURLConnection(method, postUrl, message, new AsyncHttpEvents() {
           @Override
           public void onHttpError(String errorMessage) {
             reportError("WS " + method + " error: " + errorMessage);
           }
 
           @Override
-          public void onHttpComplete(String response) {
-          }
+          public void onHttpComplete(String response) {}
         });
     httpConnection.send();
   }
 
   // Helper method for debugging purposes. Ensures that WebSocket method is
   // called on a looper thread.
   private void checkIfCalledOnValidThread() {
     if (Thread.currentThread() != handler.getLooper().getThread()) {
-      throw new IllegalStateException(
-          "WebSocket method is not called on valid thread");
+      throw new IllegalStateException("WebSocket method is not called on valid thread");
     }
   }
 
   private class WebSocketObserver implements WebSocketConnectionObserver {
     @Override
     public void onOpen() {
       Log.d(TAG, "WebSocket connection opened to: " + wsServerUrl);
       handler.post(new Runnable() {
         @Override
         public void run() {
           state = WebSocketConnectionState.CONNECTED;
           // Check if we have pending register request.
           if (roomID != null && clientID != null) {
             register(roomID, clientID);
           }
         }
       });
     }
 
     @Override
     public void onClose(WebSocketCloseNotification code, String reason) {
-      Log.d(TAG, "WebSocket connection closed. Code: " + code
-          + ". Reason: " + reason + ". State: " + state);
+      Log.d(TAG, "WebSocket connection closed. Code: " + code + ". Reason: " + reason + ". State: "
+              + state);
       synchronized (closeEventLock) {
         closeEvent = true;
         closeEventLock.notify();
       }
       handler.post(new Runnable() {
         @Override
         public void run() {
           if (state != WebSocketConnectionState.CLOSED) {
             state = WebSocketConnectionState.CLOSED;
             events.onWebSocketClose();
@@ skipping 11 matching lines @@
         public void run() {
           if (state == WebSocketConnectionState.CONNECTED
               || state == WebSocketConnectionState.REGISTERED) {
             events.onWebSocketMessage(message);
           }
         }
       });
     }
 
     @Override
-    public void onRawTextMessage(byte[] payload) {
-    }
+    public void onRawTextMessage(byte[] payload) {}
 
     @Override
-    public void onBinaryMessage(byte[] payload) {
-    }
+    public void onBinaryMessage(byte[] payload) {}
   }
-
 }