Use curly_braces_in_flow_control_structures for services, scheduler, semantics (#104616)

Author: guidezpl

packages/flutter/lib/src/scheduler/binding.dart

@@ -25,8 +25,9 @@ double _timeDilation = 1.0;
 /// It is safe to set this before initializing the binding.
 set timeDilation(double value) {
   assert(value > 0.0);
-  if (_timeDilation == value)
+  if (_timeDilation == value) {
     return;
+  }
   // If the binding has been created, we need to resetEpoch first so that we
   // capture start of the epoch with the current time dilation.
   SchedulerBinding._instance?.resetEpoch();
@@ -409,16 +410,18 @@ mixin SchedulerBinding on BindingBase {
       flow,
     );
     _taskQueue.add(entry);
-    if (isFirstTask && !locked)
+    if (isFirstTask && !locked) {
       _ensureEventLoopCallback();
+    }
     return entry.completer.future;
   }
 
   @override
   void unlocked() {
     super.unlocked();
-    if (_taskQueue.isNotEmpty)
+    if (_taskQueue.isNotEmpty) {
       _ensureEventLoopCallback();
+    }
   }
 
   // Whether this scheduler already requested to be called from the event loop.
@@ -429,17 +432,19 @@ mixin SchedulerBinding on BindingBase {
   void _ensureEventLoopCallback() {
     assert(!locked);
     assert(_taskQueue.isNotEmpty);
-    if (_hasRequestedAnEventLoopCallback)
+    if (_hasRequestedAnEventLoopCallback) {
       return;
+    }
     _hasRequestedAnEventLoopCallback = true;
     Timer.run(_runTasks);
   }
 
   // Scheduled by _ensureEventLoopCallback.
   void _runTasks() {
     _hasRequestedAnEventLoopCallback = false;
-    if (handleEventLoopCallback())
-      _ensureEventLoopCallback(); // runs next task when there's time
+    if (handleEventLoopCallback()) {
+      _ensureEventLoopCallback();
+    } // runs next task when there's time
   }
 
   /// Execute the highest-priority task, if it is of a high enough priority.
@@ -455,8 +460,9 @@ mixin SchedulerBinding on BindingBase {
   @visibleForTesting
   @pragma('vm:notify-debugger-on-exception')
   bool handleEventLoopCallback() {
-    if (_taskQueue.isEmpty || locked)
+    if (_taskQueue.isEmpty || locked) {
       return false;
+    }
     final _TaskEntry<dynamic> entry = _taskQueue.first;
     if (schedulingStrategy(priority: entry.priority, scheduler: this)) {
       try {
@@ -690,8 +696,9 @@ mixin SchedulerBinding on BindingBase {
   /// off.
   Future<void> get endOfFrame {
     if (_nextFrameCompleter == null) {
-      if (schedulerPhase == SchedulerPhase.idle)
+      if (schedulerPhase == SchedulerPhase.idle) {
         scheduleFrame();
+      }
       _nextFrameCompleter = Completer<void>();
       addPostFrameCallback((Duration timeStamp) {
         _nextFrameCompleter!.complete();
@@ -716,11 +723,13 @@ mixin SchedulerBinding on BindingBase {
 
   bool _framesEnabled = true;
   void _setFramesEnabledState(bool enabled) {
-    if (_framesEnabled == enabled)
+    if (_framesEnabled == enabled) {
       return;
+    }
     _framesEnabled = enabled;
-    if (enabled)
+    if (enabled) {
       scheduleFrame();
+    }
   }
 
   /// Ensures callbacks for [PlatformDispatcher.onBeginFrame] and
@@ -785,11 +794,13 @@ mixin SchedulerBinding on BindingBase {
   ///  * [scheduleWarmUpFrame], which ignores the "Vsync" signal entirely and
   ///    triggers a frame immediately.
   void scheduleFrame() {
-    if (_hasScheduledFrame || !framesEnabled)
+    if (_hasScheduledFrame || !framesEnabled) {
       return;
+    }
     assert(() {
-      if (debugPrintScheduleFrameStacks)
+      if (debugPrintScheduleFrameStacks) {
         debugPrintStack(label: 'scheduleFrame() called. Current phase is $schedulerPhase.');
+      }
       return true;
     }());
     ensureFrameCallbacksRegistered();
@@ -818,11 +829,13 @@ mixin SchedulerBinding on BindingBase {
   /// Consider using [scheduleWarmUpFrame] instead if the goal is to update the
   /// rendering as soon as possible (e.g. at application startup).
   void scheduleForcedFrame() {
-    if (_hasScheduledFrame)
+    if (_hasScheduledFrame) {
       return;
+    }
     assert(() {
-      if (debugPrintScheduleFrameStacks)
+      if (debugPrintScheduleFrameStacks) {
         debugPrintStack(label: 'scheduleForcedFrame() called. Current phase is $schedulerPhase.');
+      }
       return true;
     }());
     ensureFrameCallbacksRegistered();
@@ -848,8 +861,9 @@ mixin SchedulerBinding on BindingBase {
   ///
   /// Prefer [scheduleFrame] to update the display in normal operation.
   void scheduleWarmUpFrame() {
-    if (_warmUpFrame || schedulerPhase != SchedulerPhase.idle)
+    if (_warmUpFrame || schedulerPhase != SchedulerPhase.idle) {
       return;
+    }
 
     _warmUpFrame = true;
     final TimelineTask timelineTask = TimelineTask()..start('Warm-up frame');
@@ -872,8 +886,9 @@ mixin SchedulerBinding on BindingBase {
       // then skipping every frame and finishing in the new time.
       resetEpoch();
       _warmUpFrame = false;
-      if (hadScheduledFrame)
+      if (hadScheduledFrame) {
         scheduleFrame();
+      }
     });
 
     // Lock events so touch events etc don't insert themselves until the
@@ -1026,8 +1041,9 @@ mixin SchedulerBinding on BindingBase {
     _frameTimelineTask?.start('Frame');
     _firstRawTimeStampInEpoch ??= rawTimeStamp;
     _currentFrameTimeStamp = _adjustForEpoch(rawTimeStamp ?? _lastRawTimeStamp);
-    if (rawTimeStamp != null)
+    if (rawTimeStamp != null) {
       _lastRawTimeStamp = rawTimeStamp;
+    }
 
     assert(() {
       _debugFrameNumber += 1;
@@ -1040,8 +1056,9 @@ mixin SchedulerBinding on BindingBase {
           frameTimeStampDescription.write('(warm-up frame)');
         }
         _debugBanner = '▄▄▄▄▄▄▄▄ Frame ${_debugFrameNumber.toString().padRight(7)}   ${frameTimeStampDescription.toString().padLeft(18)} ▄▄▄▄▄▄▄▄';
-        if (debugPrintBeginFrameBanner)
+        if (debugPrintBeginFrameBanner) {
           debugPrint(_debugBanner);
+        }
       }
       return true;
     }());
@@ -1055,8 +1072,9 @@ mixin SchedulerBinding on BindingBase {
       final Map<int, _FrameCallbackEntry> callbacks = _transientCallbacks;
       _transientCallbacks = <int, _FrameCallbackEntry>{};
       callbacks.forEach((int id, _FrameCallbackEntry callbackEntry) {
-        if (!_removedIds.contains(id))
+        if (!_removedIds.contains(id)) {
           _invokeFrameCallback(callbackEntry.callback, _currentFrameTimeStamp!, callbackEntry.debugStack);
+        }
       });
       _removedIds.clear();
     } finally {
@@ -1079,22 +1097,25 @@ mixin SchedulerBinding on BindingBase {
     try {
       // PERSISTENT FRAME CALLBACKS
       _schedulerPhase = SchedulerPhase.persistentCallbacks;
-      for (final FrameCallback callback in _persistentCallbacks)
+      for (final FrameCallback callback in _persistentCallbacks) {
         _invokeFrameCallback(callback, _currentFrameTimeStamp!);
+      }
 
       // POST-FRAME CALLBACKS
       _schedulerPhase = SchedulerPhase.postFrameCallbacks;
       final List<FrameCallback> localPostFrameCallbacks =
           List<FrameCallback>.of(_postFrameCallbacks);
       _postFrameCallbacks.clear();
-      for (final FrameCallback callback in localPostFrameCallbacks)
+      for (final FrameCallback callback in localPostFrameCallbacks) {
         _invokeFrameCallback(callback, _currentFrameTimeStamp!);
+      }
     } finally {
       _schedulerPhase = SchedulerPhase.idle;
       _frameTimelineTask?.finish(); // end the Frame
       assert(() {
-        if (debugPrintEndFrameBanner)
+        if (debugPrintEndFrameBanner) {
           debugPrint('▀' * _debugBanner!.length);
+        }
         _debugBanner = null;
         return true;
       }());
@@ -1114,18 +1135,23 @@ mixin SchedulerBinding on BindingBase {
   }
 
   static void _debugDescribeTimeStamp(Duration timeStamp, StringBuffer buffer) {
-    if (timeStamp.inDays > 0)
+    if (timeStamp.inDays > 0) {
       buffer.write('${timeStamp.inDays}d ');
-    if (timeStamp.inHours > 0)
+    }
+    if (timeStamp.inHours > 0) {
       buffer.write('${timeStamp.inHours - timeStamp.inDays * Duration.hoursPerDay}h ');
-    if (timeStamp.inMinutes > 0)
+    }
+    if (timeStamp.inMinutes > 0) {
       buffer.write('${timeStamp.inMinutes - timeStamp.inHours * Duration.minutesPerHour}m ');
-    if (timeStamp.inSeconds > 0)
+    }
+    if (timeStamp.inSeconds > 0) {
       buffer.write('${timeStamp.inSeconds - timeStamp.inMinutes * Duration.secondsPerMinute}s ');
+    }
     buffer.write('${timeStamp.inMilliseconds - timeStamp.inSeconds * Duration.millisecondsPerSecond}');
     final int microseconds = timeStamp.inMicroseconds - timeStamp.inMilliseconds * Duration.microsecondsPerMillisecond;
-    if (microseconds > 0)
+    if (microseconds > 0) {
       buffer.write('.${microseconds.toString().padLeft(3, "0")}');
+    }
     buffer.write('ms');
   }
 
@@ -1175,7 +1201,8 @@ mixin SchedulerBinding on BindingBase {
 /// a [Priority] of [Priority.animation] or higher. Otherwise, runs
 /// all tasks.
 bool defaultSchedulingStrategy({ required int priority, required SchedulerBinding scheduler }) {
-  if (scheduler.transientCallbackCount > 0)
+  if (scheduler.transientCallbackCount > 0) {
     return priority >= Priority.animation.value;
+  }
   return true;
 }

packages/flutter/lib/src/scheduler/ticker.dart

@@ -88,8 +88,9 @@ class Ticker {
   /// created the [Ticker] (typically a [TickerProvider]), not the object that
   /// listens to the ticker's ticks.
   set muted(bool value) {
-    if (value == muted)
+    if (value == muted) {
       return;
+    }
     _muted = value;
     if (value) {
       unscheduleTick();
@@ -109,14 +110,18 @@ class Ticker {
   /// that indicates the application is not currently visible (e.g. if the
   /// device's screen is turned off).
   bool get isTicking {
-    if (_future == null)
+    if (_future == null) {
       return false;
-    if (muted)
+    }
+    if (muted) {
       return false;
-    if (SchedulerBinding.instance.framesEnabled)
+    }
+    if (SchedulerBinding.instance.framesEnabled) {
       return true;
-    if (SchedulerBinding.instance.schedulerPhase != SchedulerPhase.idle)
-      return true; // for example, we might be in a warm-up frame or forced frame
+    }
+    if (SchedulerBinding.instance.schedulerPhase != SchedulerPhase.idle) {
+      return true;
+    } // for example, we might be in a warm-up frame or forced frame
     return false;
   }
 
@@ -162,8 +167,9 @@ class Ticker {
       scheduleTick();
     }
     if (SchedulerBinding.instance.schedulerPhase.index > SchedulerPhase.idle.index &&
-        SchedulerBinding.instance.schedulerPhase.index < SchedulerPhase.postFrameCallbacks.index)
+        SchedulerBinding.instance.schedulerPhase.index < SchedulerPhase.postFrameCallbacks.index) {
       _startTime = SchedulerBinding.instance.currentFrameTimeStamp;
+    }
     return _future!;
   }
 
@@ -189,8 +195,9 @@ class Ticker {
   /// By convention, this method is used by the object that receives the ticks
   /// (as opposed to the [TickerProvider] which created the ticker).
   void stop({ bool canceled = false }) {
-    if (!isActive)
+    if (!isActive) {
       return;
+    }
 
     // We take the _future into a local variable so that isTicking is false
     // when we actually complete the future (isTicking uses _future to
@@ -239,8 +246,9 @@ class Ticker {
 
     // The onTick callback may have scheduled another tick already, for
     // example by calling stop then start again.
-    if (shouldScheduleTick)
+    if (shouldScheduleTick) {
       scheduleTick(rescheduling: true);
+    }
   }
 
   /// Schedules a tick for the next frame.
@@ -286,8 +294,9 @@ class Ticker {
     if (originalTicker._future != null) {
       _future = originalTicker._future;
       _startTime = originalTicker._startTime;
-      if (shouldScheduleTick)
+      if (shouldScheduleTick) {
         scheduleTick();
+      }
       originalTicker._future = null; // so that it doesn't get disposed when we dispose of originalTicker
       originalTicker.unscheduleTick();
     }
@@ -474,8 +483,9 @@ class TickerCanceled implements Exception {
 
   @override
   String toString() {
-    if (ticker != null)
+    if (ticker != null) {
       return 'This ticker was canceled: $ticker';
+    }
     return 'The ticker was canceled before the "orCancel" property was first used.';
   }
 }

packages/flutter/lib/src/semantics/binding.dart

@@ -64,8 +64,9 @@ mixin SemanticsBinding on BindingBase {
   bool get disableAnimations {
     bool value = _accessibilityFeatures.disableAnimations;
     assert(() {
-      if (debugSemanticsDisableAnimations != null)
+      if (debugSemanticsDisableAnimations != null) {
         value = debugSemanticsDisableAnimations!;
+      }
       return true;
     }());
     return value;