Format all Java files with google-java-format

Having a standard tool for formatting saves reviewers' valuable time.
google-java-format is Google's standard formatter and is somewhat
inspired by gofmt[1]. This commit formats everything using
google-java-format version 1.2.

The downside of this one-off formatting is breaking blame. This can be
somewhat hacked around with a tool like git-hyper-blame[2], but it's
definitely not optimal until/unless this kind of feature makes its way
to git core.

Not in this change:
* Tool support, e.g. Eclipse. The command must be run manually [3].
* Documentation of best practice, e.g. new 100-column default.

[1] https://talks.golang.org/2015/gofmt-en.slide#3
[2] https://commondatastorage.googleapis.com/chrome-infra-docs/flat/depot_tools/docs/html/git-hyper-blame.html
[3] git ls-files | grep java$ | xargs google-java-format -i

Change-Id: Id5f3c6de95ce0b68b41f0a478b5c99a93675aaa3
Signed-off-by: David Pursehouse <dpursehouse@collab.net>

gerrit-lucene/src/main/java/com/google/gerrit/lucene/LuceneVersionManager.java

@@ -32,12 +32,6 @@ import com.google.gerrit.server.index.Schema;
 import com.google.inject.Inject;
 import com.google.inject.ProvisionException;
 import com.google.inject.Singleton;
-
-import org.eclipse.jgit.errors.ConfigInvalidException;
-import org.eclipse.jgit.lib.Config;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.io.IOException;
 import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
@@ -46,11 +40,14 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
+import org.eclipse.jgit.errors.ConfigInvalidException;
+import org.eclipse.jgit.lib.Config;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 @Singleton
 public class LuceneVersionManager implements LifecycleListener {
-  private static final Logger log = LoggerFactory
-      .getLogger(LuceneVersionManager.class);
+  private static final Logger log = LoggerFactory.getLogger(LuceneVersionManager.class);
 
   private static class Version<V> {
     private final Schema<V> schema;
@@ -58,8 +55,7 @@ public class LuceneVersionManager implements LifecycleListener {
     private final boolean exists;
     private final boolean ready;
 
-    private Version(Schema<V> schema, int version, boolean exists,
-        boolean ready) {
+    private Version(Schema<V> schema, int version, boolean exists, boolean ready) {
       checkArgument(schema == null || schema.getVersion() == version);
       this.schema = schema;
       this.version = version;
@@ -69,8 +65,7 @@ public class LuceneVersionManager implements LifecycleListener {
   }
 
   static Path getDir(SitePaths sitePaths, String prefix, Schema<?> schema) {
-    return sitePaths.index_dir.resolve(String.format("%s%04d",
-        prefix, schema.getVersion()));
+    return sitePaths.index_dir.resolve(String.format("%s%04d", prefix, schema.getVersion()));
   }
 
   private final SitePaths sitePaths;
@@ -93,9 +88,9 @@ public class LuceneVersionManager implements LifecycleListener {
     reindexers = Maps.newHashMapWithExpectedSize(defs.size());
     onlineUpgrade = cfg.getBoolean("index", null, "onlineUpgrade", true);
     runReindexMsg =
-        "No index versions ready; run java -jar " +
-        sitePaths.gerrit_war.toAbsolutePath() +
-        " reindex";
+        "No index versions ready; run java -jar "
+            + sitePaths.gerrit_war.toAbsolutePath()
+            + " reindex";
   }
 
   @Override
@@ -176,7 +171,7 @@ public class LuceneVersionManager implements LifecycleListener {
   /**
    * Start the online reindexer if the current index is not already the latest.
    *
-   * @param  force start re-index
+   * @param force start re-index
    * @return true if started, otherwise false.
    * @throws ReindexerAlreadyRunningException
    */
@@ -208,24 +203,20 @@ public class LuceneVersionManager implements LifecycleListener {
     return false;
   }
 
-  private boolean isCurrentIndexVersionLatest(
-      String name, OnlineReindexer<?, ?, ?> reindexer) {
-    int readVersion = defs.get(name).getIndexCollection().getSearchIndex()
-        .getSchema().getVersion();
-    return reindexer == null
-        || reindexer.getVersion() == readVersion;
+  private boolean isCurrentIndexVersionLatest(String name, OnlineReindexer<?, ?, ?> reindexer) {
+    int readVersion = defs.get(name).getIndexCollection().getSearchIndex().getSchema().getVersion();
+    return reindexer == null || reindexer.getVersion() == readVersion;
   }
 
-  private static void validateReindexerNotRunning(
-      OnlineReindexer<?, ?, ?> reindexer)
+  private static void validateReindexerNotRunning(OnlineReindexer<?, ?, ?> reindexer)
       throws ReindexerAlreadyRunningException {
     if (reindexer != null && reindexer.isRunning()) {
       throw new ReindexerAlreadyRunningException();
     }
   }
 
-  private <K, V, I extends Index<K, V>> TreeMap<Integer, Version<V>>
-      scanVersions(IndexDefinition<K, V, I> def, GerritIndexStatus cfg) {
+  private <K, V, I extends Index<K, V>> TreeMap<Integer, Version<V>> scanVersions(
+      IndexDefinition<K, V, I> def, GerritIndexStatus cfg) {
     TreeMap<Integer, Version<V>> versions = new TreeMap<>();
     for (Schema<V> schema : def.getSchemas().values()) {
       // This part is Lucene-specific.
@@ -235,13 +226,11 @@ public class LuceneVersionManager implements LifecycleListener {
         log.warn("Not a directory: %s", p.toAbsolutePath());
       }
       int v = schema.getVersion();
-      versions.put(v, new Version<>(
-          schema, v, isDir, cfg.getReady(def.getName(), v)));
+      versions.put(v, new Version<>(schema, v, isDir, cfg.getReady(def.getName(), v)));
     }
 
     String prefix = def.getName() + "_";
-    try (DirectoryStream<Path> paths =
-        Files.newDirectoryStream(sitePaths.index_dir)) {
+    try (DirectoryStream<Path> paths = Files.newDirectoryStream(sitePaths.index_dir)) {
       for (Path p : paths) {
         String n = p.getFileName().toString();
         if (!n.startsWith(prefix)) {
@@ -250,13 +239,11 @@ public class LuceneVersionManager implements LifecycleListener {
         String versionStr = n.substring(prefix.length());
         Integer v = Ints.tryParse(versionStr);
         if (v == null || versionStr.length() != 4) {
-          log.warn("Unrecognized version in index directory: {}",
-              p.toAbsolutePath());
+          log.warn("Unrecognized version in index directory: {}", p.toAbsolutePath());
           continue;
         }
         if (!versions.containsKey(v)) {
-          versions.put(v, new Version<V>(
-              null, v, true, cfg.getReady(def.getName(), v)));
+          versions.put(v, new Version<V>(null, v, true, cfg.getReady(def.getName(), v)));
         }
       }
     } catch (IOException e) {
@@ -265,8 +252,11 @@ public class LuceneVersionManager implements LifecycleListener {
     return versions;
   }
 
-  private <V> void markNotReady(GerritIndexStatus cfg, String name,
-      Iterable<Version<V>> versions, Collection<Version<V>> inUse) {
+  private <V> void markNotReady(
+      GerritIndexStatus cfg,
+      String name,
+      Iterable<Version<V>> versions,
+      Collection<Version<V>> inUse) {
     boolean dirty = false;
     for (Version<V> v : versions) {
       if (!inUse.contains(v) && v.exists) {