Extension point for AnalysisResultListener(s).

pkg/analysis_server/lib/src/domain_analysis.dart

Index: pkg/analysis_server/lib/src/domain_analysis.dart
diff --git a/pkg/analysis_server/lib/src/domain_analysis.dart b/pkg/analysis_server/lib/src/domain_analysis.dart
index 655ca2fc571b7f81554ebb302bbe81888f09cb50..5dd9feb36d3ad3edcf75194702f2b0764fdeedd8 100644
--- a/pkg/analysis_server/lib/src/domain_analysis.dart
+++ b/pkg/analysis_server/lib/src/domain_analysis.dart
@@ -7,16 +7,23 @@ library domain.analysis;
 import 'dart:async';
 import 'dart:core' hide Resource;
 
+import 'package:analysis_server/analysis/analysis_domain.dart';
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/computer/computer_hover.dart';
 import 'package:analysis_server/src/constants.dart';
+import 'package:analysis_server/src/context_manager.dart';
 import 'package:analysis_server/src/domains/analysis/navigation.dart';
+import 'package:analysis_server/src/operation/operation_analysis.dart'
+    show sendAnalysisNotificationNavigation;
 import 'package:analysis_server/src/protocol_server.dart';
 import 'package:analysis_server/src/services/dependencies/library_dependencies.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart' as engine;
+import 'package:analyzer/src/generated/java_engine.dart' show CaughtException;
+import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/task/model.dart' show ResultDescriptor;
 
 /**
  * Instances of the class [AnalysisDomainHandler] implement a [RequestHandler]
@@ -31,7 +38,9 @@ class AnalysisDomainHandler implements RequestHandler {
   /**
    * Initialize a newly created handler to handle requests for the given [server].
    */
-  AnalysisDomainHandler(this.server);
+  AnalysisDomainHandler(this.server) {
+    _callAnalysisDomainReceivers();
+  }
 
   /**
    * Implement the `analysis.getErrors` request.
@@ -290,4 +299,72 @@ class AnalysisDomainHandler implements RequestHandler {
     server.updateOptions(updaters);
     return new AnalysisUpdateOptionsResult().toResponse(request.id);
   }
+
+  /**
+   * Call all the registered [SetAnalysisDomain] functions.
+   */
+  void _callAnalysisDomainReceivers() {
+    AnalysisDomain analysisDomain = new AnalysisDomainImpl(server);
+    for (SetAnalysisDomain function
+        in server.serverPlugin.setAnalysisDomainFunctions) {
+      try {
+        function(analysisDomain);
+      } catch (exception, stackTrace) {
+        engine.AnalysisEngine.instance.logger.logError(
+            'Exception from analysis domain receiver: ${function.runtimeType}',
+            new CaughtException(exception, stackTrace));
+      }
+    }
+  }
+}
+
+/**
+ * An implementation of [AnalysisDomain] for [AnalysisServer].
+ */
+class AnalysisDomainImpl implements AnalysisDomain {
+  final AnalysisServer server;
+
+  final Map<ResultDescriptor,
+          StreamController<engine.ComputedResult>> controllers =
+      <ResultDescriptor, StreamController<engine.ComputedResult>>{};
+
+  AnalysisDomainImpl(this.server) {
+    server.onContextsChanged.listen((ContextsChangedEvent event) {
+      event.added.forEach(_subscribeForContext);
+    });
+  }
+
+  @override
+  Stream<engine.ComputedResult> onResultComputed(ResultDescriptor descriptor) {
+    Stream<engine.ComputedResult> stream = controllers
+        .putIfAbsent(descriptor,
+            () => new StreamController<engine.ComputedResult>.broadcast())
+        .stream;
+    server.getAnalysisContexts().forEach(_subscribeForContext);
+    return stream;
+  }
+
+  @override
+  void scheduleNotification(
+      engine.AnalysisContext context, Source source, AnalysisService service) {
+    // TODO(scheglov) schedule, don't do it right now
+    String file = source.fullName;
+    if (server.hasAnalysisSubscription(service, file)) {
+      if (service == AnalysisService.NAVIGATION) {
+        sendAnalysisNotificationNavigation(server, context, source);
+      }
+    }
+  }
+
+  void _subscribeForContext(engine.AnalysisContext context) {
+    for (ResultDescriptor descriptor in controllers.keys) {
+      context.onResultComputed(descriptor).listen((result) {
+        StreamController<engine.ComputedResult> controller =
+            controllers[result.descriptor];
+        if (controller != null) {
+          controller.add(result);
+        }
+      });
+    }
+  }
 }