Take another big swing at indentation, some consts.

ClockReceiver/ClockReceiver.hpp

@@ -285,14 +285,14 @@ private:
 	automatically to gain run_for(HalfCycles).
 */
 template <class T> class HalfClockReceiver: public T {
-	public:
-		using T::T;
+public:
+	using T::T;
 
-		forceinline void run_for(const HalfCycles half_cycles) {
-			half_cycles_ += half_cycles;
-			T::run_for(half_cycles_.flush<Cycles>());
-		}
+	forceinline void run_for(const HalfCycles half_cycles) {
+		half_cycles_ += half_cycles;
+		T::run_for(half_cycles_.flush<Cycles>());
+	}
 
-	private:
-		HalfCycles half_cycles_;
+private:
+	HalfCycles half_cycles_;
 };

ClockReceiver/DeferredQueue.hpp

@@ -98,28 +98,28 @@ private:
 	This list is efficient only for short queues.
 */
 template <typename TimeUnit> class DeferredQueuePerformer: public DeferredQueue<TimeUnit> {
-	public:
-		/// Constructs a DeferredQueue that will call target(period) in between deferred actions.
-		constexpr DeferredQueuePerformer(std::function<void(TimeUnit)> &&target) : target_(std::move(target)) {}
+public:
+	/// Constructs a DeferredQueue that will call target(period) in between deferred actions.
+	constexpr DeferredQueuePerformer(std::function<void(TimeUnit)> &&target) : target_(std::move(target)) {}
 
-		/*!
-			Runs for @c length units of time.
+	/*!
+		Runs for @c length units of time.
 
-			The constructor-supplied target will be called with one or more periods that add up to @c length;
-			any scheduled actions will be called between periods.
-		*/
-		void run_for(TimeUnit length) {
-			auto time_to_next = DeferredQueue<TimeUnit>::time_until_next_action();
-			while(time_to_next != TimeUnit(-1) && time_to_next <= length) {
-				target_(time_to_next);
-				length -= time_to_next;
-				DeferredQueue<TimeUnit>::advance(time_to_next);
-			}
-
-			DeferredQueue<TimeUnit>::advance(length);
-			target_(length);
+		The constructor-supplied target will be called with one or more periods that add up to @c length;
+		any scheduled actions will be called between periods.
+	*/
+	void run_for(TimeUnit length) {
+		auto time_to_next = DeferredQueue<TimeUnit>::time_until_next_action();
+		while(time_to_next != TimeUnit(-1) && time_to_next <= length) {
+			target_(time_to_next);
+			length -= time_to_next;
+			DeferredQueue<TimeUnit>::advance(time_to_next);
 		}
 
-	private:
-		std::function<void(TimeUnit)> target_;
+		DeferredQueue<TimeUnit>::advance(length);
+		target_(length);
+	}
+
+private:
+	std::function<void(TimeUnit)> target_;
 };

ClockReceiver/VSyncPredictor.hpp

@@ -104,40 +104,40 @@ public:
 
 private:
 	class VarianceCollector {
-		public:
-			VarianceCollector(Time::Nanos default_value) {
-				sum_ = default_value * 128;
-				for(int c = 0; c < 128; ++c) {
-					history_[c] = default_value;
-				}
+	public:
+		VarianceCollector(Time::Nanos default_value) {
+			sum_ = default_value * 128;
+			for(int c = 0; c < 128; ++c) {
+				history_[c] = default_value;
 			}
+		}
 
-			void post(Time::Nanos value) {
-				sum_ -= history_[write_pointer_];
-				sum_ += value;
-				history_[write_pointer_] = value;
-				write_pointer_ = (write_pointer_ + 1) & 127;
+		void post(Time::Nanos value) {
+			sum_ -= history_[write_pointer_];
+			sum_ += value;
+			history_[write_pointer_] = value;
+			write_pointer_ = (write_pointer_ + 1) & 127;
+		}
+
+		Time::Nanos mean() {
+			return sum_ / 128;
+		}
+
+		Time::Nanos variance() {
+			// I haven't yet come up with a better solution that calculating this
+			// in whole every time, given the way that the mean mutates.
+			Time::Nanos variance = 0;
+			for(int c = 0; c < 128; ++c) {
+				const auto difference = ((history_[c] * 128) - sum_) / 128;
+				variance += (difference * difference);
 			}
+			return variance / 128;
+		}
 
-			Time::Nanos mean() {
-				return sum_ / 128;
-			}
-
-			Time::Nanos variance() {
-				// I haven't yet come up with a better solution that calculating this
-				// in whole every time, given the way that the mean mutates.
-				Time::Nanos variance = 0;
-				for(int c = 0; c < 128; ++c) {
-					const auto difference = ((history_[c] * 128) - sum_) / 128;
-					variance += (difference * difference);
-				}
-				return variance / 128;
-			}
-
-		private:
-			Time::Nanos sum_;
-			Time::Nanos history_[128];
-			size_t write_pointer_ = 0;
+	private:
+		Time::Nanos sum_;
+		Time::Nanos history_[128];
+		size_t write_pointer_ = 0;
 	};
 
 	Nanos redraw_begin_time_ = 0;