Disaply compile error position in diff viewer

plugins/org.chromium.debug.ui/src/org/chromium/debug/ui/liveedit/PreviewLoader.java

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.debug.ui.liveedit;
 
 import static org.chromium.debug.ui.DialogUtils.createErrorOptional;
 import static org.chromium.debug.ui.DialogUtils.createOptional;
 
 import org.chromium.debug.core.model.PushChangesPlan;
 import org.chromium.debug.ui.DialogUtils.Message;
 import org.chromium.debug.ui.DialogUtils.MessagePriority;
 import org.chromium.debug.ui.DialogUtils.Optional;
 import org.chromium.debug.ui.DialogUtils.Scope;
 import org.chromium.debug.ui.DialogUtils.Updater;
 import org.chromium.debug.ui.DialogUtils.ValueConsumer;
 import org.chromium.debug.ui.DialogUtils.ValueSource;
 import org.chromium.sdk.UpdatableScript;
-import org.chromium.sdk.UpdatableScript.ChangeDescription;
+import org.chromium.sdk.UpdatableScript.CompileErrorFailure;
 import org.eclipse.osgi.util.NLS;
 
 /**
  * An asynchronous loader of LiveEdit update preview data. It deals with outer world in terms of
  * {@link Updater} sources/consumers.
  * It implements {@link ValueSource} interface that provides a loaded result, or null data
  * if the result is not loaded yet. Updater gets notified whenever result is delivered.
  * <p>The input parameter may be changed at any moment.
  * <p>The loader may be in active or passive state. Since the preview data this class loads
  * is optional and is not required for wizard's work, the loader should be kept passive until
  * user actually needs its result (turns the page).
  */
 class PreviewLoader implements ValueSource<Optional<PreviewLoader.Data>> {
   private final Updater updater;
   private final ValueSource<PushChangesPlan> inputParameterSource;
   private boolean active = false;
   private final Monitor dataMonitor = new Monitor();
 
-  PreviewLoader(Updater updater, ValueSource<PushChangesPlan> inputParameterSource) {
+  PreviewLoader(Updater updater,
+      ValueSource<PushChangesPlan> inputParameterSource) {
     this.updater = updater;
     this.inputParameterSource = inputParameterSource;
   }
 
   void registerSelf(Scope scope) {
     updater.addSource(scope, this);
     updater.addConsumer(scope, parametersConsumer);
     updater.addDependency(parametersConsumer, inputParameterSource);
   }
 
   void setActive(boolean active) {
     this.active = active;
     if (active) {
       requestPreview();
     }
   }
 
   private void requestPreview() {
     final PushChangesPlan plan = inputParameterSource.getValue();
     boolean inputIsNew = dataMonitor.updateInputAndStarted(plan);
     if (!inputIsNew) {
       return;
     }
 
     // Report about our value becoming empty.
     updater.reportChanged(this);
 
     UpdatableScript.UpdateCallback callback = new UpdatableScript.UpdateCallback() {
-      public void failure(String message, UpdatableScript.Failure failure) {
-        Optional<Data> error = createErrorOptional(
-            new Message(NLS.bind(Messages.PreviewLoader_FAILED_TO_GET, message),
-                MessagePriority.WARNING));
-        done(error);
+      public void failure(final String message, UpdatableScript.Failure failure) {
+        Optional<Data> result = failure.accept(
+            new UpdatableScript.Failure.Visitor<Optional<Data>>() {
+          @Override
+          public Optional<Data> visitUnspecified() {
+            return createErrorOptional(
+                new Message(NLS.bind(Messages.PreviewLoader_FAILED_TO_GET, message),
+                    MessagePriority.WARNING));
+          }
+
+          @Override
+          public Optional<Data> visitCompileError(final CompileErrorFailure compileError) {
+            Data data = new Data() {
+              @Override
+              public <R> R accept(Visitor<R> visitor) {
+                return visitor.visitCompileError(compileError);
+              }
+              @Override public PushChangesPlan getChangesPlan() {
+                return plan;
+              }
+            };
+            return createOptional(data);
+          }
+        });
+        done(result);
       }
       public void success(Object report,
           final UpdatableScript.ChangeDescription changeDescription) {
         Optional<Data> result;
         if (changeDescription == null) {
           result = EMPTY_DATA;
         } else {
           Data data = new Data() {
             @Override public PushChangesPlan getChangesPlan() {
               return plan;
             }
-            @Override public ChangeDescription getChangeDescription() {
-              return changeDescription;
+            @Override public <R> R accept(Visitor<R> visitor) {
+              return visitor.visitSuccess(changeDescription);
             }
           };
           result = createOptional(data);
         }
         done(result);
       }
       private void done(Optional<Data> result) {
         boolean resultTaken = dataMonitor.updateResult(result, plan);
         if (resultTaken) {
           updater.reportChanged(PreviewLoader.this);
           updater.updateAsync();
         }
       }
     };
 
     plan.execute(true, callback, null);
   }
 
   public interface Data {
-    UpdatableScript.ChangeDescription getChangeDescription();
+    interface Visitor<R> {
+      R visitSuccess(UpdatableScript.ChangeDescription changeDescription);
+      R visitCompileError(UpdatableScript.CompileErrorFailure compileError);
+    }
+
+    <R> R accept(Visitor<R> visitor);
+
     PushChangesPlan getChangesPlan();
   }
 
   public Optional<Data> getValue() {
     return dataMonitor.getValue();
   }
 
   // A consumer that receive the actual input parameter (ScriptTargetMapping).
   private final ValueConsumer parametersConsumer = new ValueConsumer() {
     public void update(Updater updater) {
@@ skipping 50 matching lines @@
       this.result = result;
       return true;
     }
   }
 
   private static final Optional<Data> NO_DATA = createErrorOptional(
       new Message(Messages.PreviewLoader_WAITING_FOR_DIFF, MessagePriority.NONE));
   private static final Optional<Data> EMPTY_DATA =
       createErrorOptional(new Message(Messages.PreviewLoader_FAILED_TO_LOAD, MessagePriority.NONE));
 }