Start work to remove the context manager callbacks

pkg/analysis_server/lib/src/context_manager.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 context.directory.manager;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:core' hide Resource;
@@ skipping 289 matching lines @@
  * created, destroyed or updated, (b) inform the client when "pub list"
  * operations are in progress, and (c) determine which files should be
  * analyzed.
  *
  * TODO(paulberry): eliminate this interface, and instead have [ContextManager]
  * operations return data structures describing how context state should be
  * modified.
  */
 abstract class ContextManagerCallbacks {
   /**
-   * Return the default analysis options to be used when creating an analysis
-   * context.
-   */
-  AnalysisOptions get defaultAnalysisOptions;
-
-  /**
    * Create and return a new analysis context rooted at the given [folder], with
    * the given analysis [options], allowing [disposition] to govern details of
    * how the context is to be created.
    */
   AnalysisContext addContext(
       Folder folder, AnalysisOptions options, FolderDisposition disposition);
 
   /**
    * Called when the set of files associated with a context have changed (or
    * some of those files have been modified).  [changeSet] is the set of
@@ skipping 127 matching lines @@
 
   /// Provider of analysis options.
   AnalysisOptionsProvider analysisOptionsProvider =
       new AnalysisOptionsProvider();
 
   /**
    * The instrumentation service used to report instrumentation data.
    */
   final InstrumentationService _instrumentationService;
 
+  /**
+   * The default options used to create new analysis contexts.
+   */
+  final AnalysisOptionsImpl defaultContextOptions;
+
   @override
   ContextManagerCallbacks callbacks;
 
   /**
    * Virtual [ContextInfo] which acts as the ancestor of all other
    * [ContextInfo]s.
    */
   final ContextInfo rootInfo = new ContextInfo._root();
 
   /**
    * Stream subscription we are using to watch each analysis root directory for
    * changes.
    */
   final Map<Folder, StreamSubscription<WatchEvent>> changeSubscriptions =
       <Folder, StreamSubscription<WatchEvent>>{};
 
   ContextManagerImpl(
       this.resourceProvider,
       this.packageResolverProvider,
       this.embeddedUriResolverProvider,
       this._packageMapProvider,
-      this._instrumentationService) {
+      this._instrumentationService,
+      this.defaultContextOptions) {
     absolutePathContext = resourceProvider.absolutePathContext;
     pathContext = resourceProvider.pathContext;
   }
 
   @override
   List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot) {
     List<AnalysisContext> contexts = <AnalysisContext>[];
     ContextInfo innermostContainingInfo =
         _getInnermostContextInfoFor(analysisRoot.path);
     void addContextAndDescendants(ContextInfo info) {
@@ skipping 390 matching lines @@
 
         SourceFactory sourceFactory = info.context.sourceFactory;
 
         // Check for library embedders.
         if (embedderYamls.values.any(definesEmbeddedLibs)) {
           // If there is no embedded URI resolver, a new source factory needs to
           // be recreated.
           if (sourceFactory is SourceFactoryImpl) {
             if (!sourceFactory.resolvers
                 .any((UriResolver r) => r is EmbedderUriResolver)) {
-
               // Get all but the dart: Uri resolver.
               List<UriResolver> resolvers = sourceFactory.resolvers
                   .where((r) => r is! DartUriResolver)
                   .toList();
               // Add an embedded URI resolver in its place.
               resolvers.add(new EmbedderUriResolver(embedderYamls));
 
               // Set a new source factory.
               SourceFactoryImpl newFactory = sourceFactory.clone();
               newFactory.resolvers.clear();
@@ skipping 133 matching lines @@
     List<String> dependencies = <String>[];
 
     // Next resort to a package uri resolver.
     if (disposition == null) {
       disposition =
           _computeFolderDisposition(folder, dependencies.add, packagespecFile);
     }
 
     Map<String, Object> optionMap = readOptions(info.folder);
     AnalysisOptions options =
-        new AnalysisOptionsImpl.from(callbacks.defaultAnalysisOptions);
+        new AnalysisOptionsImpl.from(defaultContextOptions);
     applyToAnalysisOptions(options, optionMap);
 
     info.setDependencies(dependencies);
     info.context = callbacks.addContext(folder, options, disposition);
     info.context.name = folder.path;
 
     processOptionsForContext(info, optionMap);
 
     return info;
   }
@@ skipping 616 matching lines @@
       ResourceProvider resourceProvider) {
     if (packages != null) {
       // Construct package map for the SdkExtUriResolver.
       Map<String, List<Folder>> packageMap = buildPackageMap(resourceProvider);
       return <UriResolver>[new SdkExtUriResolver(packageMap)];
     } else {
       return const <UriResolver>[];
     }
   }
 }