Move onContextsChanged and defaultOptions into AnalysisServer.

pkg/analysis_server/lib/src/analysis_server.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analysis.server;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core' hide Resource;
 import 'dart:math' show max;
@@ skipping 254 matching lines @@
   /**
    * If the "analysis.analyzedFiles" notification is currently being subscribed
    * to (see [generalAnalysisServices]), and at least one such notification has
    * been sent since the subscription was enabled, the set of analyzed files
    * that was delivered in the most recently sent notification.  Otherwise
    * `null`.
    */
   Set<String> prevAnalyzedFiles;
 
   /**
+   * The default options used to create new analysis contexts.
+   */
+  AnalysisOptionsImpl defaultContextOptions = new AnalysisOptionsImpl();
+
+  /**
+   * The controller for sending [ContextsChangedEvent]s.
+   */
+  StreamController<ContextsChangedEvent> _onContextsChangedController =
+      new StreamController<ContextsChangedEvent>.broadcast();
+
+  /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
    *
    * If a [contextManager] is provided, then the [packageResolverProvider] will
    * be ignored.
    *
    * If [rethrowExceptions] is true, then any exceptions thrown by analysis are
    * propagated up the call stack.  The default is true to allow analysis
    * exceptions to show up in unit tests, but it should be set to false when
    * running a full analysis server.
    */
   AnalysisServer(this.channel, this.resourceProvider,
       OptimizingPubPackageMapProvider packageMapProvider, Index _index,
       this.serverPlugin, this.options, this.defaultSdk,
       this.instrumentationService, {ContextManager contextManager: null,
       ResolverProvider packageResolverProvider: null,
       this.rethrowExceptions: true})
       : index = _index,
         searchEngine = _index != null ? createSearchEngine(_index) : null {
     _performance = performanceDuringStartup;
     operationQueue = new ServerOperationQueue();
     if (contextManager == null) {
       contextManager = new ContextManagerImpl(resourceProvider,
           packageResolverProvider, packageMapProvider, instrumentationService);
     }
     ServerContextManagerCallbacks contextManagerCallbacks =
         new ServerContextManagerCallbacks(this, resourceProvider);
     contextManager.callbacks = contextManagerCallbacks;
-    AnalysisOptionsImpl analysisOptions =
-        contextManagerCallbacks.defaultOptions;
-    analysisOptions.incremental = true;
-    analysisOptions.incrementalApi = options.enableIncrementalResolutionApi;
-    analysisOptions.incrementalValidation =
+    defaultContextOptions.incremental = true;
+    defaultContextOptions.incrementalApi =
+        options.enableIncrementalResolutionApi;
+    defaultContextOptions.incrementalValidation =
         options.enableIncrementalResolutionValidation;
-    analysisOptions.generateImplicitErrors = false;
+    defaultContextOptions.generateImplicitErrors = false;
     this.contextManager = contextManager;
     _noErrorNotification = options.noErrorNotification;
     AnalysisEngine.instance.logger = new AnalysisLogger();
     _onAnalysisStartedController = new StreamController.broadcast();
     _onFileAnalyzedController = new StreamController.broadcast();
     _onPriorityChangeController =
         new StreamController<PriorityChangeEvent>.broadcast();
     running = true;
     onAnalysisStarted.first.then((_) {
       onAnalysisComplete.then((_) {
@@ skipping 25 matching lines @@
    * The stream that is notified when analysis of a context is started.
    */
   Stream<AnalysisContext> get onAnalysisStarted {
     return _onAnalysisStartedController.stream;
   }
 
   /**
    * The stream that is notified when contexts are added or removed.
    */
   Stream<ContextsChangedEvent> get onContextsChanged =>
-      (contextManager.callbacks as ServerContextManagerCallbacks).onContextsChanged;
+      _onContextsChangedController.stream;
 
   /**
    * The stream that is notified when a single file has been analyzed.
    */
   Stream get onFileAnalyzed => _onFileAnalyzedController.stream;
 
   /**
    * The stream that is notified when priority sources change.
    */
   Stream<PriorityChangeEvent> get onPriorityChange =>
@@ skipping 851 matching lines @@
       optionUpdaters.forEach((OptionUpdater optionUpdater) {
         optionUpdater(options);
       });
       context.analysisOptions = options;
       // TODO(brianwilkerson) As far as I can tell, this doesn't cause analysis
       // to be scheduled for this context.
     });
     //
     // Update the defaults used to create new contexts.
     //
-    AnalysisOptionsImpl options =
-        (contextManager.callbacks as ServerContextManagerCallbacks).defaultOptions;
     optionUpdaters.forEach((OptionUpdater optionUpdater) {
-      optionUpdater(options);
+      optionUpdater(defaultContextOptions);
     });
   }
 
   /**
    * Return a set of contexts containing all of the resources in the given list
    * of [resources].
    */
   Set<AnalysisContext> _getContexts(List<Resource> resources) {
     Set<AnalysisContext> contexts = new HashSet<AnalysisContext>();
     resources.forEach((Resource resource) {
@@ skipping 92 matching lines @@
 class PriorityChangeEvent {
   final Source firstSource;
 
   PriorityChangeEvent(this.firstSource);
 }
 
 class ServerContextManagerCallbacks extends ContextManagerCallbacks {
   final AnalysisServer analysisServer;
 
   /**
-   * The default options used to create new analysis contexts.
-   *
-   * TODO(paulberry): move this into AnalysisServer so that a cast isn't needed
-   * to access it.
-   */
-  AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
-
-  /**
-   * The controller for sending [ContextsChangedEvent]s.
-   */
-  StreamController<ContextsChangedEvent> _onContextsChangedController;
-
-  /**
    * The [ResourceProvider] by which paths are converted into [Resource]s.
    */
   final ResourceProvider resourceProvider;
 
-  ServerContextManagerCallbacks(this.analysisServer, this.resourceProvider) {
-    _onContextsChangedController =
-        new StreamController<ContextsChangedEvent>.broadcast();
-  }
-
-  /**
-   * The stream that is notified when contexts are added or removed.
-   *
-   * TODO(paulberry): move this into AnalysisServer so that a cast isn't needed
-   * to access it.
-   */
-  Stream<ContextsChangedEvent> get onContextsChanged =>
-      _onContextsChangedController.stream;
+  ServerContextManagerCallbacks(this.analysisServer, this.resourceProvider);
 
   @override
   AnalysisContext addContext(
       Folder folder, UriResolver packageUriResolver, Packages packages) {
     InternalAnalysisContext context =
         AnalysisEngine.instance.createAnalysisContext();
     context.contentCache = analysisServer.overlayState;
     analysisServer.folderMap[folder] = context;
     context.sourceFactory = _createSourceFactory(packageUriResolver, packages);
-    context.analysisOptions = new AnalysisOptionsImpl.from(defaultOptions);
-    _onContextsChangedController
+    context.analysisOptions =
+        new AnalysisOptionsImpl.from(analysisServer.defaultContextOptions);
+    analysisServer._onContextsChangedController
         .add(new ContextsChangedEvent(added: [context]));
     analysisServer.schedulePerformAnalysisOperation(context);
     return context;
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     if (context != null) {
       context.applyChanges(changeSet);
@@ skipping 18 matching lines @@
 
   @override
   void removeContext(Folder folder, List<String> flushedFiles) {
     AnalysisContext context = analysisServer.folderMap.remove(folder);
     sendAnalysisNotificationFlushResults(analysisServer, flushedFiles);
 
     if (analysisServer.index != null) {
       analysisServer.index.removeContext(context);
     }
     analysisServer.operationQueue.contextRemoved(context);
-    _onContextsChangedController
+    analysisServer._onContextsChangedController
         .add(new ContextsChangedEvent(removed: [context]));
     analysisServer.sendContextAnalysisDoneNotifications(
         context, AnalysisDoneReason.CONTEXT_REMOVED);
     context.dispose();
   }
 
   @override
   bool shouldFileBeAnalyzed(File file) {
     List<ShouldAnalyzeFile> functions =
         analysisServer.serverPlugin.analyzeFileFunctions;
     for (ShouldAnalyzeFile shouldAnalyzeFile in functions) {
       if (shouldAnalyzeFile(file)) {
         // Emacs creates dummy links to track the fact that a file is open for
         // editing and has unsaved changes (e.g. having unsaved changes to
         // 'foo.dart' causes a link '.#foo.dart' to be created, which points to
         // the non-existent file 'username@hostname.pid'. To avoid these dummy
         // links causing the analyzer to thrash, just ignore links to
         // non-existent files.
         return file.exists;
       }
     }
     return false;
   }
 
   @override
   void updateContextPackageUriResolver(
       Folder contextFolder, UriResolver packageUriResolver, Packages packages) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     context.sourceFactory = _createSourceFactory(packageUriResolver, packages);
-    _onContextsChangedController
+    analysisServer._onContextsChangedController
         .add(new ContextsChangedEvent(changed: [context]));
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   void _computingPackageMap(bool computing) {
     if (analysisServer.serverServices.contains(ServerService.STATUS)) {
       PubStatus pubStatus = new PubStatus(computing);
       ServerStatusParams params = new ServerStatusParams(pub: pubStatus);
       analysisServer.sendNotification(params.toNotification());
     }
@@ skipping 117 matching lines @@
   /**
    * The [PerformanceTag] for time spent in server request handlers.
    */
   static PerformanceTag serverRequests = new PerformanceTag('serverRequests');
 
   /**
    * The [PerformanceTag] for time spent in split store microtasks.
    */
   static PerformanceTag splitStore = new PerformanceTag('splitStore');
 }