[style] Add braces to DeltaTask

Change-Id: I3306cc77544dec6d9273b2c35b8db0ed43799992
Signed-off-by: Terry Parker <tparker@google.com>

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/DeltaTask.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/DeltaTask.java
index f855312761c8cad31b138ab09e7945e82de48575..9c84fb7ad2ad1b204c2f9715235e13ed556b390d 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/DeltaTask.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/DeltaTask.java
@@ -110,10 +110,12 @@ final class DeltaTask implements Callable<Object> {
                                                maxWork = s.size();
                                        }
                                }
-                               if (maxTask == null)
+                               if (maxTask == null) {
                                        return null;
-                               if (maxTask.tryStealWork(maxSlice))
+                               }
+                               if (maxTask.tryStealWork(maxSlice)) {
                                        return forThread.initWindow(maxSlice);
+                               }
                        }
                }
 
@@ -138,26 +140,30 @@ final class DeltaTask implements Callable<Object> {
                                for (; w < weightPerThread && i < endIndex;) {
                                        if (nextTop < topPaths.size()
                                                        && i == topPaths.get(nextTop).slice.beginIndex) {
-                                               if (s < i)
+                                               if (s < i) {
                                                        task.add(new Slice(s, i));
+                                               }
                                                s = i = topPaths.get(nextTop++).slice.endIndex;
-                                       } else
+                                       } else {
                                                w += list[i++].getWeight();
+                                       }
                                }
 
                                // Round up the slice to the end of a path.
                                if (s < i) {
                                        int h = list[i - 1].getPathHash();
                                        while (i < endIndex) {
-                                               if (h == list[i].getPathHash())
+                                               if (h == list[i].getPathHash()) {
                                                        i++;
-                                               else
+                                               } else {
                                                        break;
+                                               }
                                        }
                                        task.add(new Slice(s, i));
                                }
-                               if (!task.slices.isEmpty())
+                               if (!task.slices.isEmpty()) {
                                        tasks.add(task);
+                               }
                        }
                        while (topPathItr.hasNext()) {
                                WeightedPath p = topPathItr.next();
@@ -184,22 +190,25 @@ final class DeltaTask implements Callable<Object> {
                                                if (topPaths.size() < threads) {
                                                        Slice s = new Slice(cp, i);
                                                        topPaths.add(new WeightedPath(cw, s));
-                                                       if (topPaths.size() == threads)
+                                                       if (topPaths.size() == threads) {
                                                                Collections.sort(topPaths);
+                                                       }
                                                } else if (topPaths.get(0).weight < cw) {
                                                        Slice s = new Slice(cp, i);
                                                        WeightedPath p = new WeightedPath(cw, s);
                                                        topPaths.set(0, p);
-                                                       if (p.compareTo(topPaths.get(1)) > 0)
+                                                       if (p.compareTo(topPaths.get(1)) > 0) {
                                                                Collections.sort(topPaths);
+                                                       }
                                                }
                                        }
                                        cp = i;
                                        ch = o.getPathHash();
                                        cw = 0;
                                }
-                               if (o.isEdge() || o.doNotAttemptDelta())
+                               if (o.isEdge() || o.doNotAttemptDelta()) {
                                        continue;
+                               }
                                cw += o.getWeight();
                                totalWeight += o.getWeight();
                        }
@@ -212,8 +221,9 @@ final class DeltaTask implements Callable<Object> {
                        });
 
                        bytesPerUnit = 1;
-                       while (MAX_METER <= (totalWeight / bytesPerUnit))
+                       while (MAX_METER <= (totalWeight / bytesPerUnit)) {
                                bytesPerUnit <<= 10;
+                       }
                        return topPaths;
                }
        }
@@ -229,8 +239,9 @@ final class DeltaTask implements Callable<Object> {
 
                public int compareTo(WeightedPath o) {
                        int cmp = Long.signum(weight - o.weight);
-                       if (cmp != 0)
+                       if (cmp != 0) {
                                return cmp;
+                       }
                        return slice.beginIndex - o.slice.beginIndex;
                }
        }
@@ -278,14 +289,16 @@ final class DeltaTask implements Callable<Object> {
                        DeltaWindow w;
                        for (;;) {
                                synchronized (this) {
-                                       if (slices.isEmpty())
+                                       if (slices.isEmpty()) {
                                                break;
+                                       }
                                        w = initWindow(slices.removeFirst());
                                }
                                runWindow(w);
                        }
-                       while ((w = block.stealWork(this)) != null)
+                       while ((w = block.stealWork(this)) != null) {
                                runWindow(w);
+                       }
                } finally {
                        block.pm.endWorker();
                        or.close();
@@ -315,8 +328,9 @@ final class DeltaTask implements Callable<Object> {
        }
 
        synchronized Slice remaining() {
-               if (!slices.isEmpty())
+               if (!slices.isEmpty()) {
                        return slices.getLast();
+               }
                DeltaWindow d = dw;
                return d != null ? d.remaining() : null;
        }