Deprecate DirectoryBasedDartSdk and transition existing uses to the new API

pkg/analyzer/test/stress/for_git_repository.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.test.stress.limited_invalidation;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/file_system/file_system.dart' as fs;
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/src/context/builder.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/member.dart';
+import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.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/utilities_collection.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:path/path.dart' as path;
 import 'package:unittest/unittest.dart';
 
 main() {
   new StressTest().run();
@@ skipping 58 matching lines @@
   }
 
   FolderDiff diff(FolderInfo oldFolder) {
     Map<String, FileInfo> toMap(FolderInfo folder) {
       Map<String, FileInfo> map = <String, FileInfo>{};
       folder.files.forEach((file) {
         map[file.path] = file;
       });
       return map;
     }
+
     Map<String, FileInfo> newFiles = toMap(this);
     Map<String, FileInfo> oldFiles = toMap(oldFolder);
     Set<String> addedPaths = newFiles.keys.toSet()..removeAll(oldFiles.keys);
     Set<String> removedPaths = oldFiles.keys.toSet()..removeAll(newFiles.keys);
     List<String> changedPaths = <String>[];
     newFiles.forEach((path, newFile) {
       FileInfo oldFile = oldFiles[path];
       if (oldFile != null && oldFile.modification != newFile.modification) {
         changedPaths.add(path);
       }
@@ skipping 122 matching lines @@
   AnalysisContextImpl expectedContext;
   AnalysisContextImpl actualContext;
 
   Set<Element> currentRevisionValidatedElements = new Set<Element>();
 
   void createContexts() {
     assert(expectedContext == null);
     assert(actualContext == null);
     resourceProvider = PhysicalResourceProvider.INSTANCE;
     pathContext = resourceProvider.pathContext;
-    sdkManager = new DartSdkManager(
-        DirectoryBasedDartSdk.defaultSdkDirectory.getAbsolutePath(),
-        false,
-        (_) => DirectoryBasedDartSdk.defaultSdk);
+    fs.Folder sdkDirectory =
+        FolderBasedDartSdk.defaultSdkDirectory(resourceProvider);
+    sdkManager = new DartSdkManager(sdkDirectory.path, false,
+        (_) => new FolderBasedDartSdk(resourceProvider, sdkDirectory));
     contentCache = new ContentCache();
     ContextBuilder builder =
         new ContextBuilder(resourceProvider, sdkManager, contentCache);
     builder.defaultOptions = new AnalysisOptionsImpl();
     expectedContext = builder.buildContext(folderPath);
     actualContext = builder.buildContext(folderPath);
     expectedContext.analysisOptions =
         new AnalysisOptionsImpl.from(expectedContext.analysisOptions)
           ..incremental = true;
     actualContext.analysisOptions =
@@ skipping 144 matching lines @@
     List<Element> sortElements(List<Element> elements) {
       elements = elements.toList();
       elements.sort((a, b) {
         if (a.nameOffset != b.nameOffset) {
           return a.nameOffset - b.nameOffset;
         }
         return a.name.compareTo(b.name);
       });
       return elements;
     }
+
     void validateSortedElements(
         List<Element> actualElements, List<Element> expectedElements) {
       expect(actualElements, hasLength(expectedElements.length));
       actualElements = sortElements(actualElements);
       expectedElements = sortElements(expectedElements);
       for (int i = 0; i < expectedElements.length; i++) {
         _validateElements(actualElements[i], expectedElements[i], visited);
       }
     }
+
     expect(actualValue?.runtimeType, expectedValue?.runtimeType);
     expect(actualValue.nameOffset, expectedValue.nameOffset);
     expect(actualValue.name, expectedValue.name);
     if (expectedValue is ClassElement) {
       var actualElement = actualValue as ClassElement;
       validateSortedElements(actualElement.accessors, expectedValue.accessors);
       validateSortedElements(
           actualElement.constructors, expectedValue.constructors);
       validateSortedElements(actualElement.fields, expectedValue.fields);
       validateSortedElements(actualElement.methods, expectedValue.methods);
@@ skipping 194 matching lines @@
             pairwiseCompare(expectedArguments, (a, b) {
               _verifyTypes(a, b, '$desc typeArguments');
               return true;
             }, 'elements'));
       } else {
         _failTypeMismatch(actual, expected);
       }
     }
   }
 }