CCA: Replace chrome.system.display API

Since we are about to migrate CCA to SWA, we should avoid using chrome.*
API so that we can have it work on SWA as well. Therefore, replacing
chrome.system.display API by our own mojo API.

Bug: 1114967, 980846
Test: Launch CCA without showing error messages
Change-Id: I89aaf3f2700adfade8dd8eae32554ac095bb0ded
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2354109Reviewed-by: Shik Chen <shik@chromium.org>
Reviewed-by: Robert Sesek <rsesek@chromium.org>
Reviewed-by: Ahmed Fakhry <afakhry@chromium.org>
Reviewed-by: Kuo Jen Wei <inker@chromium.org>
Commit-Queue: Ahmed Fakhry <afakhry@chromium.org>
Auto-Submit: Wei Lee <wtlee@chromium.org>
Cr-Commit-Position: refs/heads/master@{#799360}

chromeos/components/camera_app_ui/DEPS

@@ -5,5 +5,6 @@ include_rules = [
   "+content/public/browser",
   "+media/capture/video/chromeos",
   "+ui/aura",
+  "+ui/display",
   "+ui/webui",
 ]

chromeos/components/camera_app_ui/camera_app_helper.mojom

@@ -30,6 +30,14 @@ interface ScreenStateMonitor {
   Update(ScreenState state);
 };
 
+// Interface for monitoring the existence of external screen. The state is
+// detected from Chrome browser process and is notified to Chrome Camera App in
+// renderer process.
+interface ExternalScreenMonitor {
+  // Updates when the existence of external screen got changed.
+  Update(bool has_external_screen);
+};
+
 // Interface for communication between Chrome Camera App (Remote) and Chrome
 // (Receiver).
 interface CameraAppHelper {
@@ -65,4 +73,10 @@ interface CameraAppHelper {
   // Checks if the logging consent option is enabled. It is only usable for SWA
   // version. For platform app version, we use Chrome MetricsPrivate API.
   IsMetricsAndCrashReportingEnabled() => (bool is_enabled);
+
+  // Registers a ExternalScreenMonitor instance and returns the initial state of
+  // the existence of external screen. Calling the Update() whenever the screen
+  // state changes.
+  SetExternalScreenMonitor(pending_remote<ExternalScreenMonitor> monitor)
+      => (bool has_external_screen);
 };

chromeos/components/camera_app_ui/camera_app_helper_impl.cc

@@ -27,6 +27,15 @@ mojom::ScreenState ToMojoScreenState(ash::ScreenState s) {
   }
 }
 
+bool HasExternalScreen() {
+  for (const auto& display : display::Screen::GetScreen()->GetAllDisplays()) {
+    if (!display.IsInternal()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 }  // namespace
 
 CameraAppHelperImpl::CameraAppHelperImpl(
@@ -34,16 +43,19 @@ CameraAppHelperImpl::CameraAppHelperImpl(
     CameraResultCallback camera_result_callback,
     aura::Window* window)
     : camera_app_ui_(camera_app_ui),
-      camera_result_callback_(std::move(camera_result_callback)) {
+      camera_result_callback_(std::move(camera_result_callback)),
+      has_external_screen_(HasExternalScreen()) {
   DCHECK(window);
   window->SetProperty(ash::kCanConsumeSystemKeysKey, true);
   ash::TabletMode::Get()->AddObserver(this);
   ash::ScreenBacklight::Get()->AddObserver(this);
+  display::Screen::GetScreen()->AddObserver(this);
 }
 
 CameraAppHelperImpl::~CameraAppHelperImpl() {
   ash::TabletMode::Get()->RemoveObserver(this);
   ash::ScreenBacklight::Get()->RemoveObserver(this);
+  display::Screen::GetScreen()->RemoveObserver(this);
 }
 
 void CameraAppHelperImpl::Bind(
@@ -95,6 +107,23 @@ void CameraAppHelperImpl::IsMetricsAndCrashReportingEnabled(
       camera_app_ui_->delegate()->IsMetricsAndCrashReportingEnabled());
 }
 
+void CameraAppHelperImpl::SetExternalScreenMonitor(
+    mojo::PendingRemote<ExternalScreenMonitor> monitor,
+    SetExternalScreenMonitorCallback callback) {
+  external_screen_monitor_ =
+      mojo::Remote<ExternalScreenMonitor>(std::move(monitor));
+  std::move(callback).Run(has_external_screen_);
+}
+
+void CameraAppHelperImpl::CheckExternalScreenState() {
+  if (has_external_screen_ == HasExternalScreen())
+    return;
+  has_external_screen_ = !has_external_screen_;
+
+  if (external_screen_monitor_.is_bound())
+    external_screen_monitor_->Update(has_external_screen_);
+}
+
 void CameraAppHelperImpl::OnTabletModeStarted() {
   if (tablet_monitor_.is_bound())
     tablet_monitor_->Update(true);
@@ -110,4 +139,13 @@ void CameraAppHelperImpl::OnScreenStateChanged(ash::ScreenState screen_state) {
     screen_state_monitor_->Update(ToMojoScreenState(screen_state));
 }
 
+void CameraAppHelperImpl::OnDisplayAdded(const display::Display& new_display) {
+  CheckExternalScreenState();
+}
+
+void CameraAppHelperImpl::OnDisplayRemoved(
+    const display::Display& old_display) {
+  CheckExternalScreenState();
+}
+
 }  // namespace chromeos_camera

chromeos/components/camera_app_ui/camera_app_helper_impl.h

@@ -13,6 +13,8 @@
 #include "chromeos/components/camera_app_ui/camera_app_helper.mojom.h"
 #include "chromeos/components/camera_app_ui/camera_app_ui.h"
 #include "mojo/public/cpp/bindings/remote.h"
+#include "ui/display/display_observer.h"
+#include "ui/display/screen.h"
 
 namespace aura {
 class Window;
@@ -22,6 +24,7 @@ namespace chromeos_camera {
 
 class CameraAppHelperImpl : public ash::TabletModeObserver,
                             public ash::ScreenBacklightObserver,
+                            public display::DisplayObserver,
                             public mojom::CameraAppHelper {
  public:
   using CameraResultCallback =
@@ -31,6 +34,7 @@ class CameraAppHelperImpl : public ash::TabletModeObserver,
                                    HandleCameraResultCallback)>;
   using TabletModeMonitor = mojom::TabletModeMonitor;
   using ScreenStateMonitor = mojom::ScreenStateMonitor;
+  using ExternalScreenMonitor = mojom::ExternalScreenMonitor;
 
   CameraAppHelperImpl(chromeos::CameraAppUI* camera_app_ui,
                       CameraResultCallback camera_result_callback,
@@ -52,8 +56,13 @@ class CameraAppHelperImpl : public ash::TabletModeObserver,
                              SetScreenStateMonitorCallback callback) override;
   void IsMetricsAndCrashReportingEnabled(
       IsMetricsAndCrashReportingEnabledCallback callback) override;
+  void SetExternalScreenMonitor(
+      mojo::PendingRemote<ExternalScreenMonitor> monitor,
+      SetExternalScreenMonitorCallback callback) override;
 
  private:
+  void CheckExternalScreenState();
+
   // ash::TabletModeObserver overrides;
   void OnTabletModeStarted() override;
   void OnTabletModeEnded() override;
@@ -61,6 +70,10 @@ class CameraAppHelperImpl : public ash::TabletModeObserver,
   // ash::ScreenBacklightObserver overrides;
   void OnScreenStateChanged(ash::ScreenState screen_state) override;
 
+  // display::DisplayObserver overrides;
+  void OnDisplayAdded(const display::Display& new_display) override;
+  void OnDisplayRemoved(const display::Display& old_display) override;
+
   // For platform app, we set |camera_app_ui_| to nullptr and should not use
   // it. For SWA, since CameraAppUI owns CameraAppHelperImpl, it is safe to
   // assume that the |camera_app_ui_| is always valid during the whole lifetime
@@ -69,8 +82,11 @@ class CameraAppHelperImpl : public ash::TabletModeObserver,
 
   CameraResultCallback camera_result_callback_;
 
+  bool has_external_screen_;
+
   mojo::Remote<TabletModeMonitor> tablet_monitor_;
   mojo::Remote<ScreenStateMonitor> screen_state_monitor_;
+  mojo::Remote<ExternalScreenMonitor> external_screen_monitor_;
 
   mojo::Receiver<chromeos_camera::mojom::CameraAppHelper> receiver_{this};
 

chromeos/components/camera_app_ui/resources/src/js/mojo/chrome_helper.js

@@ -60,6 +60,22 @@ export class ChromeHelper {
         .initialState;
   }
 
+  /**
+   * Starts monitor monitoring the existence of external screens.
+   * @param {function(boolean)} onChange Callback called when the existence of
+   *     external screens changes.
+   * @return {!Promise<boolean>} Resolved to the initial state.
+   */
+  async initExternalScreenMonitor(onChange) {
+    const monitorCallbackRouter =
+        new chromeosCamera.mojom.ExternalScreenMonitorCallbackRouter();
+    monitorCallbackRouter.update.addListener(onChange);
+
+    return (await this.remote_.setExternalScreenMonitor(
+                monitorCallbackRouter.$.bindNewPipeAndPassRemote()))
+        .hasExternalScreen;
+  }
+
   /**
    * Checks if the device is under tablet mode currently.
    * @return {!Promise<boolean>}

chromeos/components/camera_app_ui/resources/src/js/views/camera.js

@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 import {browserProxy} from '../browser_proxy/browser_proxy.js';
-import {assert, assertInstanceof, promisify} from '../chrome_util.js';
+import {assert, assertInstanceof} from '../chrome_util.js';
 import {
   PhotoConstraintsPreferrer,  // eslint-disable-line no-unused-vars
   VideoConstraintsPreferrer,  // eslint-disable-line no-unused-vars
@@ -277,14 +277,12 @@ export class Camera extends View {
     const screenState = await helper.initScreenStateMonitor(setScreenOffAuto);
     setScreenOffAuto(screenState);
 
-    const updateExternalScreen = async () => {
-      const allInfo = await promisify(chrome.system.display.getInfo)(
-          {singleUnified: false});
-      const hasExternalScreen = allInfo.some(({isInternal}) => !isInternal);
+    const updateExternalScreen = (hasExternalScreen) => {
       state.set(state.State.HAS_EXTERNAL_SCREEN, hasExternalScreen);
     };
-    await updateExternalScreen();
-    chrome.system.display.onDisplayChanged.addListener(updateExternalScreen);
+    const hasExternalScreen =
+        await helper.initExternalScreenMonitor(updateExternalScreen);
+    updateExternalScreen(hasExternalScreen);
 
     const checkScreenOff = () => {
       if (this.screenOff_) {