Move embedder locator and convert context builder to use the new API

pkg/analyzer/lib/src/context/builder.dart

 // Copyright (c) 2016, 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 analyzer.src.context.context_builder;
 
 import 'dart:collection';
 import 'dart:core' hide Resource;
 import 'dart:io' as io;
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
-import 'package:analyzer/source/embedder.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/source/sdk_ext.dart';
+import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/task/options.dart';
 import 'package:package_config/discovery.dart';
 import 'package:package_config/packages.dart';
 import 'package:package_config/packages_file.dart';
@@ skipping 175 matching lines @@
     }
     return findPackagesFromFile(new Uri.directory(rootDirectoryPath));
   }
 
   SourceFactory createSourceFactory(
       String rootDirectoryPath, AnalysisOptions options) {
     Folder _folder = null;
     Folder folder() {
       return _folder ??= resourceProvider.getResource('.');
     }
+
     UriResolver fileResolver = fileResolverProvider == null
         ? new ResourceUriResolver(resourceProvider)
         : fileResolverProvider(folder());
     if (packageResolverProvider != null) {
       UriResolver packageResolver = packageResolverProvider(folder());
       if (packageResolver != null) {
         // TODO(brianwilkerson) This doesn't support either embedder files or
         // sdk extensions because we don't have a way to get the package map
         // from the resolver.
         List<UriResolver> resolvers = <UriResolver>[
@@ skipping 34 matching lines @@
    */
   DartSdk findSdk(
       Map<String, List<Folder>> packageMap, AnalysisOptions options) {
     if (packageMap != null) {
       // TODO(brianwilkerson) Fix it so that we don't have to create a resolver
       // to figure out what the extensions are.
       SdkExtUriResolver extResolver = new SdkExtUriResolver(packageMap);
       List<String> extFilePaths = extResolver.extensionFilePaths;
       EmbedderYamlLocator locator = new EmbedderYamlLocator(packageMap);
       Map<Folder, YamlMap> embedderYamls = locator.embedderYamls;
-      EmbedderSdk embedderSdk = new EmbedderSdk(embedderYamls);
+      EmbedderSdk embedderSdk =
+          new EmbedderSdk(resourceProvider, embedderYamls);
       if (embedderSdk.sdkLibraries.length > 0) {
         //
         // There is an embedder file that defines the content of the SDK and
         // there might be an extension file that extends it.
         //
         List<String> paths = <String>[];
         for (Folder folder in embedderYamls.keys) {
           paths.add(folder
               .getChildAssumingFile(EmbedderYamlLocator.EMBEDDER_FILE_NAME)
               .path);
@@ skipping 72 matching lines @@
       }
       file = folder
           .getChildAssumingFile(AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
       if (file.exists) {
         return file;
       }
     }
     return null;
   }
 }
+
+/**
+ * Given a package map, check in each package's lib directory for the existence
+ * of an `_embedder.yaml` file. If the file contains a top level YamlMap, it
+ * will be added to the [embedderYamls] map.
+ */
+class EmbedderYamlLocator {
+  /**
+   * The name of the embedder files being searched for.
+   */
+  static const String EMBEDDER_FILE_NAME = '_embedder.yaml';
+
+  /**
+   * A mapping from a package's library directory to the parsed YamlMap.
+   */
+  final Map<Folder, YamlMap> embedderYamls = new HashMap<Folder, YamlMap>();
+
+  /**
+   * Initialize a newly created locator by processing the packages in the given
+   * [packageMap].
+   */
+  EmbedderYamlLocator(Map<String, List<Folder>> packageMap) {
+    if (packageMap != null) {
+      _processPackageMap(packageMap);
+    }
+  }
+
+  /**
+   * Programatically add an `_embedder.yaml` mapping.
+   */
+  void addEmbedderYaml(Folder libDir, String embedderYaml) {
+    _processEmbedderYaml(libDir, embedderYaml);
+  }
+
+  /**
+   * Refresh the map of located files to those found by processing the given
+   * [packageMap].
+   */
+  void refresh(Map<String, List<Folder>> packageMap) {
+    // Clear existing.
+    embedderYamls.clear();
+    if (packageMap != null) {
+      _processPackageMap(packageMap);
+    }
+  }
+
+  /**
+   * Given the yaml for an embedder ([embedderYaml]) and a folder ([libDir]),
+   * setup the uri mapping.
+   */
+  void _processEmbedderYaml(Folder libDir, String embedderYaml) {
+    try {
+      YamlNode yaml = loadYaml(embedderYaml);
+      if (yaml is YamlMap) {
+        embedderYamls[libDir] = yaml;
+      }
+    } catch (_) {
+      // Ignored
+    }
+  }
+
+  /**
+   * Given a package [name] and a list of folders ([libDirs]), process any
+   * `_embedder.yaml` files that are found in any of the folders.
+   */
+  void _processPackage(String name, List<Folder> libDirs) {
+    for (Folder libDir in libDirs) {
+      String embedderYaml = _readEmbedderYaml(libDir);
+      if (embedderYaml != null) {
+        _processEmbedderYaml(libDir, embedderYaml);
+      }
+    }
+  }
+
+  /**
+   * Process each of the entries in the [packageMap].
+   */
+  void _processPackageMap(Map<String, List<Folder>> packageMap) {
+    packageMap.forEach(_processPackage);
+  }
+
+  /**
+   * Read and return the contents of [libDir]/[EMBEDDER_FILE_NAME], or `null` if
+   * the file doesn't exist.
+   */
+  String _readEmbedderYaml(Folder libDir) {
+    File file = libDir.getChild(EMBEDDER_FILE_NAME);
+    try {
+      return file.readAsStringSync();
+    } on FileSystemException {
+      // File can't be read.
+      return null;
+    }
+  }
+}