Initial work on refactorings.

pkg/analysis_services/lib/src/refactoring/progress_monitor.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.
+
+// This code was auto-generated, is not intended to be edited, and is subject to
+// significant change. Please see the README file for more information.
+
+library services.src.refactoring.progress_monitor;
+
+import 'package:analysis_services/refactoring/progress_monitor.dart';
+
+
+/**
+ * A [ProgressMonitor] which represents a part of a bigger [ProgressMonitor].
+ */
+class SubProgressMonitor implements ProgressMonitor {
+  final ProgressMonitor _parent;
+  final int _parentTicks;
+
+  int _nestedBeginTasks = 0;
+
+  double _scale = 0.0;
+
+  int _sentToParent = 0;
+
+  bool _usedUp = false;
+
+  bool _hasSubTask = false;
+
+  SubProgressMonitor(this._parent, this._parentTicks);
+
+  @override
+  bool get isCanceled => _parent.isCanceled;
+
+  @override
+  void beginTask(String name, int totalWork) {
+    _nestedBeginTasks++;
+    // ignore nested begin task calls
+    if (_nestedBeginTasks > 1) {
+      return;
+    }
+    // prepare scale to convert this PM to parent PM
+    _scale = totalWork <= 0 ? 0.0 : _parentTicks / totalWork;
+    _sentToParent = 0;
+    _usedUp = false;
+  }
+
+  @override
+  void done() {
+    // ignore if already done
+    if (_nestedBeginTasks == 0 || --_nestedBeginTasks > 0) {
+      return;
+    }
+    // send any remaining ticks
+    double remaining = (_parentTicks - _sentToParent).toDouble();
+    if (remaining > 0) {
+      _parent.internalWorked(remaining);
+    }
+    // clear the sub task if there was one
+    if (_hasSubTask) {
+      _parent.subTask("");
+    }
+  }
+
+  @override
+  void internalWorked(double work) {
+    // may be ignore
+    if (_usedUp || _nestedBeginTasks != 1) {
+      return;
+    }
+    // send to parent
+    double parentWork = work > 0.0 ? _scale * work : 0.0;
+    _parent.internalWorked(parentWork);
+    _sentToParent += parentWork;
+    // may be used up
+    if (_sentToParent >= _parentTicks) {
+      _usedUp = true;
+    }
+  }
+
+  @override
+  void setCanceled() {
+    _parent.setCanceled();
+  }
+
+  @override
+  void subTask(String name) {
+    _hasSubTask = true;
+    _parent.subTask(name);
+  }
+
+  @override
+  void worked(int work) {
+    double workDouble = work.toDouble();
+    internalWorked(workDouble);
+  }
+}