src/chrome/browser/extensions/api/system_display/system_display_apitest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/debug/leak_annotations.h"
   6 #include "base/strings/string_number_conversions.h"
   7 #include "chrome/browser/extensions/extension_apitest.h"
   8 #include "chrome/browser/extensions/extension_function_test_utils.h"
   9 #include "extensions/browser/api/system_display/display_info_provider.h"
  10 #include "extensions/browser/api/system_display/system_display_api.h"
  11 #include "extensions/common/api/system_display.h"
  12 #include "ui/gfx/display.h"
  13 #include "ui/gfx/display_observer.h"
  14 #include "ui/gfx/screen.h"
  15
  16 #if defined(OS_CHROMEOS)
  17 #include "ash/display/screen_ash.h"
  18 #include "ash/shell.h"
  19 #endif
  20
  21 namespace utils = extension_function_test_utils;
  22
  23 namespace extensions {
  24
  25 using core_api::system_display::Bounds;
  26 using core_api::system_display::DisplayUnitInfo;
  27 using gfx::Screen;
  28
  29 #if defined(OS_CHROMEOS)
  30 class MockScreen : public ash::ScreenAsh {
  31  public:
  32   MockScreen() {
  33     for (int i = 0; i < 4; i++) {
  34       gfx::Rect bounds(0, 0, 1280, 720);
  35       gfx::Rect work_area(0, 0, 960, 720);
  36       gfx::Display display(i, bounds);
  37       display.set_work_area(work_area);
  38       displays_.push_back(display);
  39     }
  40   }
  41   virtual ~MockScreen() {}
  42
  43  protected:
  44   // Overridden from gfx::Screen:
  45   virtual int GetNumDisplays() const OVERRIDE {
  46     return displays_.size();
  47   }
  48   virtual std::vector<gfx::Display> GetAllDisplays() const OVERRIDE {
  49     return displays_;
  50   }
  51   virtual gfx::Display GetPrimaryDisplay() const OVERRIDE {
  52     return displays_[0];
  53   }
  54
  55  private:
  56   std::vector<gfx::Display> displays_;
  57
  58   DISALLOW_COPY_AND_ASSIGN(MockScreen);
  59 };
  60 #else
  61 class MockScreen : public Screen {
  62  public:
  63   MockScreen() {
  64     for (int i = 0; i < 4; i++) {
  65       gfx::Rect bounds(0, 0, 1280, 720);
  66       gfx::Rect work_area(0, 0, 960, 720);
  67       gfx::Display display(i, bounds);
  68       display.set_work_area(work_area);
  69       displays_.push_back(display);
  70     }
  71   }
  72   virtual ~MockScreen() {}
  73
  74  protected:
  75   // Overridden from gfx::Screen:
  76   virtual bool IsDIPEnabled() OVERRIDE { return true; }
  77   virtual gfx::Point GetCursorScreenPoint() OVERRIDE  { return gfx::Point(); }
  78   virtual gfx::NativeWindow GetWindowUnderCursor() OVERRIDE {
  79     return gfx::NativeWindow();
  80   }
  81   virtual gfx::NativeWindow GetWindowAtScreenPoint(
  82       const gfx::Point& point) OVERRIDE {
  83     return gfx::NativeWindow();
  84   }
  85   virtual int GetNumDisplays() const OVERRIDE {
  86     return displays_.size();
  87   }
  88   virtual std::vector<gfx::Display> GetAllDisplays() const OVERRIDE {
  89     return displays_;
  90   }
  91   virtual gfx::Display GetDisplayNearestWindow(
  92       gfx::NativeView window) const OVERRIDE {
  93     return gfx::Display(0);
  94   }
  95   virtual gfx::Display GetDisplayNearestPoint(
  96       const gfx::Point& point) const OVERRIDE {
  97     return gfx::Display(0);
  98   }
  99   virtual gfx::Display GetDisplayMatching(
 100       const gfx::Rect& match_rect) const OVERRIDE {
 101     return gfx::Display(0);
 102   }
 103   virtual gfx::Display GetPrimaryDisplay() const OVERRIDE {
 104     return displays_[0];
 105   }
 106   virtual void AddObserver(gfx::DisplayObserver* observer) OVERRIDE {}
 107   virtual void RemoveObserver(gfx::DisplayObserver* observer) OVERRIDE {}
 108
 109  private:
 110   std::vector<gfx::Display> displays_;
 111
 112   DISALLOW_COPY_AND_ASSIGN(MockScreen);
 113 };
 114 #endif
 115
 116 class MockDisplayInfoProvider : public DisplayInfoProvider {
 117  public:
 118   MockDisplayInfoProvider() {}
 119
 120   virtual ~MockDisplayInfoProvider() {}
 121
 122   virtual bool SetInfo(
 123       const std::string& display_id,
 124       const core_api::system_display::DisplayProperties& params,
 125       std::string* error) OVERRIDE {
 126     // Should get called only once per test case.
 127     EXPECT_FALSE(set_info_value_);
 128     set_info_value_ = params.ToValue();
 129     set_info_display_id_ = display_id;
 130     return true;
 131   }
 132
 133   virtual gfx::Screen* GetActiveScreen() OVERRIDE { return NULL; }
 134
 135   scoped_ptr<base::DictionaryValue> GetSetInfoValue() {
 136     return set_info_value_.Pass();
 137   }
 138
 139   std::string GetSetInfoDisplayId() const {
 140     return set_info_display_id_;
 141   }
 142
 143  private:
 144   // Update the content of the |unit| obtained for |display| using
 145   // platform specific method.
 146   virtual void UpdateDisplayUnitInfoForPlatform(
 147       const gfx::Display& display,
 148       extensions::core_api::system_display::DisplayUnitInfo* unit) OVERRIDE {
 149     int64 id = display.id();
 150     unit->name = "DISPLAY NAME FOR " + base::Int64ToString(id);
 151     if (id == 1)
 152       unit->mirroring_source_id = "0";
 153     unit->is_primary = id == 0 ? true : false;
 154     unit->is_internal = id == 0 ? true : false;
 155     unit->is_enabled = true;
 156     unit->rotation = (90 * id) % 360;
 157     unit->dpi_x = 96.0;
 158     unit->dpi_y = 96.0;
 159     if (id == 0) {
 160       unit->overscan.left = 20;
 161       unit->overscan.top = 40;
 162       unit->overscan.right = 60;
 163       unit->overscan.bottom = 80;
 164     }
 165   }
 166
 167   scoped_ptr<base::DictionaryValue> set_info_value_;
 168   std::string set_info_display_id_;
 169
 170   DISALLOW_COPY_AND_ASSIGN(MockDisplayInfoProvider);
 171 };
 172
 173 class SystemDisplayApiTest: public ExtensionApiTest {
 174  public:
 175   SystemDisplayApiTest() : provider_(new MockDisplayInfoProvider),
 176                            screen_(new MockScreen) {}
 177
 178   virtual ~SystemDisplayApiTest() {}
 179
 180   virtual void SetUpOnMainThread() OVERRIDE {
 181     ExtensionApiTest::SetUpOnMainThread();
 182     ANNOTATE_LEAKING_OBJECT_PTR(
 183         gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_NATIVE));
 184     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
 185     DisplayInfoProvider::InitializeForTesting(provider_.get());
 186   }
 187
 188   virtual void TearDownOnMainThread() OVERRIDE {
 189 #if defined(OS_CHROMEOS)
 190     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE,
 191                                    ash::Shell::GetScreen());
 192 #endif
 193     ExtensionApiTest::TearDownOnMainThread();
 194   }
 195
 196  protected:
 197   scoped_ptr<MockDisplayInfoProvider> provider_;
 198   scoped_ptr<gfx::Screen> screen_;
 199
 200  private:
 201   DISALLOW_COPY_AND_ASSIGN(SystemDisplayApiTest);
 202 };
 203
 204 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, GetDisplay) {
 205   ASSERT_TRUE(RunPlatformAppTest("system/display")) << message_;
 206 }
 207
 208 #if !defined(OS_CHROMEOS)
 209 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplay) {
 210   scoped_refptr<SystemDisplaySetDisplayPropertiesFunction>
 211       set_info_function(new SystemDisplaySetDisplayPropertiesFunction());
 212
 213   set_info_function->set_has_callback(true);
 214
 215   EXPECT_EQ("Function available only on ChromeOS.",
 216             utils::RunFunctionAndReturnError(set_info_function.get(),
 217                                              "[\"display_id\", {}]",
 218                                              browser()));
 219
 220   scoped_ptr<base::DictionaryValue> set_info = provider_->GetSetInfoValue();
 221   EXPECT_FALSE(set_info);
 222 }
 223 #endif  // !defined(OS_CHROMEOS)
 224
 225 #if defined(OS_CHROMEOS)
 226 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplayNotKioskEnabled) {
 227   scoped_ptr<base::DictionaryValue> test_extension_value(utils::ParseDictionary(
 228       "{\n"
 229       "  \"name\": \"Test\",\n"
 230       "  \"version\": \"1.0\",\n"
 231       "  \"app\": {\n"
 232       "    \"background\": {\n"
 233       "      \"scripts\": [\"background.js\"]\n"
 234       "    }\n"
 235       "  }\n"
 236       "}"));
 237   scoped_refptr<Extension> test_extension(
 238       utils::CreateExtension(test_extension_value.get()));
 239
 240   scoped_refptr<SystemDisplaySetDisplayPropertiesFunction>
 241       set_info_function(new SystemDisplaySetDisplayPropertiesFunction());
 242
 243   set_info_function->set_extension(test_extension.get());
 244   set_info_function->set_has_callback(true);
 245
 246   EXPECT_EQ("The extension needs to be kiosk enabled to use the function.",
 247             utils::RunFunctionAndReturnError(set_info_function.get(),
 248                                              "[\"display_id\", {}]",
 249                                              browser()));
 250
 251   scoped_ptr<base::DictionaryValue> set_info = provider_->GetSetInfoValue();
 252   EXPECT_FALSE(set_info);
 253 }
 254
 255 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplayKioskEnabled) {
 256   scoped_ptr<base::DictionaryValue> test_extension_value(utils::ParseDictionary(
 257       "{\n"
 258       "  \"name\": \"Test\",\n"
 259       "  \"version\": \"1.0\",\n"
 260       "  \"app\": {\n"
 261       "    \"background\": {\n"
 262       "      \"scripts\": [\"background.js\"]\n"
 263       "    }\n"
 264       "  },\n"
 265       "  \"kiosk_enabled\": true\n"
 266       "}"));
 267   scoped_refptr<Extension> test_extension(
 268       utils::CreateExtension(test_extension_value.get()));
 269
 270   scoped_refptr<SystemDisplaySetDisplayPropertiesFunction>
 271       set_info_function(new SystemDisplaySetDisplayPropertiesFunction());
 272
 273   set_info_function->set_has_callback(true);
 274   set_info_function->set_extension(test_extension.get());
 275
 276   ASSERT_TRUE(utils::RunFunction(
 277       set_info_function.get(),
 278       "[\"display_id\", {\n"
 279       "  \"isPrimary\": true,\n"
 280       "  \"mirroringSourceId\": \"mirroringId\",\n"
 281       "  \"boundsOriginX\": 100,\n"
 282       "  \"boundsOriginY\": 200,\n"
 283       "  \"rotation\": 90,\n"
 284       "  \"overscan\": {\"left\": 1, \"top\": 2, \"right\": 3, \"bottom\": 4}\n"
 285       "}]",
 286       browser(),
 287       utils::NONE));
 288
 289   scoped_ptr<base::DictionaryValue> set_info = provider_->GetSetInfoValue();
 290   ASSERT_TRUE(set_info);
 291   EXPECT_TRUE(utils::GetBoolean(set_info.get(), "isPrimary"));
 292   EXPECT_EQ("mirroringId",
 293             utils::GetString(set_info.get(), "mirroringSourceId"));
 294   EXPECT_EQ(100, utils::GetInteger(set_info.get(), "boundsOriginX"));
 295   EXPECT_EQ(200, utils::GetInteger(set_info.get(), "boundsOriginY"));
 296   EXPECT_EQ(90, utils::GetInteger(set_info.get(), "rotation"));
 297   base::DictionaryValue* overscan;
 298   ASSERT_TRUE(set_info->GetDictionary("overscan", &overscan));
 299   EXPECT_EQ(1, utils::GetInteger(overscan, "left"));
 300   EXPECT_EQ(2, utils::GetInteger(overscan, "top"));
 301   EXPECT_EQ(3, utils::GetInteger(overscan, "right"));
 302   EXPECT_EQ(4, utils::GetInteger(overscan, "bottom"));
 303
 304   EXPECT_EQ("display_id", provider_->GetSetInfoDisplayId());
 305 }
 306 #endif  // defined(OS_CHROMEOS)
 307
 308 }  // namespace extensions