Reland "[Brightness] Fix small manual changes"

This reverts commit a2db90e3e3066a5e593d9a263f6e553e24ffaaf5.

Reason for revert: I reverted the original because the build failed after merging it. However, it now transpires that it had nothing to do with it. So, putting the original fix back in.

Original change's description:
> Revert "[Brightness] Fix small manual changes"
>
> This reverts commit cc8270a89cf8b42a6c48e38394d80779b7959362.
>
> Reason for revert: This may have caused problems with other integration tests. Investigating.
>
> Original change's description:
> > [Brightness] Fix small manual changes
> >
> > Small, manual changes that were smaller than the step size
> > for smooth changes were not performed.
> >
> > Test: New test added. Failed before fix.
> > Bug: b/178258598
> > Fixed: b/178258598
> > Change-Id: Ie0fc991ed5c15a009618e0c6660bf573e3879187
> > Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/474841
> > Commit-Queue: Kevin Twidle <kpt@google.com>
> > Reviewed-by: Lingxue Luo <lingxueluo@google.com>
>
> TBR=kpt@google.com,lingxueluo@google.com
>
> Change-Id: I9efe3b7dc6b307bf083c8bc2c8b70ed6eb712c18
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Bug: b/178258598
> Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/485749
> Reviewed-by: Kevin Twidle <kpt@google.com>
> Commit-Queue: Kevin Twidle <kpt@google.com>

Bug: b/178258598
Change-Id: I0758b59d0b828dd3d444a7e67d8c1d134a0eb9c7
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/487786
Reviewed-by: Lingxue Luo <lingxueluo@google.com>
Commit-Queue: Kevin Twidle <kpt@google.com>
diff --git a/src/ui/bin/brightness_manager/src/control.rs b/src/ui/bin/brightness_manager/src/control.rs
index a9ef61e..b13ea71 100644
--- a/src/ui/bin/brightness_manager/src/control.rs
+++ b/src/ui/bin/brightness_manager/src/control.rs
@@ -41,6 +41,7 @@
 const BRIGHTNESS_USER_MULTIPLIER_MAX: f32 = 8.0;
 const BRIGHTNESS_USER_MULTIPLIER_MIN: f32 = 0.25;
 const BRIGHTNESS_TABLE_FILE_PATH: &str = "/data/brightness_table";
+const BRIGHTNESS_MINIMUM_CHANGE: f32 = 0.00001;
 
 // Gives pleasing, smooth brightness ramp up and down
 const BRIGHTNESS_STEP_SIZE: f32 = 0.001;
@@ -493,7 +494,7 @@
     }
 }
 
-#[async_trait(?Send)]
+#[async_trait(? Send)]
 pub trait ControlTrait {
     async fn handle_request(
         &mut self,
@@ -508,7 +509,7 @@
     fn get_backlight_and_auto_brightness_on(&mut self) -> (Arc<Mutex<dyn BacklightControl>>, bool);
 }
 
-#[async_trait(?Send)]
+#[async_trait(? Send)]
 impl ControlTrait for Control {
     async fn handle_request(
         &mut self,
@@ -643,6 +644,8 @@
         )
         .detach();
         *set_brightness_abort_handle = Some(abort_handle);
+    } else if (current_value - value).abs() > BRIGHTNESS_MINIMUM_CHANGE {
+        set_brightness_impl(value, backlight, current_sender_channel).await;
     }
 }
 
@@ -707,7 +710,6 @@
 }
 
 #[cfg(test)]
-
 mod tests {
     use super::*;
 
@@ -786,8 +788,8 @@
         (sensor, backlight)
     }
 
-    async fn generate_control_struct() -> Control {
-        let (sensor, backlight) = set_mocks(400, 0.5);
+    async fn generate_control_struct(sensor: u16, backlight: f64) -> Control {
+        let (sensor, backlight) = set_mocks(sensor, backlight);
         let set_brightness_abort_handle = Arc::new(Mutex::new(None::<AbortHandle>));
         let auto_brightness_abort_handle = None::<AbortHandle>;
         let BrightnessTable { points } = &*BRIGHTNESS_TABLE.lock().await;
@@ -852,7 +854,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_brightness_table_valid() {
-        let mut control = generate_control_struct().await;
+        let mut control = generate_control_struct(400, 0.5).await;
         let brightness_table = {
             let mut lux_to_nits = Vec::new();
             lux_to_nits.push(BrightnessPoint { ambient_lux: 10., display_nits: 50. });
@@ -881,7 +883,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_brightness_table_not_valid_negative_value() {
-        let mut control = generate_control_struct().await;
+        let mut control = generate_control_struct(400, 0.5).await;
         let brightness_table = {
             let mut lux_to_nits = Vec::new();
             lux_to_nits.push(BrightnessPoint { ambient_lux: -10., display_nits: 50. });
@@ -893,7 +895,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_brightness_table_not_valid_lux_not_increasing() {
-        let mut control = generate_control_struct().await;
+        let mut control = generate_control_struct(400, 0.5).await;
         let brightness_table = {
             let mut lux_to_nits = Vec::new();
             lux_to_nits.push(BrightnessPoint { ambient_lux: 10., display_nits: 50. });
@@ -907,7 +909,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_brightness_table_valid_but_empty() {
-        let mut control = generate_control_struct().await;
+        let mut control = generate_control_struct(400, 0.5).await;
         let brightness_table = {
             let lux_to_nits = Vec::new();
             BrightnessTable { points: lux_to_nits }
@@ -917,77 +919,77 @@
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(0, old_curve).await,
-                brightness_curve_lux_to_nits(0, &control.spline).await
+                brightness_curve_lux_to_nits(0, &control.spline).await,
             ),
             true
         );
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(1, old_curve).await,
-                brightness_curve_lux_to_nits(1, &control.spline).await
+                brightness_curve_lux_to_nits(1, &control.spline).await,
             ),
             true
         );
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(2, old_curve).await,
-                brightness_curve_lux_to_nits(2, &control.spline).await
+                brightness_curve_lux_to_nits(2, &control.spline).await,
             ),
             true
         );
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(15, old_curve).await,
-                brightness_curve_lux_to_nits(15, &control.spline).await
+                brightness_curve_lux_to_nits(15, &control.spline).await,
             ),
             true
         );
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(16, old_curve).await,
-                brightness_curve_lux_to_nits(16, &control.spline).await
+                brightness_curve_lux_to_nits(16, &control.spline).await,
             ),
             true
         );
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(100, old_curve).await,
-                brightness_curve_lux_to_nits(100, &control.spline).await
+                brightness_curve_lux_to_nits(100, &control.spline).await,
             ),
             true
         );
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(150, old_curve).await,
-                brightness_curve_lux_to_nits(150, &control.spline).await
+                brightness_curve_lux_to_nits(150, &control.spline).await,
             ),
             true
         );
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(200, old_curve).await,
-                brightness_curve_lux_to_nits(200, &control.spline).await
+                brightness_curve_lux_to_nits(200, &control.spline).await,
             ),
             true
         );
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(240, old_curve).await,
-                brightness_curve_lux_to_nits(240, &control.spline).await
+                brightness_curve_lux_to_nits(240, &control.spline).await,
             ),
             true
         );
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(300, old_curve).await,
-                brightness_curve_lux_to_nits(300, &control.spline).await
+                brightness_curve_lux_to_nits(300, &control.spline).await,
             ),
             true
         );
         assert_eq!(
             cmp_float(
                 brightness_curve_lux_to_nits(340, old_curve).await,
-                brightness_curve_lux_to_nits(340, &control.spline).await
+                brightness_curve_lux_to_nits(340, &control.spline).await,
             ),
             true
         );
@@ -995,7 +997,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_scale_new_adjustment() {
-        let mut control = generate_control_struct().await;
+        let mut control = generate_control_struct(400, 0.5).await;
         let mut new_adjust = control.scale_new_adjustment(-1.0).await;
         assert_eq!(0.25, new_adjust);
         new_adjust = control.scale_new_adjustment(1.0).await;
@@ -1006,7 +1008,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_set_brightness_slowly_send_value() {
-        let control = generate_control_struct().await;
+        let control = generate_control_struct(400, 0.5).await;
         let (channel_sender, mut channel_receiver) = futures::channel::mpsc::unbounded::<f32>();
         control.current_sender_channel.lock().await.add_sender_channel(channel_sender).await;
         let set_brightness = |_| {};
@@ -1035,7 +1037,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_set_brightness_slowly_in_range() {
-        let control = generate_control_struct().await;
+        let control = generate_control_struct(400, 0.5).await;
         let mut result = Vec::new();
         let set_brightness = |nits| {
             result.push(nits as f32);
@@ -1059,7 +1061,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_set_brightness_slowly_min() {
-        let control = generate_control_struct().await;
+        let control = generate_control_struct(400, 0.5).await;
         let mut result = Vec::new();
         let set_brightness = |nits| {
             result.push(nits as f32);
@@ -1083,7 +1085,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_set_brightness_slowly_max() {
-        let control = generate_control_struct().await;
+        let control = generate_control_struct(400, 0.5).await;
         let mut result = Vec::new();
         let set_brightness = |nits| {
             result.push(nits as f32);
@@ -1127,7 +1129,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_set_brightness_is_abortable_with_auto_brightness_on() {
-        let control = generate_control_struct().await;
+        let control = generate_control_struct(400, 0.5).await;
         let set_brightness_abort_handle = Arc::new(Mutex::new(None::<AbortHandle>));
         let (_sensor, backlight) = set_mocks(0, 0.0);
         let backlight = backlight.clone();
@@ -1153,7 +1155,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_set_brightness_impl() {
-        let control = generate_control_struct().await;
+        let control = generate_control_struct(400, 0.5).await;
         let (_sensor, backlight) = set_mocks(0, 0.0);
         let backlight_clone = backlight.clone();
         set_brightness_impl(0.3, backlight_clone, control.current_sender_channel).await;
@@ -1163,7 +1165,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_brightness_manager_fail_gracefully() {
-        let control = generate_control_struct().await;
+        let control = generate_control_struct(400, 0.5).await;
         let (_sensor, backlight) = set_mocks_not_valid(0, 0.0);
         {
             let last_set_brightness = &*LAST_SET_BRIGHTNESS.lock().await;
@@ -1177,7 +1179,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_store_brightness_table() -> Result<(), Error> {
-        let mut control = generate_control_struct().await;
+        let mut control = generate_control_struct(400, 0.5).await;
         let brightness_table = BrightnessTable {
             points: vec![
                 BrightnessPoint { ambient_lux: 10., display_nits: 50. },
@@ -1223,7 +1225,7 @@
 
     #[fasync::run_singlethreaded(test)]
     async fn test_set_manual_brightness_smooth_with_duration_got_set() {
-        let mut control = generate_control_struct().await;
+        let mut control = generate_control_struct(400, 0.5).await;
         control.set_manual_brightness_smooth(0.6, 4000000000).await;
         let duration = *BRIGHTNESS_CHANGE_DURATION.lock().await;
         assert_eq!(4000, duration.into_millis());
@@ -1233,7 +1235,7 @@
     fn test_set_manual_brightness_updates_brightness() {
         let mut exec = fasync::Executor::new().unwrap();
 
-        let func_fut1 = generate_control_struct();
+        let func_fut1 = generate_control_struct(400, 0.5);
         futures::pin_mut!(func_fut1);
         let mut control = exec.run_singlethreaded(&mut func_fut1);
         {
@@ -1251,9 +1253,36 @@
         assert_eq!(cmp_float(0.6, value.unwrap() as f32), true);
     }
 
+    #[test]
+    fn test_set_manual_brightness_updates_brightness_small_change() {
+        const TARGET_BRIGHTNESS: f32 = 0.0006;
+        const ORIGINAL_BRIGHTNESS: f32 = 0.001;
+        assert!((TARGET_BRIGHTNESS - ORIGINAL_BRIGHTNESS).abs() < BRIGHTNESS_STEP_SIZE);
+        assert!((TARGET_BRIGHTNESS - ORIGINAL_BRIGHTNESS).abs() > BRIGHTNESS_MINIMUM_CHANGE);
+
+        let mut exec = fasync::Executor::new().unwrap();
+        let func_fut1 = generate_control_struct(400, ORIGINAL_BRIGHTNESS as f64);
+        futures::pin_mut!(func_fut1);
+        let mut control = exec.run_singlethreaded(&mut func_fut1);
+        {
+            let func_fut2 = control.set_manual_brightness_smooth(0.0006, 4000);
+            futures::pin_mut!(func_fut2);
+            exec.run_singlethreaded(&mut func_fut2);
+        }
+        let _ = exec.run_until_stalled(&mut future::pending::<()>());
+        let func_fut3 = control.backlight.lock();
+        futures::pin_mut!(func_fut3);
+        let backlight = exec.run_singlethreaded(&mut func_fut3);
+        let func_fut4 = backlight.get_brightness();
+        futures::pin_mut!(func_fut4);
+        let value = exec.run_singlethreaded(&mut func_fut4);
+        let brightness_value = value.unwrap() as f32;
+        assert_eq!(TARGET_BRIGHTNESS, brightness_value);
+    }
+
     #[fasync::run_singlethreaded(test)]
     async fn test_get_max_absolute_brightness() {
-        let mut control = generate_control_struct().await;
+        let mut control = generate_control_struct(400, 0.5).await;
         let max_brightness = control.get_max_absolute_brightness().await;
         assert_eq!(250.0, max_brightness.unwrap());
     }