Move system.display tests to extensions/

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 "base/debug/leak_annotations.h"
 #include "base/strings/string_number_conversions.h"
-#include "chrome/browser/extensions/extension_apitest.h"
-#include "chrome/browser/extensions/extension_function_test_utils.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 "ui/gfx/display.h"
 #include "ui/gfx/display_observer.h"
 #include "ui/gfx/screen.h"
 
-#if defined(OS_CHROMEOS)
-#include "ash/display/screen_ash.h"
-#include "ash/shell.h"
-#endif
-
-namespace utils = extension_function_test_utils;
-
 namespace extensions {
 
 using core_api::system_display::Bounds;
 using core_api::system_display::DisplayUnitInfo;
 using gfx::Screen;
 
-#if defined(OS_CHROMEOS)
-class MockScreen : public ash::ScreenAsh {
- public:
-  MockScreen() {
-    for (int i = 0; i < 4; i++) {
-      gfx::Rect bounds(0, 0, 1280, 720);
-      gfx::Rect work_area(0, 0, 960, 720);
-      gfx::Display display(i, bounds);
-      display.set_work_area(work_area);
-      displays_.push_back(display);
-    }
-  }
-  virtual ~MockScreen() {}
-
- protected:
-  // Overridden from gfx::Screen:
-  virtual int GetNumDisplays() const override {
-    return displays_.size();
-  }
-  virtual std::vector<gfx::Display> GetAllDisplays() const override {
-    return displays_;
-  }
-  virtual gfx::Display GetPrimaryDisplay() const override {
-    return displays_[0];
-  }
-
- private:
-  std::vector<gfx::Display> displays_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockScreen);
-};
-#else
 class MockScreen : public Screen {
  public:
   MockScreen() {
     for (int i = 0; i < 4; i++) {
       gfx::Rect bounds(0, 0, 1280, 720);
       gfx::Rect work_area(0, 0, 960, 720);
       gfx::Display display(i, bounds);
       display.set_work_area(work_area);
       displays_.push_back(display);
     }
   }
   ~MockScreen() override {}
 
  protected:
   // Overridden from gfx::Screen:
   gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
   gfx::NativeWindow GetWindowUnderCursor() override {
     return gfx::NativeWindow();
   }
   gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override {
     return gfx::NativeWindow();
   }
-  int GetNumDisplays() const override { return displays_.size(); }
+  int GetNumDisplays() const override {
+    return static_cast<int>(displays_.size());
+  }
   std::vector<gfx::Display> GetAllDisplays() const override {
     return displays_;
   }
   gfx::Display GetDisplayNearestWindow(gfx::NativeView window) const override {
     return gfx::Display(0);
   }
   gfx::Display GetDisplayNearestPoint(const gfx::Point& point) const override {
     return gfx::Display(0);
   }
   gfx::Display GetDisplayMatching(const gfx::Rect& match_rect) const override {
     return gfx::Display(0);
   }
   gfx::Display GetPrimaryDisplay() const override { return displays_[0]; }
   void AddObserver(gfx::DisplayObserver* observer) override {}
   void RemoveObserver(gfx::DisplayObserver* observer) override {}
 
  private:
   std::vector<gfx::Display> displays_;
 
   DISALLOW_COPY_AND_ASSIGN(MockScreen);
 };

[James Cook, 2014/12/19 18:07:03]

It's great you were able to get rid of this #ifdef chromeos block!

-#endif
 
 class MockDisplayInfoProvider : public DisplayInfoProvider {
  public:
   MockDisplayInfoProvider() {}
 
   ~MockDisplayInfoProvider() override {}
 
   bool SetInfo(const std::string& display_id,
                const core_api::system_display::DisplayProperties& params,
                std::string* error) override {
     // Should get called only once per test case.
     EXPECT_FALSE(set_info_value_);
     set_info_value_ = params.ToValue();
     set_info_display_id_ = display_id;
     return true;
   }
 
   gfx::Screen* GetActiveScreen() override { return NULL; }
 
   scoped_ptr<base::DictionaryValue> GetSetInfoValue() {
     return set_info_value_.Pass();
   }
 
-  std::string GetSetInfoDisplayId() const {
-    return set_info_display_id_;
-  }
+  std::string GetSetInfoDisplayId() const { return set_info_display_id_; }
 
  private:
   // Update the content of the |unit| obtained for |display| using
   // platform specific method.
   void UpdateDisplayUnitInfoForPlatform(
       const gfx::Display& display,
       extensions::core_api::system_display::DisplayUnitInfo* unit) override {
     int64 id = display.id();
     unit->name = "DISPLAY NAME FOR " + base::Int64ToString(id);
     if (id == 1)
@@ skipping 11 matching lines @@
       unit->overscan.bottom = 80;
     }
   }
 
   scoped_ptr<base::DictionaryValue> set_info_value_;
   std::string set_info_display_id_;
 
   DISALLOW_COPY_AND_ASSIGN(MockDisplayInfoProvider);
 };
 
-class SystemDisplayApiTest: public ExtensionApiTest {
+class SystemDisplayApiTest : public ShellApiTest {
  public:
-  SystemDisplayApiTest() : provider_(new MockDisplayInfoProvider),
-                           screen_(new MockScreen) {}
+  SystemDisplayApiTest()
+      : provider_(new MockDisplayInfoProvider), screen_(new MockScreen) {}
 
   ~SystemDisplayApiTest() override {}
 
   void SetUpOnMainThread() override {
-    ExtensionApiTest::SetUpOnMainThread();
+    ShellApiTest::SetUpOnMainThread();
     ANNOTATE_LEAKING_OBJECT_PTR(
         gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_NATIVE));
     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
     DisplayInfoProvider::InitializeForTesting(provider_.get());
   }
 
-  void TearDownOnMainThread() override {
-#if defined(OS_CHROMEOS)
-    gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE,
-                                   ash::Shell::GetScreen());
-#endif
-    ExtensionApiTest::TearDownOnMainThread();
-  }
-
  protected:
   scoped_ptr<MockDisplayInfoProvider> provider_;
   scoped_ptr<gfx::Screen> screen_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SystemDisplayApiTest);
 };
 
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, GetDisplay) {
-  ASSERT_TRUE(RunPlatformAppTest("system/display")) << message_;
+  ASSERT_TRUE(RunAppTest("system/display")) << message_;
 }
 
 #if !defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplay) {
-  scoped_refptr<SystemDisplaySetDisplayPropertiesFunction>
-      set_info_function(new SystemDisplaySetDisplayPropertiesFunction());
+  scoped_refptr<SystemDisplaySetDisplayPropertiesFunction> set_info_function(
+      new SystemDisplaySetDisplayPropertiesFunction());
 
   set_info_function->set_has_callback(true);
 
-  EXPECT_EQ("Function available only on ChromeOS.",
-            utils::RunFunctionAndReturnError(set_info_function.get(),
-                                             "[\"display_id\", {}]",
-                                             browser()));
+  EXPECT_EQ(
+      "Function available only on ChromeOS.",
+      api_test_utils::RunFunctionAndReturnError(
+          set_info_function.get(), "[\"display_id\", {}]", browser_context()));
 
   scoped_ptr<base::DictionaryValue> set_info = provider_->GetSetInfoValue();
   EXPECT_FALSE(set_info);
 }
 #endif  // !defined(OS_CHROMEOS)
 
 #if defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplayNotKioskEnabled) {
-  scoped_ptr<base::DictionaryValue> test_extension_value(utils::ParseDictionary(
-      "{\n"
-      "  \"name\": \"Test\",\n"
-      "  \"version\": \"1.0\",\n"
-      "  \"app\": {\n"
-      "    \"background\": {\n"
-      "      \"scripts\": [\"background.js\"]\n"
-      "    }\n"
-      "  }\n"
-      "}"));
+  scoped_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"
+          "}"));
   scoped_refptr<Extension> test_extension(
-      utils::CreateExtension(test_extension_value.get()));
+      api_test_utils::CreateExtension(test_extension_value.get()));
 
-  scoped_refptr<SystemDisplaySetDisplayPropertiesFunction>
-      set_info_function(new SystemDisplaySetDisplayPropertiesFunction());
+  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("The extension needs to be kiosk enabled to use the function.",
-            utils::RunFunctionAndReturnError(set_info_function.get(),
-                                             "[\"display_id\", {}]",
-                                             browser()));
+  EXPECT_EQ(
+      "The extension needs to be kiosk enabled to use the function.",
+      api_test_utils::RunFunctionAndReturnError(
+          set_info_function.get(), "[\"display_id\", {}]", browser_context()));
 
   scoped_ptr<base::DictionaryValue> set_info = provider_->GetSetInfoValue();
   EXPECT_FALSE(set_info);
 }
 
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplayKioskEnabled) {
-  scoped_ptr<base::DictionaryValue> test_extension_value(utils::ParseDictionary(
-      "{\n"
-      "  \"name\": \"Test\",\n"
-      "  \"version\": \"1.0\",\n"
-      "  \"app\": {\n"
-      "    \"background\": {\n"
-      "      \"scripts\": [\"background.js\"]\n"
-      "    }\n"
-      "  },\n"
-      "  \"kiosk_enabled\": true\n"
-      "}"));
+  scoped_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"
+          "}"));
   scoped_refptr<Extension> test_extension(
-      utils::CreateExtension(test_extension_value.get()));
+      api_test_utils::CreateExtension(test_extension_value.get()));
 
-  scoped_refptr<SystemDisplaySetDisplayPropertiesFunction>
-      set_info_function(new SystemDisplaySetDisplayPropertiesFunction());
+  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(utils::RunFunction(
+  ASSERT_TRUE(api_test_utils::RunFunction(
       set_info_function.get(),
       "[\"display_id\", {\n"
       "  \"isPrimary\": true,\n"
       "  \"mirroringSourceId\": \"mirroringId\",\n"
       "  \"boundsOriginX\": 100,\n"
       "  \"boundsOriginY\": 200,\n"
       "  \"rotation\": 90,\n"
       "  \"overscan\": {\"left\": 1, \"top\": 2, \"right\": 3, \"bottom\": 4}\n"
       "}]",
-      browser(),
-      utils::NONE));
+      browser_context()));
 
   scoped_ptr<base::DictionaryValue> set_info = provider_->GetSetInfoValue();
   ASSERT_TRUE(set_info);
-  EXPECT_TRUE(utils::GetBoolean(set_info.get(), "isPrimary"));
+  EXPECT_TRUE(api_test_utils::GetBoolean(set_info.get(), "isPrimary"));
   EXPECT_EQ("mirroringId",
-            utils::GetString(set_info.get(), "mirroringSourceId"));
-  EXPECT_EQ(100, utils::GetInteger(set_info.get(), "boundsOriginX"));
-  EXPECT_EQ(200, utils::GetInteger(set_info.get(), "boundsOriginY"));
-  EXPECT_EQ(90, utils::GetInteger(set_info.get(), "rotation"));
+            api_test_utils::GetString(set_info.get(), "mirroringSourceId"));
+  EXPECT_EQ(100, api_test_utils::GetInteger(set_info.get(), "boundsOriginX"));
+  EXPECT_EQ(200, api_test_utils::GetInteger(set_info.get(), "boundsOriginY"));
+  EXPECT_EQ(90, api_test_utils::GetInteger(set_info.get(), "rotation"));
   base::DictionaryValue* overscan;
   ASSERT_TRUE(set_info->GetDictionary("overscan", &overscan));
-  EXPECT_EQ(1, utils::GetInteger(overscan, "left"));
-  EXPECT_EQ(2, utils::GetInteger(overscan, "top"));
-  EXPECT_EQ(3, utils::GetInteger(overscan, "right"));
-  EXPECT_EQ(4, utils::GetInteger(overscan, "bottom"));
+  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());
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace extensions