Fixing bug of display orientation setting

(1) Modified code so that tablet
mode updating will enable/disable display
orientation in setting page.

(2) Code refactoring: move all of methods
related with display information in
SystemInfoApi::SystemInfoEventRouter to
DisplayInfoProvider and its subclasses.

In the previous code, tablet mode's change
will not affect display orientation when
setting page has already shown. As result,
when opening setting page then changing
laptop to tablet mode, user is still able
to modify display orientation. After
investigation, the bug reason is that in
ChromeOS change in tablet mode will not
trigger OnDisplayChanged event.

Bug: 889625
Change-Id: Ic526ec54e6c01cd14a0d4a7e883774b9fafed268
Reviewed-on: https://chromium-review.googlesource.com/c/1264544
Commit-Queue: Andrew Xu <andrewxu@chromium.org>
Reviewed-by: Toni Baržić <tbarzic@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#599846}

chrome/browser/extensions/api/system_display/system_display_chromeos_apitest.cc

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ash/public/cpp/ash_switches.h"
+#include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/system_display/display_info_provider_chromeos.h"
+#include "extensions/browser/api/system_display/display_info_provider.h"
+#include "extensions/test/extension_test_message_listener.h"
+#include "extensions/test/result_catcher.h"
+
+class SystemDisplayChromeOSApiTest : public extensions::ExtensionApiTest {
+ public:
+  SystemDisplayChromeOSApiTest() = default;
+  ~SystemDisplayChromeOSApiTest() override = default;
+
+  void SetUpDefaultCommandLine(base::CommandLine* command_line) override {
+    command_line->AppendSwitch(ash::switches::kAshEnableTabletMode);
+    extensions::ExtensionApiTest::SetUpDefaultCommandLine(command_line);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SystemDisplayChromeOSApiTest);
+};
+
+IN_PROC_BROWSER_TEST_F(SystemDisplayChromeOSApiTest,
+                       CheckOnDisplayChangedEvent) {
+  ExtensionTestMessageListener listener_for_extension_ready("ready", false);
+  ASSERT_TRUE(
+      LoadExtension(test_data_dir_.AppendASCII("system_display_chromeos")));
+  ASSERT_TRUE(listener_for_extension_ready.WaitUntilSatisfied());
+
+  extensions::DisplayInfoProviderChromeOS* provider =
+      static_cast<extensions::DisplayInfoProviderChromeOS*>(
+          extensions::DisplayInfoProvider::Get());
+
+  // Change Tablet Mode then ensure that OnDisplayChangedEvent is triggered
+  provider->OnTabletModeToggled(true);
+
+  extensions::ResultCatcher catcher;
+  EXPECT_TRUE(catcher.GetNextResult());
+}

chrome/browser/extensions/system_display/display_info_provider_chromeos.cc

@@ -12,6 +12,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "chrome/browser/ui/ash/tablet_mode_client.h"
 #include "content/public/common/service_manager_connection.h"
 #include "extensions/common/api/system_display.h"
 #include "services/service_manager/public/cpp/connector.h"
@@ -274,7 +275,7 @@ DisplayInfoProviderChromeOS::DisplayInfoProviderChromeOS(
   connector->BindInterface(ash::mojom::kServiceName, &cros_display_config_);
 }
 
-DisplayInfoProviderChromeOS::~DisplayInfoProviderChromeOS() {}
+DisplayInfoProviderChromeOS::~DisplayInfoProviderChromeOS() = default;
 
 void DisplayInfoProviderChromeOS::SetDisplayProperties(
     const std::string& display_id_str,
@@ -595,6 +596,26 @@ void DisplayInfoProviderChromeOS::SetMirrorMode(
           std::move(callback)));
 }
 
+void DisplayInfoProviderChromeOS::StartObserving() {
+  DisplayInfoProvider::StartObserving();
+
+  TabletModeClient* client = TabletModeClient::Get();
+  if (client)
+    client->AddObserver(this);
+}
+
+void DisplayInfoProviderChromeOS::StopObserving() {
+  DisplayInfoProvider::StopObserving();
+
+  TabletModeClient* client = TabletModeClient::Get();
+  if (client)
+    client->RemoveObserver(this);
+}
+
+void DisplayInfoProviderChromeOS::OnTabletModeToggled(bool enabled) {
+  DispatchOnDisplayChangedEvent();
+}
+
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   std::unique_ptr<service_manager::Connector> connector =

chrome/browser/extensions/system_display/display_info_provider_chromeos.h

@@ -11,6 +11,7 @@
 #include "ash/public/interfaces/cros_display_config.mojom.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "chrome/browser/ui/ash/tablet_mode_client_observer.h"
 #include "extensions/browser/api/system_display/display_info_provider.h"
 
 namespace service_manager {
@@ -19,7 +20,8 @@ class Connector;
 
 namespace extensions {
 
-class DisplayInfoProviderChromeOS : public DisplayInfoProvider {
+class DisplayInfoProviderChromeOS : public DisplayInfoProvider,
+                                    public TabletModeClientObserver {
  public:
   explicit DisplayInfoProviderChromeOS(service_manager::Connector* connector);
   ~DisplayInfoProviderChromeOS() override;
@@ -52,6 +54,11 @@ class DisplayInfoProviderChromeOS : public DisplayInfoProvider {
   bool ClearTouchCalibration(const std::string& id) override;
   void SetMirrorMode(const api::system_display::MirrorModeInfo& info,
                      ErrorCallback callback) override;
+  void StartObserving() override;
+  void StopObserving() override;
+
+  // TabletModeClientObserver implementation.
+  void OnTabletModeToggled(bool enabled) override;
 
  private:
   void CallSetDisplayLayoutInfo(ash::mojom::DisplayLayoutInfoPtr layout_info,

chrome/test/BUILD.gn

@@ -1440,6 +1440,10 @@ test("browser_tests") {
         sources += [ "../browser/extensions/background_app_browsertest.cc" ]
       }
 
+      if (is_chromeos) {
+        sources += [ "../browser/extensions/api/system_display/system_display_chromeos_apitest.cc" ]
+      }
+
       deps += [
         "//chrome/common/extensions/api",
         "//chrome/services/media_gallery_util/public/cpp:browser_tests",

chrome/test/data/extensions/api_test/system_display_chromeos/background.js

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+chrome.test.runTests([
+  function waitForDisplayChangedEvent() {
+    chrome.test.listenOnce(chrome.system.display.onDisplayChanged,
+                           function() {});
+  }
+]);
+
+chrome.test.sendMessage("ready");

chrome/test/data/extensions/api_test/system_display_chromeos/manifest.json

+{
+  "name": "ondisplaychangedevent",
+  "manifest_version": 2,
+  "version": "1.0",
+  "description": "Test system.display API",
+  "permissions": ["system.display"],
+  "app": {
+    "background": {
+      "scripts": ["background.js"]
+    }
+  }
+}

extensions/browser/api/system_display/display_info_provider.cc

@@ -6,6 +6,7 @@
 
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/api/system_display.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
@@ -121,6 +122,18 @@ void DisplayInfoProvider::GetDisplayLayout(
       FROM_HERE, base::BindOnce(std::move(callback), DisplayLayoutList()));
 }
 
+void DisplayInfoProvider::StartObserving() {
+  display::Screen* screen = display::Screen::GetScreen();
+  if (screen)
+    screen->AddObserver(this);
+}
+
+void DisplayInfoProvider::StopObserving() {
+  display::Screen* screen = display::Screen::GetScreen();
+  if (screen)
+    screen->RemoveObserver(this);
+}
+
 bool DisplayInfoProvider::OverscanCalibrationStart(const std::string& id) {
   return false;
 }
@@ -169,10 +182,32 @@ void DisplayInfoProvider::SetMirrorMode(
       FROM_HERE, base::BindOnce(std::move(callback), "Not supported"));
 }
 
+void DisplayInfoProvider::DispatchOnDisplayChangedEvent() {
+  ExtensionsBrowserClient::Get()->BroadcastEventToRenderers(
+      events::SYSTEM_DISPLAY_ON_DISPLAY_CHANGED,
+      extensions::api::system_display::OnDisplayChanged::kEventName,
+      std::make_unique<base::ListValue>());
+}
+
 void DisplayInfoProvider::UpdateDisplayUnitInfoForPlatform(
     const display::Display& display,
     extensions::api::system_display::DisplayUnitInfo* unit) {
   NOTIMPLEMENTED_LOG_ONCE();
 }
 
+void DisplayInfoProvider::OnDisplayAdded(const display::Display& new_display) {
+  DispatchOnDisplayChangedEvent();
+}
+
+void DisplayInfoProvider::OnDisplayRemoved(
+    const display::Display& old_display) {
+  DispatchOnDisplayChangedEvent();
+}
+
+void DisplayInfoProvider::OnDisplayMetricsChanged(
+    const display::Display& display,
+    uint32_t metrics) {
+  DispatchOnDisplayChangedEvent();
+}
+
 }  // namespace extensions

extensions/browser/api/system_display/display_info_provider.h

@@ -14,6 +14,7 @@
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/optional.h"
+#include "ui/display/display_observer.h"
 
 namespace display {
 class Display;
@@ -36,13 +37,13 @@ struct TouchCalibrationPairQuad;
 // Implementation class for chrome.system.display extension API
 // (system_display_api.cc). Callbacks that provide an error string use an
 // empty string for success.
-class DisplayInfoProvider {
+class DisplayInfoProvider : public display::DisplayObserver {
  public:
   using DisplayUnitInfoList = std::vector<api::system_display::DisplayUnitInfo>;
   using DisplayLayoutList = std::vector<api::system_display::DisplayLayout>;
   using ErrorCallback = base::OnceCallback<void(base::Optional<std::string>)>;
 
-  virtual ~DisplayInfoProvider();
+  ~DisplayInfoProvider() override;
 
   // Returns a pointer to DisplayInfoProvider or null if Create() or
   // InitializeForTesting() have not been called yet.
@@ -82,6 +83,10 @@ class DisplayInfoProvider {
   virtual void GetDisplayLayout(
       base::OnceCallback<void(DisplayLayoutList result)> callback);
 
+  // Start/Stop observing display state change
+  virtual void StartObserving();
+  virtual void StopObserving();
+
   // Implements overscan calibration methods. See system_display.idl. These
   // return false if |id| is invalid.
   virtual bool OverscanCalibrationStart(const std::string& id);
@@ -113,6 +118,9 @@ class DisplayInfoProvider {
  protected:
   DisplayInfoProvider();
 
+  // Trigger OnDisplayChangedEvent
+  void DispatchOnDisplayChangedEvent();
+
   // Create a DisplayUnitInfo from a display::Display for implementations of
   // GetAllDisplaysInfo()
   static api::system_display::DisplayUnitInfo CreateDisplayUnitInfo(
@@ -128,6 +136,12 @@ class DisplayInfoProvider {
       const display::Display& display,
       api::system_display::DisplayUnitInfo* unit);
 
+  // DisplayObserver
+  void OnDisplayAdded(const display::Display& new_display) override;
+  void OnDisplayRemoved(const display::Display& old_display) override;
+  void OnDisplayMetricsChanged(const display::Display& display,
+                               uint32_t metrics) override;
+
   DISALLOW_COPY_AND_ASSIGN(DisplayInfoProvider);
 };