[CCA] Makes window states not mutually exclusive

Originally we thought the window states: {minimized, maximized,
fullscreen, regular} are mutually exclusive. However, when under tablet
mode, there are only two states: {minimized,
maximized/fullscreen/regular}.

Therefore, since the assumption is not valid under tablet mode, we
should change the logic in CameraAppWindowStateController to make it
works under tablet mode as well.

Bug: b/172780736
Test: tast run [DUT] camera.CCAUI*.swa
Change-Id: I2bcf472e78af3065f9c754024141e2275b7bc710
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2583670Reviewed-by: Robert Sesek <rsesek@chromium.org>
Reviewed-by: Inker Kuo <inker@chromium.org>
Commit-Queue: Wei Lee <wtlee@chromium.org>
Cr-Commit-Position: refs/heads/master@{#838007}

chromeos/components/camera_app_ui/camera_app_helper.mojom

@@ -52,20 +52,20 @@ enum WindowStateType {
   REGULAR = 3,  // None of the above.
 };
 
-// Interface for monitoring window state.
+// Interface for monitoring window states.
 interface WindowStateMonitor {
-  // Updates when the window state is changed.
-  OnWindowStateChanged(WindowStateType state);
+  // Updates when any of the window states are changed.
+  OnWindowStateChanged(array<WindowStateType> states);
 };
 
 // Interface for window controlling.
 interface WindowStateController {
   // Adds |monitor| for window state changes.
   AddMonitor(pending_remote<WindowStateMonitor> monitor)
-      => (WindowStateType state);
+      => (array<WindowStateType> states);
 
-  // Gets current |state| of the window.
-  GetWindowState() => (WindowStateType state);
+  // Gets current |states| of the window.
+  GetWindowState() => (array<WindowStateType> states);
 
   // Minimize the window.
   Minimize() => ();

chromeos/components/camera_app_ui/camera_app_window_state_controller.cc

@@ -8,9 +8,27 @@
 
 namespace chromeos {
 
+namespace {
+
+bool IsRestored(views::Widget* widget) {
+  if (ash::TabletMode::Get()->InTabletMode()) {
+    return !widget->IsMinimized();
+  }
+  return !widget->IsMinimized() && !widget->IsMaximized() &&
+         !widget->IsFullscreen();
+}
+
+std::vector<CameraAppWindowStateController::WindowStateType> ToVector(
+    const base::flat_set<CameraAppWindowStateController::WindowStateType>& s) {
+  return std::vector<CameraAppWindowStateController::WindowStateType>(s.begin(),
+                                                                      s.end());
+}
+
+}  // namespace
+
 CameraAppWindowStateController::CameraAppWindowStateController(
     views::Widget* widget)
-    : widget_(widget), window_state_(GetCurrentWindowState()) {
+    : widget_(widget), window_states_(GetCurrentWindowStates()) {
   widget_->AddObserver(this);
 }
 
@@ -30,16 +48,16 @@ void CameraAppWindowStateController::AddMonitor(
   auto remote = mojo::Remote<chromeos_camera::mojom::WindowStateMonitor>(
       std::move(monitor));
   monitors_.push_back(std::move(remote));
-  std::move(callback).Run(window_state_);
+  std::move(callback).Run(ToVector(window_states_));
 }
 
 void CameraAppWindowStateController::GetWindowState(
     GetWindowStateCallback callback) {
-  std::move(callback).Run(window_state_);
+  std::move(callback).Run(ToVector(window_states_));
 }
 
 void CameraAppWindowStateController::Minimize(MinimizeCallback callback) {
-  if (GetCurrentWindowState() == WindowStateType::MINIMIZED) {
+  if (widget_->IsMinimized()) {
     std::move(callback).Run();
     return;
   }
@@ -48,15 +66,7 @@ void CameraAppWindowStateController::Minimize(MinimizeCallback callback) {
 }
 
 void CameraAppWindowStateController::Restore(RestoreCallback callback) {
-  auto current_state = GetCurrentWindowState();
-
-  // In tablet mode, it won't do anything when calling restore() for windows
-  // which are already maximized. Therefore, for maximized windows, trigger the
-  // callback immediately.
-  if (current_state == WindowStateType::REGULAR ||
-      (ash::TabletMode::Get()->InTabletMode() &&
-       (current_state == WindowStateType::MAXIMIZED ||
-        current_state == WindowStateType::FULLSCREEN))) {
+  if (IsRestored(widget_)) {
     std::move(callback).Run();
     return;
   }
@@ -65,7 +75,7 @@ void CameraAppWindowStateController::Restore(RestoreCallback callback) {
 }
 
 void CameraAppWindowStateController::Maximize(MaximizeCallback callback) {
-  if (GetCurrentWindowState() == WindowStateType::MAXIMIZED) {
+  if (widget_->IsMaximized()) {
     std::move(callback).Run();
     return;
   }
@@ -74,7 +84,7 @@ void CameraAppWindowStateController::Maximize(MaximizeCallback callback) {
 }
 
 void CameraAppWindowStateController::Fullscreen(FullscreenCallback callback) {
-  if (GetCurrentWindowState() == WindowStateType::FULLSCREEN) {
+  if (widget_->IsFullscreen()) {
     std::move(callback).Run();
     return;
   }
@@ -113,47 +123,51 @@ void CameraAppWindowStateController::OnWidgetBoundsChanged(
 }
 
 void CameraAppWindowStateController::OnWindowStateChanged() {
-  auto prev_state = window_state_;
-  window_state_ = GetCurrentWindowState();
-
-  std::queue<base::OnceClosure>* callbacks;
-  switch (window_state_) {
-    case WindowStateType::MINIMIZED:
-      callbacks = &minimize_callbacks_;
-      break;
-    case WindowStateType::REGULAR:
-      callbacks = &restore_callbacks_;
-      break;
-    case WindowStateType::MAXIMIZED:
-      callbacks = &maximize_callbacks_;
-      break;
-    case WindowStateType::FULLSCREEN:
-      callbacks = &fullscreen_callbacks_;
-      break;
-  }
-  while (!callbacks->empty()) {
-    std::move(callbacks->front()).Run();
-    callbacks->pop();
-  }
-
-  if (prev_state != window_state_) {
+  auto trigger_callbacks = [](std::queue<base::OnceClosure>* callbacks) {
+    while (!callbacks->empty()) {
+      std::move(callbacks->front()).Run();
+      callbacks->pop();
+    }
+  };
+
+  if (widget_->IsMinimized()) {
+    trigger_callbacks(&minimize_callbacks_);
+  }
+  if (IsRestored(widget_)) {
+    trigger_callbacks(&restore_callbacks_);
+  }
+  if (widget_->IsMaximized()) {
+    trigger_callbacks(&maximize_callbacks_);
+  }
+  if (widget_->IsFullscreen()) {
+    trigger_callbacks(&fullscreen_callbacks_);
+  }
+
+  auto prev_states = window_states_;
+  window_states_ = GetCurrentWindowStates();
+  if (prev_states != window_states_) {
     for (const auto& monitor : monitors_) {
-      monitor->OnWindowStateChanged(window_state_);
+      monitor->OnWindowStateChanged(ToVector(window_states_));
     }
   }
 }
 
-CameraAppWindowStateController::WindowStateType
-CameraAppWindowStateController::GetCurrentWindowState() {
+base::flat_set<CameraAppWindowStateController::WindowStateType>
+CameraAppWindowStateController::GetCurrentWindowStates() {
+  base::flat_set<CameraAppWindowStateController::WindowStateType> states;
   if (widget_->IsMinimized()) {
-    return WindowStateType::MINIMIZED;
-  } else if (widget_->IsMaximized()) {
-    return WindowStateType::MAXIMIZED;
-  } else if (widget_->IsFullscreen()) {
-    return WindowStateType::FULLSCREEN;
-  } else {
-    return WindowStateType::REGULAR;
+    states.insert(WindowStateType::MINIMIZED);
+  }
+  if (widget_->IsMaximized()) {
+    states.insert(WindowStateType::MAXIMIZED);
+  }
+  if (widget_->IsFullscreen()) {
+    states.insert(WindowStateType::FULLSCREEN);
+  }
+  if (IsRestored(widget_)) {
+    states.insert(WindowStateType::REGULAR);
   }
+  return states;
 }
 
 }  // namespace chromeos

chromeos/components/camera_app_ui/camera_app_window_state_controller.h

@@ -8,6 +8,7 @@
 #include <queue>
 #include <vector>
 
+#include "base/containers/flat_set.h"
 #include "chromeos/components/camera_app_ui/camera_app_helper.mojom.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
@@ -55,10 +56,10 @@ class CameraAppWindowStateController
 
  private:
   void OnWindowStateChanged();
-  WindowStateType GetCurrentWindowState();
+  base::flat_set<WindowStateType> GetCurrentWindowStates();
 
   views::Widget* widget_;
-  WindowStateType window_state_;
+  base::flat_set<WindowStateType> window_states_;
   mojo::ReceiverSet<chromeos_camera::mojom::WindowStateController> receivers_;
   std::vector<mojo::Remote<WindowStateMonitor>> monitors_;
   std::queue<base::OnceClosure> minimize_callbacks_;

chromeos/components/camera_app_ui/resources/js/window_controller/mojo_window_controller.js

@@ -23,10 +23,10 @@ export class MojoWindowController {
     this.windowStateController_ = null;
 
     /**
-     * Current window state.
-     * @type {?chromeosCamera.mojom.WindowStateType}
+     * Current window states.
+     * @type {!Array<!chromeosCamera.mojom.WindowStateType>}
      */
-    this.windowState_ = null;
+    this.windowStates_ = [];
   }
 
   /** @override */
@@ -35,12 +35,12 @@ export class MojoWindowController {
 
     const windowMonitorCallbackRouter =
         new chromeosCamera.mojom.WindowStateMonitorCallbackRouter();
-    windowMonitorCallbackRouter.onWindowStateChanged.addListener((state) => {
-      this.windowState_ = state;
+    windowMonitorCallbackRouter.onWindowStateChanged.addListener((states) => {
+      this.windowStates_ = states;
     });
-    const {state} = await this.windowStateController_.addMonitor(
+    const {states} = await this.windowStateController_.addMonitor(
         windowMonitorCallbackRouter.$.bindNewPipeAndPassRemote());
-    this.windowState_ = state;
+    this.windowStates_ = states;
   }
 
   /** @override */
@@ -85,14 +85,16 @@ export class MojoWindowController {
 
   /** @override */
   isMinimized() {
-    return this.windowState_ === chromeosCamera.mojom.WindowStateType.MINIMIZED;
+    return this.windowStates_.includes(
+        chromeosCamera.mojom.WindowStateType.MINIMIZED);
   }
 
   /** @override */
   isFullscreenOrMaximized() {
-    return this.windowState_ ===
-        chromeosCamera.mojom.WindowStateType.FULLSCREEN ||
-        this.windowState_ === chromeosCamera.mojom.WindowStateType.MAXIMIZED;
+    return this.windowStates_.includes(
+               chromeosCamera.mojom.WindowStateType.FULLSCREEN) ||
+        this.windowStates_.includes(
+            chromeosCamera.mojom.WindowStateType.MAXIMIZED);
   }
 
   /** @override */