update ContextManager to support analysis option include directive

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';
@@ skipping 459 matching lines @@
    * to the standard URI resolver.
    */
   final ResolverProvider packageResolverProvider;
 
   /**
    * Provider which is used to determine the mapping from package name to
    * package folder.
    */
   final PubPackageMapProvider _packageMapProvider;
 
-  /// Provider of analysis options.
-  AnalysisOptionsProvider analysisOptionsProvider =
-      new AnalysisOptionsProvider();
-
   /**
    * A list of the globs used to determine which files should be analyzed.
    */
   final List<Glob> analyzedFilesGlobs;
 
   /**
    * The default options used to create new analysis contexts.
    */
   final AnalysisOptionsImpl defaultContextOptions;
 
@@ skipping 184 matching lines @@
         setIgnorePatternsForContext(info, excludeList);
       }
     }
   }
 
   /**
    * Return the options from the analysis options file in the given [folder]
    * if exists, or in one of the parent folders, or `null` if no analysis
    * options file is found or if the contents of the file are not valid YAML.
    */
-  Map<String, Object> readOptions(Folder folder) {
+  Map<String, Object> readOptions(Folder folder, Packages packages) {
     try {
-      return analysisOptionsProvider.getOptions(folder, crawlUp: true);
+      Map<String, List<Folder>> packageMap =
+          new ContextBuilder(resourceProvider, null, null)
+              .convertPackagesToMap(packages);
+      List<UriResolver> resolvers = <UriResolver>[
+        new ResourceUriResolver(resourceProvider),
+        new PackageMapUriResolver(resourceProvider, packageMap),
+      ];
+      SourceFactory sourceFactory =
+          new SourceFactory(resolvers, packages, resourceProvider);
+      return new AnalysisOptionsProvider(sourceFactory)
+          .getOptions(folder, crawlUp: true);
     } catch (_) {
       // Parse errors are reported by GenerateOptionsErrorsTask.
     }
     return null;
   }
 
   @override
   void refresh(List<Resource> roots) {
     // Destroy old contexts
     List<ContextInfo> contextInfos = rootInfo.descendants.toList();
@@ skipping 208 matching lines @@
         _addSourceFiles(changeSet, child, info);
       }
     }
   }
 
   void _checkForAnalysisOptionsUpdate(
       String path, ContextInfo info, ChangeType changeType) {
     if (AnalysisEngine.isAnalysisOptionsFileName(path, pathContext)) {
       var analysisContext = info.context;
       if (analysisContext is context.AnalysisContextImpl) {
-        Map<String, Object> options = readOptions(info.folder);
+        Map<String, Object> options =
+            readOptions(info.folder, info.disposition.packages);
         processOptionsForContext(info, options,
             optionsRemoved: changeType == ChangeType.REMOVE);
         analysisContext.sourceFactory = _createSourceFactory(
             analysisContext, analysisContext.analysisOptions, info.folder);
         callbacks.applyChangesToContext(info.folder, new ChangeSet());
       }
     }
   }
 
   void _checkForPackagespecUpdate(
@@ skipping 132 matching lines @@
    * [parent] and using [packagespecFile] to resolve package URI's.
    */
   ContextInfo _createContext(
       ContextInfo parent, Folder folder, File packagespecFile) {
     List<String> dependencies = <String>[];
     FolderDisposition disposition =
         _computeFolderDisposition(folder, dependencies.add, packagespecFile);
     ContextInfo info = new ContextInfo(this, parent, folder, packagespecFile,
         normalizedPackageRoots[folder.path], disposition);
 
-    Map<String, Object> optionMap = readOptions(info.folder);
+    Map<String, Object> optionMap =
+        readOptions(info.folder, disposition.packages);
     AnalysisOptions options =
         new AnalysisOptionsImpl.from(defaultContextOptions);
     applyToAnalysisOptions(options, optionMap);
 
     info.setDependencies(dependencies);
     if (enableNewAnalysisDriver) {
       info.analysisDriver = callbacks.addAnalysisDriver(folder, options);
     } else {
       info.context = callbacks.addContext(folder, options);
       _folderMap[folder] = info.context;
@@ skipping 800 matching lines @@
     }
     return _embedderLocator;
   }
 
   @override
   SdkExtensionFinder getSdkExtensionFinder(ResourceProvider resourceProvider) {
     return _sdkExtensionFinder ??=
         new SdkExtensionFinder(buildPackageMap(resourceProvider));
   }
 }