import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
public boolean isUpToDate() {
  if (id == 0) return true;
  if (!EduNames.STUDY.equals(courseMode)) return true;

  ProgressManager.getInstance().runProcessWithProgressAsynchronously(new Backgroundable(null, "Updating Course") {
    @Override
    public void run(@NotNull ProgressIndicator indicator) {
      final Date date = EduStepicConnector.getCourseUpdateDate(id);
      if (date == null) return;
      if (date.after(myUpdateDate)) {
        isUpToDate = false;
      }
      for (Lesson lesson : lessons) {
        if (!lesson.isUpToDate()) {
          isUpToDate = false;
        }
      }
    }
  }, new EmptyProgressIndicator());

  return isUpToDate;
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
public void actionPerformed(final AnActionEvent e) {
  if (myLagging) {
    myLagging = false;
    myAlarm.cancelAllRequests();
  }
  else {
    myLagging = true;
    for (int i = 0; i < 100; i++) {
      new Runnable() {
        @Override
        public void run() {
          DebugUtil.sleep(5);
          ProgressManager.getInstance().runProcessWithProgressAsynchronously(new Task.Backgroundable(null, "lagging") {
            @Override
            public void run(@NotNull ProgressIndicator indicator) {
              DebugUtil.sleep(1);
            }
          }, new EmptyProgressIndicator());
          if (myLagging) {
            myAlarm.addRequest(this, 1);
          }
        }
      }.run();
    }
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
public void testProcessorReturningFalseDoesNotCrashTheOtherThread() {
  final AtomicInteger delay = new AtomicInteger(0);
  final Runnable checkCanceled = new Runnable() {
    @Override
    public void run() {
      ProgressManager.checkCanceled();
    }
  };
  Processor<String> processor = new Processor<String>() {
    @Override
    public boolean process(String s) {
      busySleep(delay.incrementAndGet() % 10 + 10, checkCanceled);
      return delay.get() % 100 != 0;
    }
  };
  for (int i=0; i<100; i++) {
    ProgressIndicator indicator = new EmptyProgressIndicator();
    boolean result = JobLauncher.getInstance()
      .invokeConcurrentlyUnderProgress(Collections.nCopies(10000, ""), indicator, false, false, processor);
    assertFalse(indicator.isCanceled());
    assertFalse(result);
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
private static void doTest(Map<String, String> graph, final String start, final String finish, final int k, String... expectedPaths) {
  final Graph<String> generator = initGraph(graph);
  final List<List<String>> paths = getAlgorithmsInstance().findKShortestPaths(generator, start, finish, k, new EmptyProgressIndicator());
  List<String> pathStrings = new ArrayList<String>();
  Set<Integer> sizes = new HashSet<Integer>();
  for (List<String> path : paths) {
    pathStrings.add(StringUtil.join(path, ""));
    sizes.add(path.size());
  }
  if (sizes.size() != paths.size()) {
    UsefulTestCase.assertSameElements(pathStrings, expectedPaths);
  }
  else {
    UsefulTestCase.assertOrderedEquals(pathStrings, expectedPaths);
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
private void reparseFile(final PsiFile file, FileElement treeElement, CharSequence newText) {
  PsiToDocumentSynchronizer synchronizer =((PsiDocumentManagerBase)PsiDocumentManager.getInstance(myProject)).getSynchronizer();
  TextRange changedPsiRange = DocumentCommitProcessor.getChangedPsiRange(file, treeElement, newText);
  if (changedPsiRange == null) return;

  final DiffLog log = BlockSupport.getInstance(myProject).reparseRange(file, changedPsiRange, newText, new EmptyProgressIndicator(),
                                                                       treeElement.getText());
  synchronizer.setIgnorePsiEvents(true);
  try {
    CodeStyleManager.getInstance(file.getProject()).performActionWithFormatterDisabled(new Runnable() {
      @Override
      public void run() {
        runTransaction(new PomTransactionBase(file, getModelAspect(TreeAspect.class)) {
          @Nullable
          @Override
          public PomModelEvent runInner() throws IncorrectOperationException {
            return new TreeAspectEvent(PomModelImpl.this, log.performActualPsiChange(file));
          }
        });
      }
    });
  }
  finally {
    synchronizer.setIgnorePsiEvents(false);
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
private void updateExpectAuthCanceled(File wc1, String expectedText) {
  Assert.assertTrue(wc1.isDirectory());
  final VirtualFile vf = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(wc1);
  final UpdatedFiles files = UpdatedFiles.create();
  final UpdateSession session =
    myVcs.getUpdateEnvironment().updateDirectories(new FilePath[]{VcsUtil.getFilePath(vf)}, files, new EmptyProgressIndicator(),
                                                   new Ref<SequentialUpdatesContext>());
  Assert.assertTrue(session.getExceptions() != null && ! session.getExceptions().isEmpty());
  Assert.assertTrue(!session.isCanceled());
  Assert.assertTrue(session.getExceptions().get(0).getMessage().contains(expectedText));

  if (myIsSecure) {
    ++ myExpectedCreds;
    ++ myExpectedCert;
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
private void assertUnversioned(VirtualFile... files) throws VcsException {
  MockChangelistBuilder builder = new MockChangelistBuilder();
  myChangeProvider.getChanges(myDirtyScope, builder, new EmptyProgressIndicator(),
                              new MockChangeListManagerGate(ChangeListManager.getInstance(myProject)));
  List<VirtualFile> unversionedFiles = builder.getUnversionedFiles();
  
  assertEquals(unversionedFiles.size(), files.length, "Incorrect number of unversioned files.");
  for (VirtualFile expected : files) {
    if (!unversionedFiles.contains(expected)) {
      fail("Expected file " + expected + " is not unversioned!");
    }
  }
  for (VirtualFile actual : unversionedFiles) {
    if (ArrayUtil.find(files, actual) < 0) {
      fail("Actually unversioned file " + actual + " is not in the unversioned list!");
    }
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
private void updateExpectAuthCanceled(File wc1, String expectedText) {
  Assert.assertTrue(wc1.isDirectory());
  final VirtualFile vf = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(wc1);
  final UpdatedFiles files = UpdatedFiles.create();
  final UpdateSession session =
    myVcs.getUpdateEnvironment().updateDirectories(new FilePath[]{new FilePathImpl(vf)}, files, new EmptyProgressIndicator(),
                                                   new Ref<SequentialUpdatesContext>());
  Assert.assertTrue(session.getExceptions() != null && ! session.getExceptions().isEmpty());
  Assert.assertTrue(!session.isCanceled());
  Assert.assertTrue(session.getExceptions().get(0).getMessage().contains(expectedText));

  if (myIsSecure) {
    ++ myExpectedCreds;
    ++ myExpectedCert;
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
public void processEvent() {
  int rows = myGraphTable.getSelectedRowCount();
  if (rows < 1) {
    myLoadingPanel.stopLoading();
    onEmptySelection();
  }
  else {
    onSelection(myGraphTable.getSelectedRows());
    myLoadingPanel.startLoading();

    final EmptyProgressIndicator indicator = new EmptyProgressIndicator();
    myLastRequest = indicator;

    List<Integer> selectionToLoad = getSelectionToLoad();
    myLogData.getCommitDetailsGetter()
      .loadCommitsData(myGraphTable.getModel().convertToCommitIds(selectionToLoad), detailsList -> {
        if (myLastRequest == indicator && !(indicator.isCanceled())) {
          LOG.assertTrue(selectionToLoad.size() == detailsList.size(),
                         "Loaded incorrect number of details " + detailsList + " for selection " + selectionToLoad);
          myLastRequest = null;
          onDetailsLoaded(detailsList);
          myLoadingPanel.stopLoading();
        }
      }, indicator);
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
public static <T> T runUnderDisposeAwareIndicator(@Nonnull Disposable parent, @Nonnull Computable<T> task) {
  ProgressIndicator indicator = new EmptyProgressIndicator(ModalityState.defaultModalityState());
  indicator.start();

  Disposable disposable = () -> {
    if (indicator.isRunning()) indicator.cancel();
  };

  if (!registerIfParentNotDisposed(parent, disposable)) {
    indicator.cancel();
    throw new ProcessCanceledException();
  }

  try {
    return ProgressManager.getInstance().runProcess(task, indicator);
  }
  finally {
    Disposer.dispose(disposable);
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
@Nullable
private Runnable reparseFile(@Nonnull final PsiFile file, @Nonnull FileElement treeElement, @Nonnull CharSequence newText) {
  TextRange changedPsiRange = ChangedPsiRangeUtil.getChangedPsiRange(file, treeElement, newText);
  if (changedPsiRange == null) return null;

  Runnable reparseLeaf = tryReparseOneLeaf(treeElement, newText, changedPsiRange);
  if (reparseLeaf != null) return reparseLeaf;

  final DiffLog log = BlockSupport.getInstance(myProject).reparseRange(file, treeElement, changedPsiRange, newText, new EmptyProgressIndicator(),
                                                                       treeElement.getText());
  return () -> runTransaction(new PomTransactionBase(file, getModelAspect(TreeAspect.class)) {
    @Override
    public PomModelEvent runInner() throws IncorrectOperationException {
      return new TreeAspectEvent(PomModelImpl.this, log.performActualPsiChange(file));
    }
  });
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
@Override
public void invoke(@Nonnull final Project project, final Editor editor, final PsiFile file) throws IncorrectOperationException {

  final List<ProblemDescriptor> descriptions = ProgressManager.getInstance().runProcess(() -> {
    InspectionManager inspectionManager = InspectionManager.getInstance(project);
    return InspectionEngine.runInspectionOnFile(file, myToolWrapper, inspectionManager.createNewGlobalContext(false));
  }, new EmptyProgressIndicator());

  if (!descriptions.isEmpty() && !FileModificationService.getInstance().preparePsiElementForWrite(file)) return;

  final AbstractPerformFixesTask fixesTask = applyFixes(project, "Apply Fixes", descriptions, myQuickfixClass);

  if (!fixesTask.isApplicableFixFound()) {
    HintManager.getInstance().showErrorHint(editor, "Unfortunately '" + myText + "' is currently not available for batch mode\n User interaction is required for each problem found");
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
@NotNull
@Override
public SearchCostResult isCheapEnoughToSearch(@NotNull String name,
                                              @NotNull final GlobalSearchScope scope,
                                              @Nullable final PsiFile fileToIgnoreOccurrencesIn,
                                              @Nullable final ProgressIndicator progress) {
  final AtomicInteger count = new AtomicInteger();
  final ProgressIndicator indicator = progress == null ? new EmptyProgressIndicator() : progress;
  final Processor<VirtualFile> processor = new Processor<VirtualFile>() {
    private final VirtualFile virtualFileToIgnoreOccurrencesIn =
      fileToIgnoreOccurrencesIn == null ? null : fileToIgnoreOccurrencesIn.getVirtualFile();

    @Override
    public boolean process(VirtualFile file) {
      indicator.checkCanceled();
      if (Comparing.equal(file, virtualFileToIgnoreOccurrencesIn)) return true;
      final int value = count.incrementAndGet();
      return value < 10;
    }
  };
  List<IdIndexEntry> keys = getWordEntries(name, true);
  boolean cheap = keys.isEmpty() || processFilesContainingAllKeys(myManager.getProject(), scope, null, keys, processor);

  if (!cheap) {
    return SearchCostResult.TOO_MANY_OCCURRENCES;
  }

  return count.get() == 0 ? SearchCostResult.ZERO_OCCURRENCES : SearchCostResult.FEW_OCCURRENCES;
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
public static void ensureCorrectReparse(@NotNull final PsiFile file) {
  final String psiToStringDefault = DebugUtil.psiToString(file, false, false);

  final String fileText = file.getText();
  final DiffLog diffLog = new BlockSupportImpl(file.getProject()).reparseRange(
    file, TextRange.allOf(fileText), fileText, new EmptyProgressIndicator(), fileText);
  diffLog.performActualPsiChange(file);

  TestCase.assertEquals(psiToStringDefault, DebugUtil.psiToString(file, false, false));
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
@Override
public void load(@Nullable final String configPath) {
  AccessToken token = HeavyProcessLatch.INSTANCE.processStarted("Loading application components");
  try {
    long t = System.currentTimeMillis();
    init(mySplash == null ? null : new EmptyProgressIndicator() {
      @Override
      public void setFraction(double fraction) {
        mySplash.showProgress("", (float)(0.65 + getPercentageOfComponentsLoaded() * 0.35));
      }
    }, new Runnable() {
      @Override
      public void run() {
        // create ServiceManagerImpl at first to force extension classes registration
        getPicoContainer().getComponentInstance(ServiceManagerImpl.class);

        String effectiveConfigPath = FileUtilRt.toSystemIndependentName(configPath == null ? PathManager.getConfigPath() : configPath);
        for (ApplicationLoadListener listener : ApplicationLoadListener.EP_NAME.getExtensions()) {
          try {
            listener.beforeApplicationLoaded(ApplicationImpl.this, effectiveConfigPath);
          }
          catch (Throwable e) {
            LOG.error(e);
          }
        }

        // we set it after beforeApplicationLoaded call, because app store can depends on stream provider state
        ServiceKt.getStateStore(ApplicationImpl.this).setPath(effectiveConfigPath);
      }
    });
    t = System.currentTimeMillis() - t;
    LOG.info(getComponentConfigCount() + " application components initialized in " + t + " ms");
  }
  finally {
    token.finish();
  }
  myLoaded = true;

  createLocatorFile();
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
public static void sendError(Project project,
                             final String login,
                             final String password,
                             final ErrorBean error,
                             final Consumer<Integer> callback,
                             final Consumer<Exception> errback) {
  if (StringUtil.isEmpty(login)) {
    return;
  }

  Task.Backgroundable task = new Task.Backgroundable(project, DiagnosticBundle.message("title.submitting.error.report")) {
    @Override
    public void run(@NotNull ProgressIndicator indicator) {
      try {
        int threadId = postNewThread(login, password, error);
        callback.consume(threadId);
      }
      catch (Exception ex) {
        errback.consume(ex);
      }
    }
  };

  if (project == null) {
    task.run(new EmptyProgressIndicator());
  }
  else {
    ProgressManager.getInstance().run(task);
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
@Override
public boolean beforeOkAction() {
  if (myCreateEntryCheckBox.isSelected()) {
    try {
      CreateDesktopEntryAction.createDesktopEntry(null, new EmptyProgressIndicator(), myGlobalEntryCheckBox.isSelected());
    }
    catch (Throwable e) {
      // ignored
    }
  }
  return true;
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
public void testTasksRunEvenWhenReadActionIsHardToGet_Performance() throws ExecutionException, InterruptedException {
  final Processor<String> processor = new Processor<String>() {
    @Override
    public boolean process(String s) {
      busySleep(1);
      return true;
    }
  };
  for (int i=0; i<10/*0*/; i++) {
    System.out.println("i = " + i);
    final ProgressIndicator indicator = new EmptyProgressIndicator();
    Future<?> future = ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
      @Override
      public void run() {
        JobLauncher.getInstance().invokeConcurrentlyUnderProgress(Collections.nCopies(10000, ""), indicator, true, false, processor);
        assertFalse(indicator.isCanceled());
      }
    });
    for (int k=0; k<10000; k++) {
      ApplicationManager.getApplication().runWriteAction(new Runnable() {
        @Override
        public void run() {
          busySleep(1);
        }
      });
    }
    future.get();
  }
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
@NotNull
private DiffLog merge(@NotNull final ASTNode oldRoot, @NotNull StartMarker newRoot, @NotNull CharSequence lastCommittedText) {
  DiffLog diffLog = new DiffLog();
  DiffTreeChangeBuilder<ASTNode, LighterASTNode> builder = new ConvertFromTokensToASTBuilder(newRoot, diffLog);
  MyTreeStructure treeStructure = new MyTreeStructure(newRoot, null);
  ShallowNodeComparator<ASTNode, LighterASTNode> comparator = new MyComparator(getUserDataUnprotected(CUSTOM_COMPARATOR), treeStructure);

  ProgressIndicator indicator = ProgressIndicatorProvider.getGlobalProgressIndicator();
  BlockSupportImpl.diffTrees(oldRoot, builder, comparator, treeStructure, indicator == null ? new EmptyProgressIndicator() : indicator,
                             lastCommittedText);
  return diffLog;
}
 

import com.intellij.openapi.progress.EmptyProgressIndicator; //导入依赖的package包/类
@CalledInAwt
private void pingImpl() {
  while (true) {
    myCurrentWrapper.set(null);
    // stop if project is being disposed
    if (!myProject.isDefault() && !myProject.isOpen()) return;
    if (getSuspendFlag()) return;
    final TaskDescriptor current = getNextMatching();
    if (current == null) {
      return;
    }

    if (Where.AWT.equals(current.getWhere())) {
      setIndicator(null);
      try {
        current.run(this);
      }
      catch (RuntimeException th) {
        handleException(th, true);
      }
    }
    else {
      final TaskWrapper task = new TaskWrapper(myProject, current.getName(), myCancellable, current);
      myCurrentWrapper.set(task);
      if (ApplicationManager.getApplication().isUnitTestMode()) {
        setIndicator(new EmptyProgressIndicator());
      }
      else {
        setIndicator(new BackgroundableProcessIndicator(task));
      }
      ProgressManager.getInstance().runProcessWithProgressAsynchronously(task, getIndicator());
      return;
    }
  }
}