Split intraline differences into their own cache

The bulk of the running time for loading a PatchList entry from the
PatchListCache is actually within the intraline difference code.
Assuming no bugs, running JGit's DiffFormatter and converting the
results is typically sub-second, even for a very large change that
has renames.

By deferring the intraline difference logic until its actually
required to display a particular file allows file lists to load
very quickly, and doesn't penalize users who have disabled the
intraline difference setting in their account preferences.

This also offers a work around for the dreaded "patch of death"
situation.  When a bad file is encountered and it won't load,
users can temporarily switch off intraline difference and open the
file anyway.  Unfortunately the server will still have at least
one worker thread stuck generating the intraline difference cache
record, but at least the change is still viewable.

Change-Id: I61bbd3d068bd9b3da9d1018c0f66969a5b6ff58e
Signed-off-by: Shawn O. Pearce <sop@google.com>

gerrit-server/src/main/java/com/google/gerrit/server/patch/IntraLineDiffKey.java

@@ -0,0 +1,103 @@
+// Copyright (C) 2010 The Android Open Source Project
+//
+// 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.google.gerrit.server.patch;
+
+import static org.eclipse.jgit.lib.ObjectIdSerialization.readNotNull;
+import static org.eclipse.jgit.lib.ObjectIdSerialization.writeNotNull;
+
+import org.eclipse.jgit.diff.Edit;
+import org.eclipse.jgit.lib.ObjectId;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.List;
+
+public class IntraLineDiffKey implements Serializable {
+  static final long serialVersionUID = 1L;
+
+  private transient ObjectId aId;
+  private transient ObjectId bId;
+
+  // Transient data passed through on cache misses to the loader.
+
+  private transient Text aText;
+  private transient Text bText;
+  private transient List<Edit> edits;
+
+  IntraLineDiffKey(ObjectId aId, Text aText, ObjectId bId, Text bText,
+      List<Edit> edits) {
+    this.aId = aId;
+    this.bId = bId;
+
+    this.aText = aText;
+    this.bText = bText;
+    this.edits = edits;
+  }
+
+  Text getTextA() {
+    return aText;
+  }
+
+  Text getTextB() {
+    return bText;
+  }
+
+  List<Edit> getEdits() {
+    return edits;
+  }
+
+  @Override
+  public int hashCode() {
+    int h = 0;
+
+    h = h * 31 + aId.hashCode();
+    h = h * 31 + bId.hashCode();
+
+    return h;
+  }
+
+  @Override
+  public boolean equals(final Object o) {
+    if (o instanceof IntraLineDiffKey) {
+      final IntraLineDiffKey k = (IntraLineDiffKey) o;
+      return aId.equals(k.aId) //
+          && bId.equals(k.bId);
+    }
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder n = new StringBuilder();
+    n.append("IntraLineDiffKey[");
+    n.append(aId.name());
+    n.append("..");
+    n.append(bId.name());
+    n.append("]");
+    return n.toString();
+  }
+
+  private void writeObject(final ObjectOutputStream out) throws IOException {
+    writeNotNull(out, aId);
+    writeNotNull(out, bId);
+  }
+
+  private void readObject(final ObjectInputStream in) throws IOException {
+    aId = readNotNull(in);
+    bId = readNotNull(in);
+  }
+}