@Override
  public UsageView showUsages(
      UsageInfo[] usages,
      UsageViewPresentation presentation,
      UsageViewManager manager,
      PsiElement[] elements) {
    final List<PsiElement> overridingMethods = new ArrayList<>();
    final List<UsageInfo> others = new ArrayList<>();
    for (UsageInfo usage : usages) {
      if (usage instanceof SafeDeleteOverridingMethodUsageInfo) {
        overridingMethods.add(((SafeDeleteOverridingMethodUsageInfo) usage).getOverridingMethod());
      } else {
        others.add(usage);
      }
    }

    UsageTarget[] targets = new UsageTarget[elements.length + overridingMethods.size()];
    for (int i = 0; i < targets.length; i++) {
      if (i < elements.length) {
        targets[i] = new PsiElement2UsageTargetAdapter(elements[i]);
      } else {
        targets[i] = new PsiElement2UsageTargetAdapter(overridingMethods.get(i - elements.length));
      }
    }

    return manager.showUsages(
        targets,
        UsageInfoToUsageConverter.convert(elements, others.toArray(new UsageInfo[others.size()])),
        presentation);
  }
  private void showUsageView(
      @NotNull final UsageViewDescriptor viewDescriptor,
      final Factory<UsageSearcher> factory,
      @NotNull final UsageInfo[] usageInfos) {
    UsageViewManager viewManager = UsageViewManager.getInstance(myProject);

    final PsiElement[] initialElements = viewDescriptor.getElements();
    final UsageTarget[] targets = PsiElement2UsageTargetAdapter.convert(initialElements);
    final Ref<Usage[]> convertUsagesRef = new Ref<>();
    if (!ProgressManager.getInstance()
        .runProcessWithProgressSynchronously(
            new Runnable() {
              @Override
              public void run() {
                ApplicationManager.getApplication()
                    .runReadAction(
                        new Runnable() {
                          @Override
                          public void run() {
                            convertUsagesRef.set(UsageInfo2UsageAdapter.convert(usageInfos));
                          }
                        });
              }
            },
            "Preprocess usages",
            true,
            myProject)) return;

    if (convertUsagesRef.isNull()) return;

    final Usage[] usages = convertUsagesRef.get();

    final UsageViewPresentation presentation = createPresentation(viewDescriptor, usages);

    final UsageView usageView = viewManager.showUsages(targets, usages, presentation, factory);
    customizeUsagesView(viewDescriptor, usageView);
  }
  private UsageView showUsages(
      UsageInfo[] usages, UsageViewPresentation presentation, UsageViewManager manager) {
    for (SafeDeleteProcessorDelegate delegate :
        Extensions.getExtensions(SafeDeleteProcessorDelegate.EP_NAME)) {
      if (delegate instanceof SafeDeleteProcessorDelegateBase) {
        final UsageView view =
            ((SafeDeleteProcessorDelegateBase) delegate)
                .showUsages(usages, presentation, manager, myElements);
        if (view != null) return view;
      }
    }
    UsageTarget[] targets = new UsageTarget[myElements.length];
    for (int i = 0; i < targets.length; i++) {
      targets[i] = new PsiElement2UsageTargetAdapter(myElements[i]);
    }

    return manager.showUsages(
        targets, UsageInfoToUsageConverter.convert(myElements, usages), presentation);
  }
  public void searchAndShowUsages(
      @NotNull UsageViewManager manager,
      @NotNull Factory<UsageSearcher> usageSearcherFactory,
      @NotNull final FindModel findModelCopy,
      @NotNull UsageViewPresentation presentation,
      @NotNull FindUsagesProcessPresentation processPresentation,
      final FindManager findManager) {
    presentation.setMergeDupLinesAvailable(false);
    final ReplaceContext[] context = new ReplaceContext[1];
    manager.searchAndShowUsages(
        new UsageTarget[] {
          new FindInProjectUtil.StringUsageTarget(myProject, findModelCopy.getStringToFind())
        },
        usageSearcherFactory,
        processPresentation,
        presentation,
        new UsageViewManager.UsageViewStateListener() {
          @Override
          public void usageViewCreated(@NotNull UsageView usageView) {
            context[0] = new ReplaceContext(usageView, findModelCopy);
            addReplaceActions(context[0]);
          }

          @Override
          public void findingUsagesFinished(final UsageView usageView) {
            if (context[0] != null && findManager.getFindInProjectModel().isPromptOnReplace()) {
              SwingUtilities.invokeLater(
                  new Runnable() {
                    @Override
                    public void run() {
                      replaceWithPrompt(context[0]);
                      context[0].invalidateExcludedSetCache();
                    }
                  });
            }
          }
        });
  }
  private void showUsages(final UsageInfo[] usages) {
    UsageViewPresentation presentation = new UsageViewPresentation();
    presentation.setTabText("Safe Delete Conflicts");
    presentation.setTargetsNodeText(
        RefactoringBundle.message("attempting.to.delete.targets.node.text"));
    presentation.setShowReadOnlyStatusAsRed(true);
    presentation.setShowCancelButton(true);
    presentation.setCodeUsagesString(RefactoringBundle.message("references.found.in.code"));
    presentation.setUsagesInGeneratedCodeString(
        RefactoringBundle.message("references.found.in.generated.code"));
    presentation.setNonCodeUsagesString(
        RefactoringBundle.message("occurrences.found.in.comments.strings.and.non.java.files"));
    presentation.setUsagesString(RefactoringBundle.message("usageView.usagesText"));

    UsageViewManager manager = UsageViewManager.getInstance(myProject);
    final UsageView usageView = showUsages(usages, presentation, manager);
    usageView.addPerformOperationAction(
        new RerunSafeDelete(myProject, myElements, usageView),
        RefactoringBundle.message("retry.command"),
        null,
        RefactoringBundle.message("rerun.safe.delete"));
    usageView.addPerformOperationAction(
        () -> {
          UsageInfo[] preprocessedUsages = usages;
          for (SafeDeleteProcessorDelegate delegate :
              Extensions.getExtensions(SafeDeleteProcessorDelegate.EP_NAME)) {
            preprocessedUsages = delegate.preprocessUsages(myProject, preprocessedUsages);
            if (preprocessedUsages == null) return;
          }
          final UsageInfo[] filteredUsages =
              UsageViewUtil.removeDuplicatedUsages(preprocessedUsages);
          execute(filteredUsages);
        },
        "Delete Anyway",
        RefactoringBundle.message("usageView.need.reRun"),
        RefactoringBundle.message("usageView.doAction"));
  }
  private void showElementUsages(
      @NotNull final FindUsagesHandler handler,
      final Editor editor,
      @NotNull final RelativePoint popupPosition,
      final int maxUsages,
      @NotNull final FindUsagesOptions options) {
    ApplicationManager.getApplication().assertIsDispatchThread();
    final UsageViewSettings usageViewSettings = UsageViewSettings.getInstance();
    final UsageViewSettings savedGlobalSettings = new UsageViewSettings();

    savedGlobalSettings.loadState(usageViewSettings);
    usageViewSettings.loadState(myUsageViewSettings);

    final Project project = handler.getProject();
    UsageViewManager manager = UsageViewManager.getInstance(project);
    FindUsagesManager findUsagesManager =
        ((FindManagerImpl) FindManager.getInstance(project)).getFindUsagesManager();
    final UsageViewPresentation presentation =
        findUsagesManager.createPresentation(handler, options);
    presentation.setDetachedMode(true);
    final UsageViewImpl usageView =
        (UsageViewImpl)
            manager.createUsageView(UsageTarget.EMPTY_ARRAY, Usage.EMPTY_ARRAY, presentation, null);

    Disposer.register(
        usageView,
        new Disposable() {
          @Override
          public void dispose() {
            myUsageViewSettings.loadState(usageViewSettings);
            usageViewSettings.loadState(savedGlobalSettings);
          }
        });

    final List<Usage> usages = new ArrayList<Usage>();
    final Set<UsageNode> visibleNodes = new LinkedHashSet<UsageNode>();
    UsageInfoToUsageConverter.TargetElementsDescriptor descriptor =
        new UsageInfoToUsageConverter.TargetElementsDescriptor(
            handler.getPrimaryElements(), handler.getSecondaryElements());

    final MyTable table = new MyTable();
    final AsyncProcessIcon processIcon = new AsyncProcessIcon("xxx");
    boolean hadMoreSeparator = visibleNodes.remove(MORE_USAGES_SEPARATOR_NODE);
    if (hadMoreSeparator) {
      usages.add(MORE_USAGES_SEPARATOR);
      visibleNodes.add(MORE_USAGES_SEPARATOR_NODE);
    }

    addUsageNodes(usageView.getRoot(), usageView, new ArrayList<UsageNode>());

    TableScrollingUtil.installActions(table);

    final List<UsageNode> data = collectData(usages, visibleNodes, usageView, presentation);
    setTableModel(table, usageView, data);

    SpeedSearchBase<JTable> speedSearch = new MySpeedSearch(table);
    speedSearch.setComparator(new SpeedSearchComparator(false));

    final JBPopup popup =
        createUsagePopup(
            usages,
            descriptor,
            visibleNodes,
            handler,
            editor,
            popupPosition,
            maxUsages,
            usageView,
            options,
            table,
            presentation,
            processIcon,
            hadMoreSeparator);

    Disposer.register(popup, usageView);

    // show popup only if find usages takes more than 300ms, otherwise it would flicker needlessly
    Alarm alarm = new Alarm(usageView);
    alarm.addRequest(
        new Runnable() {
          @Override
          public void run() {
            showPopupIfNeedTo(popup, popupPosition);
          }
        },
        300);

    final PingEDT pingEDT =
        new PingEDT(
            "Rebuild popup in EDT",
            new Condition<Object>() {
              @Override
              public boolean value(Object o) {
                return popup.isDisposed();
              }
            },
            100,
            new Runnable() {
              @Override
              public void run() {
                if (popup.isDisposed()) return;

                final List<UsageNode> nodes = new ArrayList<UsageNode>();
                List<Usage> copy;
                synchronized (usages) {
                  // open up popup as soon as several usages 've been found
                  if (!popup.isVisible()
                      && (usages.size() <= 1 || !showPopupIfNeedTo(popup, popupPosition))) {
                    return;
                  }
                  addUsageNodes(usageView.getRoot(), usageView, nodes);
                  copy = new ArrayList<Usage>(usages);
                }

                rebuildPopup(
                    usageView,
                    copy,
                    nodes,
                    table,
                    popup,
                    presentation,
                    popupPosition,
                    !processIcon.isDisposed());
              }
            });

    final MessageBusConnection messageBusConnection = project.getMessageBus().connect(usageView);
    messageBusConnection.subscribe(
        UsageFilteringRuleProvider.RULES_CHANGED,
        new Runnable() {
          @Override
          public void run() {
            pingEDT.ping();
          }
        });

    Processor<Usage> collect =
        new Processor<Usage>() {
          private final UsageTarget[] myUsageTarget = {
            new PsiElement2UsageTargetAdapter(handler.getPsiElement())
          };

          @Override
          public boolean process(@NotNull Usage usage) {
            synchronized (usages) {
              if (!filter.shouldShow(usage)) return true;
              if (visibleNodes.size() >= maxUsages) return false;
              if (UsageViewManager.isSelfUsage(usage, myUsageTarget)) {
                return true;
              }

              Usage usageToAdd = transform(usage);
              if (usageToAdd == null) return true;

              UsageNode node = usageView.doAppendUsage(usageToAdd);
              usages.add(usageToAdd);
              if (node != null) {
                visibleNodes.add(node);
                boolean continueSearch = true;
                if (visibleNodes.size() == maxUsages) {
                  visibleNodes.add(MORE_USAGES_SEPARATOR_NODE);
                  usages.add(MORE_USAGES_SEPARATOR);
                  continueSearch = false;
                }
                pingEDT.ping();

                return continueSearch;
              }
              return true;
            }
          }
        };

    final ProgressIndicator indicator =
        FindUsagesManager.startProcessUsages(
            handler,
            handler.getPrimaryElements(),
            handler.getSecondaryElements(),
            collect,
            options,
            new Runnable() {
              @Override
              public void run() {
                ApplicationManager.getApplication()
                    .invokeLater(
                        new Runnable() {
                          @Override
                          public void run() {
                            Disposer.dispose(processIcon);
                            Container parent = processIcon.getParent();
                            parent.remove(processIcon);
                            parent.repaint();
                            pingEDT.ping(); // repaint title
                            synchronized (usages) {
                              if (visibleNodes.isEmpty()) {
                                if (usages.isEmpty()) {
                                  String text =
                                      UsageViewBundle.message(
                                          "no.usages.found.in",
                                          searchScopePresentableName(options, project));
                                  showHint(
                                      text, editor, popupPosition, handler, maxUsages, options);
                                  popup.cancel();
                                } else {
                                  // all usages filtered out
                                }
                              } else if (visibleNodes.size() == 1) {
                                if (usages.size() == 1) {
                                  // the only usage
                                  Usage usage = visibleNodes.iterator().next().getUsage();
                                  usage.navigate(true);
                                  // String message =
                                  // UsageViewBundle.message("show.usages.only.usage",
                                  // searchScopePresentableName(options, project));
                                  // navigateAndHint(usage, message, handler, popupPosition,
                                  // maxUsages, options);
                                  popup.cancel();
                                } else {
                                  assert usages.size() > 1 : usages;
                                  // usage view can filter usages down to one
                                  Usage visibleUsage = visibleNodes.iterator().next().getUsage();
                                  if (areAllUsagesInOneLine(visibleUsage, usages)) {
                                    String hint =
                                        UsageViewBundle.message(
                                            "all.usages.are.in.this.line",
                                            usages.size(),
                                            searchScopePresentableName(options, project));
                                    navigateAndHint(
                                        visibleUsage,
                                        hint,
                                        handler,
                                        popupPosition,
                                        maxUsages,
                                        options);
                                    popup.cancel();
                                  }
                                }
                              } else {
                                String title = presentation.getTabText();
                                boolean shouldShowMoreSeparator =
                                    visibleNodes.contains(MORE_USAGES_SEPARATOR_NODE);
                                String fullTitle =
                                    getFullTitle(
                                        usages,
                                        title,
                                        shouldShowMoreSeparator,
                                        visibleNodes.size() - (shouldShowMoreSeparator ? 1 : 0),
                                        false);
                                ((AbstractPopup) popup).setCaption(fullTitle);
                              }
                            }
                          }
                        },
                        project.getDisposed());
              }
            });
    Disposer.register(
        popup,
        new Disposable() {
          @Override
          public void dispose() {
            indicator.cancel();
          }
        });
  }