Redo normal expressions in dialog updater to be thread-safe

plugins/org.chromium.debug.ui/src/org/chromium/debug/ui/liveedit/WizardLogicBuilder.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.createConstant;
-import static org.chromium.debug.ui.DialogUtils.createErrorOptional;
-import static org.chromium.debug.ui.DialogUtils.createOptional;
-import static org.chromium.debug.ui.DialogUtils.createOptionalProcessor;
-import static org.chromium.debug.ui.DialogUtils.createProcessor;
-import static org.chromium.debug.ui.DialogUtils.dependencies;
-import static org.chromium.debug.ui.DialogUtils.handleErrors;
-import static org.chromium.debug.ui.DialogUtils.handleErrorsAddNew;
+import static org.chromium.debug.ui.DialogUtils.*;
 
 import java.util.List;
 
 import org.chromium.debug.core.ChromiumDebugPlugin;
 import org.chromium.debug.core.util.ScriptTargetMapping;
-import org.chromium.debug.ui.DialogUtils.Gettable;
-import org.chromium.debug.ui.DialogUtils.Message;
-import org.chromium.debug.ui.DialogUtils.MessagePriority;
-import org.chromium.debug.ui.DialogUtils.NormalExpression;
+import org.chromium.debug.ui.DialogUtils.*;
 import org.chromium.debug.ui.DialogUtils.Optional;
-import org.chromium.debug.ui.DialogUtils.OptionalSwitcher;
-import org.chromium.debug.ui.DialogUtils.Scope;
-import org.chromium.debug.ui.DialogUtils.ScopeEnabler;
-import org.chromium.debug.ui.DialogUtils.Updater;
-import org.chromium.debug.ui.DialogUtils.ValueConsumer;
 import org.chromium.debug.ui.DialogUtils.ValueProcessor;
 import org.chromium.debug.ui.DialogUtils.ValueSource;
 import org.chromium.debug.ui.WizardUtils.LogicBasedWizard;
 import org.chromium.debug.ui.WizardUtils.NextPageEnabler;
 import org.chromium.debug.ui.WizardUtils.PageElements;
 import org.chromium.debug.ui.WizardUtils.PageImpl;
 import org.chromium.debug.ui.WizardUtils.PageListener;
 import org.chromium.debug.ui.WizardUtils.WizardFinishController;
 import org.chromium.debug.ui.WizardUtils.WizardFinisher;
 import org.chromium.debug.ui.WizardUtils.WizardLogic;
 import org.chromium.debug.ui.actions.ChooseVmControl;
 import org.chromium.debug.ui.actions.CompareChangesAction;
 import org.chromium.debug.ui.liveedit.PushChangesWizard.FinisherDelegate;
+import org.chromium.sdk.UpdatableScript;
 import org.chromium.sdk.UpdatableScript.ChangeDescription;
 import org.eclipse.compare.structuremergeviewer.DiffNode;
 import org.eclipse.core.runtime.NullProgressMonitor;
 
 /**
  * Creates Updater-based logic implementation of the wizard. It is responsible for proper data
  * manipulation and view control updates.
  * <p>
  * The wizard pages are arranged in graph with one fork:<br>
  * 'choose vm' -&gt;
@@ skipping 58 matching lines @@
           return createOptional(vmList);
         }
       }
     });
     updater.addSource(scope, selectedVmValue);
     updater.addConsumer(scope, selectedVmValue);
     updater.addDependency(selectedVmValue, selectedVmInput);
 
 
     // A condition value for up-coming fork between 'single vm' and 'multiple vm' paths.
-    Gettable<? extends Optional<Boolean>> singleVmSelectedExpression = handleErrors(
+    Gettable<? extends Optional<? extends Boolean>> singleVmSelectedExpression = handleErrors(
         new NormalExpression<Boolean>() {
-          public Boolean calculate() {
-            return selectedVmValue.getValue().getNormal().size() == 1;
+          @Calculate
+          public Boolean calculate(List<ScriptTargetMapping> selectedVm) {
+            return selectedVm.size() == 1;
           }
-        },
-        dependencies(selectedVmValue));
+          @DependencyGetter
+          public ValueSource<? extends Optional<List<ScriptTargetMapping>>> getSelectVmSource() {
+            return selectedVmValue;
+          }
+        });
 
     // A switch between 2 paths: 'single vm' and 'multiple vm'.
     OptionalSwitcher<Boolean> singleVmSelectedSwitch =
         scope.addOptionalSwitch(singleVmSelectedExpression);
 
     final PreviewAndOptionPath singleVmPath =
         createSingleVmPath(chooseVmPage, singleVmSelectedSwitch, selectedVmValue);
     final PreviewAndOptionPath multipleVmPath =
         createMultipleVmPath(chooseVmPage, singleVmSelectedSwitch, selectedVmValue);
 
     // 2 merges for output values of 2 paths. Only the value from active path is effective.
     final ValueSource<? extends Optional<? extends FinisherDelegate>> wizardFinisherDelegateValue =
         singleVmSelectedSwitch.createOptionalMerge(singleVmPath.getFinisherDelegateValue(),
             multipleVmPath.getFinisherDelegateValue());
 
-    ValueSource<? extends Optional<Void>> warningValue =
+    ValueSource<? extends Optional<? extends Void>> warningValue =
         singleVmSelectedSwitch.createOptionalMerge(singleVmPath.getWarningValue(),
             multipleVmPath.getWarningValue());
 
 
     // A simple value converter that wraps wizard delegate as UI-aware wizard finisher.
-    ValueProcessor<Optional<WizardFinisher>> finisherValue =
-        createOptionalProcessor(new NormalExpression<WizardFinisher>() {
-              public WizardFinisher calculate() {
-                return new PushChangesWizard.FinisherImpl(
-                    wizardFinisherDelegateValue.getValue().getNormal());
+    ValueProcessor<Optional<? extends WizardFinisher>> finisherValue =
+        createProcessor(handleErrors(new NormalExpression<WizardFinisher>() {
+              @Calculate
+              public WizardFinisher calculate(FinisherDelegate finisherDelegate) {
+                return new PushChangesWizard.FinisherImpl(finisherDelegate);
               }
-            },
-            dependencies(wizardFinisherDelegateValue));
+              @DependencyGetter
+              public ValueSource<? extends Optional<? extends FinisherDelegate>>
+                  getWizardFinisherDelegateSource() {
+                return wizardFinisherDelegateValue;
+              }
+            }));
     updater.addConsumer(scope, finisherValue);
     updater.addSource(scope, finisherValue);
     updater.addDependency(finisherValue, wizardFinisherDelegateValue);
 
     // A controller that ties finisher value and other warnings to a wizard UI.
     WizardFinishController finishController =
         new WizardFinishController(finisherValue, warningValue, wizardImpl);
     updater.addConsumer(scope, finishController);
     updater.addDependency(finishController, wizardFinisherDelegateValue);
     updater.addDependency(finishController, warningValue);
@@ skipping 10 matching lines @@
       }
     };
   }
 
   /**
    * An internal interface that defines a uniform output of preview path. The preview path
    * is responsible for returning finisher (which may carry error messages) and it also may
    * return additional warning messages.
    */
   private interface PreviewAndOptionPath {
-    ValueSource<? extends Optional<FinisherDelegate>> getFinisherDelegateValue();
+    ValueSource<? extends Optional<? extends FinisherDelegate>> getFinisherDelegateValue();
     ValueSource<Optional<Void>> getWarningValue();
   }
 
   /**
    * Creates a 'single vm' page path in wizard. User sees it after choosing exactly one VM.
    * It consists of 2 pages, 'textual preview' and 'v8 preview'.
    */
   private PreviewAndOptionPath createSingleVmPath(PageImpl<?> basePage,
       OptionalSwitcher<Boolean> switcher,
       final ValueSource<? extends Optional<? extends List<ScriptTargetMapping>>> selectedVmValue) {
@@ skipping 43 matching lines @@
 
     // previewRawResultValue is trigged only when page is actually visible to user.
     v8PreviewPage.addListener(new PageListener() {
       public void onSetVisible(boolean visible) {
         previewRawResultValue.setActive(visible);
       }
     });
 
     // Parses raw preview value and converts it into a form suitable for the viewer; also handles
     // errors that become warnings.
-    final ValueProcessor<Optional<LiveEditDiffViewer.Input>> previewValue =
-        createProcessor(handleErrorsAddNew(
-            new NormalExpression<Optional<LiveEditDiffViewer.Input>>() {
-          public Optional<LiveEditDiffViewer.Input> calculate() {
-            ScriptTargetMapping filePair = singleVmValue.getValue();
-            ChangeDescription changeDescription = previewRawResultValue.getValue().getNormal();
-            Optional<LiveEditDiffViewer.Input> result;
-            if (changeDescription == null) {
-              result = createOptional(null);
-            } else {
-              try {
-                LiveEditDiffViewer.Input viewerInput =
-                    PushResultParser.createViewerInput(changeDescription, filePair, true);
-                result = createOptional(viewerInput);
-              } catch (RuntimeException e) {
-                ChromiumDebugPlugin.log(e);
-                result = createErrorOptional(new Message(
-                    "Error in getting preview: " + e.toString(), MessagePriority.WARNING));
+    final ValueProcessor<Optional<? extends LiveEditDiffViewer.Input>> previewValue =
+      createProcessor(handleErrors(
+          new NormalExpression<LiveEditDiffViewer.Input>() {
+            @Calculate
+            public Optional<? extends LiveEditDiffViewer.Input> calculate(
+                ChangeDescription previewRawResultParam) {
+              ScriptTargetMapping filePair = singleVmValue.getValue();
+              ChangeDescription changeDescription = previewRawResultParam;
+              Optional<LiveEditDiffViewer.Input> result;
+              if (changeDescription == null) {
+                result = createOptional(null);
+              } else {
+                try {
+                  LiveEditDiffViewer.Input viewerInput =
+                      PushResultParser.createViewerInput(changeDescription, filePair, true);
+                  result = createOptional(viewerInput);
+                } catch (RuntimeException e) {
+                  ChromiumDebugPlugin.log(e);
+                  result = createErrorOptional(new Message(
+                      "Error in getting preview: " + e.toString(), MessagePriority.WARNING));
+                }
               }
+              return result;
             }
-            return result;
-          }
-        },
-        dependencies(previewRawResultValue)));
+            @DependencyGetter
+            public ValueSource<Optional<UpdatableScript.ChangeDescription>>
+                previewRawResultValueSource() {
+              return previewRawResultValue;
+            }
+          }));
+
+
+
     updater.addConsumer(scope, previewValue);
     updater.addSource(scope, previewValue);
     updater.addDependency(previewValue, previewRawResultValue);
     updater.addDependency(previewValue, singleVmValue);
 
     // A simple consumer that sets preview data to the viewer.
     ValueConsumer v8PreviewInputSetter = new ValueConsumer() {
       public void update(Updater updater) {
-        Optional<LiveEditDiffViewer.Input> previewOptional = previewValue.getValue();
+        Optional<? extends LiveEditDiffViewer.Input> previewOptional = previewValue.getValue();
         LiveEditDiffViewer.Input viewerInput;
         if (previewOptional.isNormal()) {
           viewerInput = previewOptional.getNormal();
         } else {
           viewerInput = null;
         }
         v8PreviewPage.getPageElements().getPreviewViewer().setInput(viewerInput);
       }
     };
     updater.addConsumer(scope, v8PreviewInputSetter);
@@ skipping 49 matching lines @@
       OptionalSwitcher<Boolean> switcher,
       final ValueSource<? extends Optional<? extends List<ScriptTargetMapping>>> selectedVmValue) {
 
     PageImpl<PageElements> multipleVmStubPage = pageSet.getMultipleVmStubPage();
 
     ScopeEnabler scopeEnabler =
         new NextPageEnabler(basePage, multipleVmStubPage);
 
     Scope scope = switcher.addScope(Boolean.FALSE, scopeEnabler);
 
-    final ValueProcessor<? extends Optional<FinisherDelegate>> wizardFinisher =
+    final ValueProcessor<Optional<? extends FinisherDelegate>> wizardFinisher =
         createProcessor(handleErrors(new NormalExpression<FinisherDelegate>() {
-          public FinisherDelegate calculate() {
+          @Calculate
+          public FinisherDelegate calculate(List<ScriptTargetMapping> selectedVm) {
             return new PushChangesWizard.MultipleVmFinisher(selectedVmValue.getValue().getNormal());
           }
-        }, dependencies(selectedVmValue)));
+          @DependencyGetter
+          public ValueSource<? extends Optional<? extends List<ScriptTargetMapping>>>
+              getSelectVmSource() {
+            return selectedVmValue;
+          }
+        }));
     updater.addSource(scope, wizardFinisher);
     updater.addConsumer(scope, wizardFinisher);
     updater.addDependency(wizardFinisher, selectedVmValue);
 
     final ValueSource<Optional<Void>> warningValue =
         createConstant(createOptional((Void) null), updater);
 
     return new PreviewAndOptionPath() {
-      public ValueSource<? extends Optional<FinisherDelegate>> getFinisherDelegateValue() {
+      public ValueSource<? extends Optional<? extends FinisherDelegate>>
+          getFinisherDelegateValue() {
         return wizardFinisher;
       }
       public ValueSource<Optional<Void>> getWarningValue() {
         return warningValue;
       }
     };
   }
 }