SystemDisplayApi: Introdice OverscanTracker

extensions/browser/api/system_display/system_display_apitest.cc

 // Copyright 2013 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 <stdint.h>
 
+#include <set>
 #include <utility>
 
 #include "base/debug/leak_annotations.h"
 #include "base/macros.h"
+#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "extensions/browser/api/system_display/display_info_provider.h"
 #include "extensions/browser/api/system_display/system_display_api.h"
 #include "extensions/browser/api_test_utils.h"
 #include "extensions/common/api/system_display.h"
 #include "extensions/shell/test/shell_apitest.h"
+#include "extensions/test/result_catcher.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
 namespace extensions {
 
 using api::system_display::Bounds;
 using api::system_display::DisplayUnitInfo;
 using display::Screen;
 
 class MockScreen : public Screen {
@@ skipping 57 matching lines @@
     EXPECT_FALSE(set_info_value_);
     set_info_value_ = params.ToValue();
     set_info_display_id_ = display_id;
     return true;
   }
 
   void EnableUnifiedDesktop(bool enable) override {
     unified_desktop_enabled_ = enable;
   }
 
+  bool OverscanCalibrationStart(const std::string& id) override {
+    if (base::ContainsKey(overscan_started_, id))
+      return false;
+    overscan_started_.insert(id);
+    return true;
+  }
+
+  bool OverscanCalibrationAdjust(
+      const std::string& id,
+      const api::system_display::Insets& delta) override {
+    if (!base::ContainsKey(overscan_started_, id))
+      return false;
+    overscan_adjusted_.insert(id);
+    return true;
+  }
+
+  bool OverscanCalibrationReset(const std::string& id) override {
+    if (!base::ContainsKey(overscan_started_, id))
+      return false;
+    overscan_adjusted_.erase(id);
+    return true;
+  }
+
+  bool OverscanCalibrationComplete(const std::string& id) override {
+    if (!base::ContainsKey(overscan_started_, id))
+      return false;
+    overscan_started_.erase(id);
+    return true;
+  }
+
   std::unique_ptr<base::DictionaryValue> GetSetInfoValue() {
     return std::move(set_info_value_);
   }
 
   std::string GetSetInfoDisplayId() const { return set_info_display_id_; }
 
   bool unified_desktop_enabled() const { return unified_desktop_enabled_; }
 
+  bool calibration_started(const std::string& id) const {
+    return base::ContainsKey(overscan_started_, id);
+  }
+
+  bool calibration_changed(const std::string& id) const {
+    return base::ContainsKey(overscan_adjusted_, id);
+  }
+
  private:
   // Update the content of the |unit| obtained for |display| using
   // platform specific method.
   void UpdateDisplayUnitInfoForPlatform(
       const display::Display& display,
       extensions::api::system_display::DisplayUnitInfo* unit) override {
     int64_t id = display.id();
     unit->name = "DISPLAY NAME FOR " + base::Int64ToString(id);
     if (id == 1)
       unit->mirroring_source_id = "0";
     unit->is_primary = id == 0 ? true : false;
     unit->is_internal = id == 0 ? true : false;
     unit->is_enabled = true;
     unit->rotation = (90 * id) % 360;
     unit->dpi_x = 96.0;
     unit->dpi_y = 96.0;
     if (id == 0) {
       unit->overscan.left = 20;
       unit->overscan.top = 40;
       unit->overscan.right = 60;
       unit->overscan.bottom = 80;
     }
   }
 
   std::unique_ptr<base::DictionaryValue> set_info_value_;
   std::string set_info_display_id_;
   bool unified_desktop_enabled_ = false;
+  std::set<std::string> overscan_started_;
+  std::set<std::string> overscan_adjusted_;
 
   DISALLOW_COPY_AND_ASSIGN(MockDisplayInfoProvider);
 };
 
 class SystemDisplayApiTest : public ShellApiTest {
  public:
   SystemDisplayApiTest()
       : provider_(new MockDisplayInfoProvider), screen_(new MockScreen) {}
 
   ~SystemDisplayApiTest() override {}
@@ skipping 30 matching lines @@
       api_test_utils::RunFunctionAndReturnError(
           set_info_function.get(), "[\"display_id\", {}]", browser_context()));
 
   std::unique_ptr<base::DictionaryValue> set_info =
       provider_->GetSetInfoValue();
   EXPECT_FALSE(set_info);
 }
 
 #else  // !defined(OS_CHROMEOS)
 
+constexpr char kTestManifest[] =
+    "{\n"
+    "  \"name\": \"Test\",\n"
+    "  \"version\": \"1.0\",\n"
+    "  \"app\": {\n"
+    "    \"background\": {\n"
+    "      \"scripts\": [\"background.js\"]\n"
+    "    }\n"
+    "  }\n"
+    "}";
+
+constexpr char kTestManifestKiosk[] =
+    "{\n"
+    "  \"name\": \"Test\",\n"
+    "  \"version\": \"1.0\",\n"
+    "  \"app\": {\n"
+    "    \"background\": {\n"
+    "      \"scripts\": [\"background.js\"]\n"
+    "    }\n"
+    "  },\n"
+    "  \"kiosk_enabled\": true\n"
+    "}";
+
 // TODO(stevenjb): Add API tests for {GS}etDisplayLayout. That code currently
 // lives in src/chrome but should be getting moved soon.
 
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplayNotKioskEnabled) {
   std::unique_ptr<base::DictionaryValue> test_extension_value(
-      api_test_utils::ParseDictionary("{\n"
-                                      "  \"name\": \"Test\",\n"
-                                      "  \"version\": \"1.0\",\n"
-                                      "  \"app\": {\n"
-                                      "    \"background\": {\n"
-                                      "      \"scripts\": [\"background.js\"]\n"
-                                      "    }\n"
-                                      "  }\n"
-                                      "}"));
+      api_test_utils::ParseDictionary(kTestManifest));
   scoped_refptr<Extension> test_extension(
       api_test_utils::CreateExtension(test_extension_value.get()));
 
   scoped_refptr<SystemDisplaySetDisplayPropertiesFunction> set_info_function(
       new SystemDisplaySetDisplayPropertiesFunction());
 
   set_info_function->set_extension(test_extension.get());
   set_info_function->set_has_callback(true);
 
   EXPECT_EQ(
       SystemDisplayFunction::kKioskOnlyError,
       api_test_utils::RunFunctionAndReturnError(
           set_info_function.get(), "[\"display_id\", {}]", browser_context()));
 
   std::unique_ptr<base::DictionaryValue> set_info =
       provider_->GetSetInfoValue();
   EXPECT_FALSE(set_info);
 }
 
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplayKioskEnabled) {
   std::unique_ptr<base::DictionaryValue> test_extension_value(
-      api_test_utils::ParseDictionary("{\n"
-                                      "  \"name\": \"Test\",\n"
-                                      "  \"version\": \"1.0\",\n"
-                                      "  \"app\": {\n"
-                                      "    \"background\": {\n"
-                                      "      \"scripts\": [\"background.js\"]\n"
-                                      "    }\n"
-                                      "  },\n"
-                                      "  \"kiosk_enabled\": true\n"
-                                      "}"));
+      api_test_utils::ParseDictionary(kTestManifestKiosk));
   scoped_refptr<Extension> test_extension(
       api_test_utils::CreateExtension(test_extension_value.get()));
 
   scoped_refptr<SystemDisplaySetDisplayPropertiesFunction> set_info_function(
       new SystemDisplaySetDisplayPropertiesFunction());
 
   set_info_function->set_has_callback(true);
   set_info_function->set_extension(test_extension.get());
 
   ASSERT_TRUE(api_test_utils::RunFunction(
@@ skipping 22 matching lines @@
   EXPECT_EQ(1, api_test_utils::GetInteger(overscan, "left"));
   EXPECT_EQ(2, api_test_utils::GetInteger(overscan, "top"));
   EXPECT_EQ(3, api_test_utils::GetInteger(overscan, "right"));
   EXPECT_EQ(4, api_test_utils::GetInteger(overscan, "bottom"));
 
   EXPECT_EQ("display_id", provider_->GetSetInfoDisplayId());
 }
 
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, EnableUnifiedDesktop) {
   std::unique_ptr<base::DictionaryValue> test_extension_value(
-      api_test_utils::ParseDictionary("{\n"
-                                      "  \"name\": \"Test\",\n"
-                                      "  \"version\": \"1.0\",\n"
-                                      "  \"app\": {\n"
-                                      "    \"background\": {\n"
-                                      "      \"scripts\": [\"background.js\"]\n"
-                                      "    }\n"
-                                      "  },\n"
-                                      "  \"kiosk_enabled\": true\n"
-                                      "}"));
+      api_test_utils::ParseDictionary(kTestManifestKiosk));
   scoped_refptr<Extension> test_extension(
       api_test_utils::CreateExtension(test_extension_value.get()));
   {
     scoped_refptr<SystemDisplayEnableUnifiedDesktopFunction>
         enable_unified_function(
             new SystemDisplayEnableUnifiedDesktopFunction());
 
     enable_unified_function->set_has_callback(true);
     enable_unified_function->set_extension(test_extension.get());
 
     EXPECT_FALSE(provider_->unified_desktop_enabled());
 
     ASSERT_TRUE(api_test_utils::RunFunction(enable_unified_function.get(),
                                             "[true]", browser_context()));
     EXPECT_TRUE(provider_->unified_desktop_enabled());
   }
   {
     scoped_refptr<SystemDisplayEnableUnifiedDesktopFunction>
         enable_unified_function(
             new SystemDisplayEnableUnifiedDesktopFunction());
 
     enable_unified_function->set_has_callback(true);
     enable_unified_function->set_extension(test_extension.get());
     ASSERT_TRUE(api_test_utils::RunFunction(enable_unified_function.get(),
                                             "[false]", browser_context()));
     EXPECT_FALSE(provider_->unified_desktop_enabled());
   }
 }
 
+IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, OverscanCalibrationStart) {
+  const std::string id = "display0";
+  std::unique_ptr<base::DictionaryValue> test_extension_value(
+      api_test_utils::ParseDictionary(kTestManifestKiosk));
+  scoped_refptr<Extension> test_extension(
+      api_test_utils::CreateExtension(test_extension_value.get()));
+
+  // Setup MockDisplayInfoProvider.
+  api::system_display::DisplayProperties params;
+  provider_->SetInfo(id, params, nullptr);
+
+  // Call OverscanCalibrationStart.
+  scoped_refptr<SystemDisplayOverscanCalibrationStartFunction> start_function(
+      new SystemDisplayOverscanCalibrationStartFunction());
+  start_function->set_extension(test_extension.get());
+  start_function->set_has_callback(true);
+  ASSERT_TRUE(api_test_utils::RunFunction(
+      start_function.get(), "[\"" + id + "\"]", browser_context()));
+
+  ASSERT_TRUE(provider_->calibration_started(id));
+
+  // Call OverscanCalibrationComplete.
+  scoped_refptr<SystemDisplayOverscanCalibrationCompleteFunction>
+      complete_function(new SystemDisplayOverscanCalibrationCompleteFunction());
+  complete_function->set_extension(test_extension.get());
+  complete_function->set_has_callback(true);
+  ASSERT_TRUE(api_test_utils::RunFunction(
+      complete_function.get(), "[\"" + id + "\"]", browser_context()));
+
+  ASSERT_FALSE(provider_->calibration_started(id));
+}
+
+IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, OverscanCalibrationApp) {
+  // Setup MockDisplayInfoProvider.
+  const std::string id = "display0";
+  api::system_display::DisplayProperties params;
+  provider_->SetInfo(id, params, nullptr);
+
+  ASSERT_TRUE(RunAppTest("system/display/overscan")) << message_;
+
+  ASSERT_FALSE(provider_->calibration_started(id));
+  ASSERT_TRUE(provider_->calibration_changed(id));
+}
+
+IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, OverscanCalibrationAppNoComplete) {
+  // Setup MockDisplayInfoProvider.
+  const std::string id = "display0";
+  api::system_display::DisplayProperties params;
+  provider_->SetInfo(id, params, nullptr);
+
+  ResultCatcher catcher;
+  const Extension* extension = LoadApp("system/display/overscan_no_complete");
+  ASSERT_TRUE(extension);
+  EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
+
+  // Calibration was started by the app but not completed.
+  ASSERT_TRUE(provider_->calibration_started(id));
+
+  // Unloading the app should complete the calibraiton (and hide the overlay).
+  UnloadApp(extension);
+  ASSERT_FALSE(provider_->calibration_changed(id));
+  ASSERT_FALSE(provider_->calibration_started(id));
+}
+
 #endif  // !defined(OS_CHROMEOS)
 
 }  // namespace extensions