Get some tests running using the analysis driver

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 272 matching lines @@
    * folder is or contains the given path.  ("innermost" refers to the nesting
    * of contexts, so if there is a context for path /foo and a context for
    * path /foo/bar, then the innermost context containing /foo/bar/baz.dart is
    * the context for /foo/bar.)
    *
    * If no context contains the given path, `null` is returned.
    */
   AnalysisContext getContextFor(String path);
 
   /**
+   * Return a list of all of the analysis drivers reachable from the given
+   * [analysisRoot] (the driver associated with [analysisRoot] and all of its
+   * descendants).
+   */
+  List<AnalysisDriver> getDriversInAnalysisRoot(Folder analysisRoot);
+
+  /**
    * Return `true` if the given [path] is ignored by a [ContextInfo] whose
    * folder contains it.
    */
   bool isIgnored(String path);
 
   /**
    * Return `true` if the given absolute [path] is in one of the current
    * root folders and is not excluded.
    */
   bool isInAnalysisRoot(String path);
@@ skipping 282 matching lines @@
    */
   ContextInfo getContextInfoFor(Folder folder) {
     ContextInfo info = _getInnermostContextInfoFor(folder.path);
     if (info != null && folder == info.folder) {
       return info;
     }
     return null;
   }
 
   @override
+  List<AnalysisDriver> getDriversInAnalysisRoot(Folder analysisRoot) {
+    List<AnalysisDriver> drivers = <AnalysisDriver>[];
+    void addContextAndDescendants(ContextInfo info) {
+      drivers.add(info.analysisDriver);
+      info.children.forEach(addContextAndDescendants);
+    }
+
+    ContextInfo innermostContainingInfo =
+        _getInnermostContextInfoFor(analysisRoot.path);
+    if (innermostContainingInfo != null) {
+      if (analysisRoot == innermostContainingInfo.folder) {
+        addContextAndDescendants(innermostContainingInfo);
+      } else {
+        for (ContextInfo info in innermostContainingInfo.children) {
+          if (analysisRoot.isOrContains(info.folder.path)) {
+            addContextAndDescendants(info);
+          }
+        }
+      }
+    }
+    return drivers;
+  }
+
+  @override
   bool isIgnored(String path) {
     ContextInfo info = rootInfo;
     do {
       info = info.findChildInfoFor(path);
       if (info == null) {
         return false;
       }
       if (info.ignored(path)) {
         return true;
       }
@@ skipping 344 matching lines @@
           continue;
         }
         _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, info.disposition.packages);
-        processOptionsForContext(info, options,
-            optionsRemoved: changeType == ChangeType.REMOVE);
-        analysisContext.sourceFactory = _createSourceFactory(
-            analysisContext, analysisContext.analysisOptions, info.folder);
-        callbacks.applyChangesToContext(info.folder, new ChangeSet());
+      if (enableNewAnalysisDriver) {
+        // TODO(brianwilkerson) Implement this.
+//        AnalysisDriver driver = info.analysisDriver;
+//        String contextRoot = info.folder.path;
+//        ContextBuilder builder =
+//        callbacks.createContextBuilder(info.folder, defaultContextOptions);
+//        AnalysisOptions options = builder.getAnalysisOptions(contextRoot);
+//        driver.analysisOptions = options;
+//        driver.sourceFactory = builder.createSourceFactory(contextRoot, options);
+        // TODO(brianwilkerson) Set exclusion patterns.
+      } else {
+        var analysisContext = info.context;
+        if (analysisContext is context.AnalysisContextImpl) {
+          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(
       String path, ContextInfo info, Folder folder) {
     // Check to see if this is the .packages file for this context and if so,
     // update the context's source factory.
     if (absolutePathContext.basename(path) == PACKAGE_SPEC_NAME) {
       String contextRoot = info.folder.path;
@@ skipping 925 matching lines @@
     }
     return _embedderLocator;
   }
 
   @override
   SdkExtensionFinder getSdkExtensionFinder(ResourceProvider resourceProvider) {
     return _sdkExtensionFinder ??=
         new SdkExtensionFinder(buildPackageMap(resourceProvider));
   }
 }