Add BuildBotClient to abstract http/logdog access

tools/gardening/bin/find_timeouts.dart

 // Copyright (c) 2017, 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.
 
 /// Scans past dart2js-windows test steps for timeouts and reports the
 /// frequency of each test that has timed out.
 
 import 'dart:async';
 import 'dart:io';
 import 'package:args/args.dart';
 import 'package:gardening/src/buildbot_data.dart';
 import 'package:gardening/src/buildbot_loading.dart';
 import 'package:gardening/src/buildbot_structures.dart';
+import 'package:gardening/src/client.dart';
 import 'package:gardening/src/logdog.dart' as logdog;
 import 'package:gardening/src/util.dart';
 
 main(List<String> args) async {
   ArgParser argParser = createArgParser();
-  argParser.addFlag('logdog',
-      negatable: false, help: "Pull test results from logdog.");
   argParser.addOption('start',
       defaultsTo: '-2',
       help: "Start pulling from the specified <build-number>.\n"
           "Use negative numbers for the most recent builds;\n"
           "for instance -2 for the second-to-last build.'");
   ArgResults argResults = argParser.parse(args);
   processArgResults(argResults);
+
+  BuildbotClient client = argResults['logdog']
+      ? new LogdogBuildbotClient()
+      : new HttpBuildbotClient();
+
   List<String> arguments = argResults.rest;
   if (arguments.length > 1) {
     print('Usage: find_timeouts.dart [options] [<count>]');
     print('Where <count> is the number of old builds that are scanned');
     print('and options are:');
     print(argParser.usage);
     exit(1);
   }
   int buildNumberCount = 10;
   if (arguments.length > 0) {
     buildNumberCount = int.parse(arguments[0]);
   }
-  int buildNumberOffset = int.parse(argResults['start']);
+  int buildNumberOffset;
+  if (argResults.wasParsed('start')) {
+    buildNumberOffset = int.parse(argResults['start']);
+  } else {
+    buildNumberOffset = client.mostRecentBuildNumber;
+  }
 
-  bool useLogDog = argResults['logdog'];
-
-  HttpClient client = new HttpClient();
   BuildGroup group =
       buildGroups.firstWhere((g) => g.groupName == 'dart2js-windows');
   Map<String, List<Timeout>> timeouts = <String, List<Timeout>>{};
   for (BuildSubgroup subgroup in group.subgroups) {
-    if (useLogDog) {
-      await readLogDogResults(subgroup, timeouts,
-          buildNumberOffset: buildNumberOffset,
-          buildNumberCount: buildNumberCount);
-    } else {
-      await readBuildBotResults(client, subgroup, timeouts,
-          buildNumberOffset: buildNumberOffset,
-          buildNumberCount: buildNumberCount);
-    }
+    await readBuildBotResults(client, subgroup, timeouts,
+        buildNumberOffset: buildNumberOffset,
+        buildNumberCount: buildNumberCount);
   }
 
   List<String> sorted = timeouts.keys.toList()
     ..sort((a, b) {
       return -timeouts[a].length.compareTo(timeouts[b].length);
     });
 
   sorted.forEach((String testName) {
     List<Timeout> list = timeouts[testName];
     print('${padLeft('${list.length}', 4)} $testName');
     for (Timeout timeout in list) {
       print('     - ${timeout.buildUri.botName}/${timeout.buildUri.stepName} '
           '${timeout.timeout.id} (${timeout.buildNumber})');
     }
   });
 
   client.close();
 }
 
 Future readLogDogResults(
     BuildSubgroup subgroup, Map<String, List<Timeout>> timeouts,
     {int buildNumberOffset, int buildNumberCount}) async {
   Map<String, String> subgroupPaths = subgroup.logDogPaths;
   for (String shardName in subgroupPaths.keys) {
     String subgroupPath = subgroupPaths[shardName];
     List<int> buildNumbers = <int>[];
-    for (String line in logdog.ls(subgroupPath).split('\n')) {
+    String text = await logdog.ls(subgroupPath);
+    for (String line in text.split('\n')) {
       line = line.trim();
       if (line.isNotEmpty) {
         buildNumbers.add(int.parse(line));
       }
     }
     buildNumbers.sort((a, b) => -a.compareTo(b));
     int buildNumberIndex;
     if (buildNumberOffset < 0) {
       buildNumberIndex = -buildNumberOffset - 1;
     } else {
@@ skipping 10 matching lines @@
             timeouts.putIfAbsent(timeout.id.testName, () => <Timeout>[]).add(
                 new Timeout(subgroup, result.buildNumber, buildUri, timeout));
           }
           buildUri = buildUri.prev();
         }
       }
     }
   }
 }
 
-Future readBuildBotResults(HttpClient client, BuildSubgroup subgroup,
+Future readBuildBotResults(BuildbotClient client, BuildSubgroup subgroup,
     Map<String, List<Timeout>> timeouts,
     {int buildNumberOffset, int buildNumberCount}) async {
   List<BuildUri> buildUris = subgroup.createUris(buildNumberOffset);
   for (BuildUri buildUri in buildUris) {
     for (int i = 0; i < buildNumberCount; i++) {
-      BuildResult result = await readBuildResult(client, buildUri);
+      BuildResult result = await client.readResult(buildUri);
       for (TestFailure timeout in result.timeouts) {
         timeouts
             .putIfAbsent(timeout.id.testName, () => <Timeout>[])
             .add(new Timeout(subgroup, result.buildNumber, buildUri, timeout));
       }
       buildUri = result.buildUri.prev();
     }
   }
 }
 
 class Timeout {
   final BuildSubgroup subgroup;
   final int buildNumber;
   final BuildUri buildUri;
   final TestFailure timeout;
 
   Timeout(this.subgroup, this.buildNumber, this.buildUri, this.timeout);
 }