Fixed the Touchscreen.TouchEventsEnabled histogram to record the correct values on X11 and Ozone ba…

chrome/browser/manifest/manifest_icon_selector_unittest.cc

 // Copyright 2015 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 "chrome/browser/manifest/manifest_icon_selector.h"
 
+#include <string>
+#include <vector>
+
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/screen_type_delegate.h"
+#include "ui/gfx/test/test_screen.h"
 
 namespace {
 
 const int kPreferredIconSize = 48;
 
 }
 
-// A dummy implementation of gfx::Screen, since ManifestIconSelector needs
-// access to a gfx::Display's device scale factor.
-// This is inspired by web_contents_video_capture_device_unittest.cc
-// A bug has been opened to merge all those mocks: http://crbug.com/417227
-class FakeScreen : public gfx::Screen {
- public:
-  FakeScreen() : display_(0x1337, gfx::Rect(0, 0, 2560, 1440)) {
-  }
-  ~FakeScreen() override {}
-
-  void SetDisplayDeviceScaleFactor(float device_scale_factor) {
-    display_.set_device_scale_factor(device_scale_factor);
+class ManifestIconSelectorTest : public testing::Test  {
+ protected:
+  ManifestIconSelectorTest() {
+    test_screen_.display()->set_id(0x1337);
+    test_screen_.display()->set_bounds(gfx::Rect(0, 0, 2560, 1440));
   }
 
-  // gfx::Screen implementation (only what's needed for testing).
-  gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
-  gfx::NativeWindow GetWindowUnderCursor() override { return nullptr; }
-  gfx::NativeWindow GetWindowAtScreenPoint(
-      const gfx::Point& point) override { return nullptr; }
-  int GetNumDisplays() const override { return 1; }
-  std::vector<gfx::Display> GetAllDisplays() const override {
-    return std::vector<gfx::Display>(1, display_);
-  }
-  gfx::Display GetDisplayNearestWindow(
-      gfx::NativeView view) const override {
-    return display_;
-  }
-  gfx::Display GetDisplayNearestPoint(
-      const gfx::Point& point) const override {
-    return display_;
-  }
-  gfx::Display GetDisplayMatching(
-      const gfx::Rect& match_rect) const override {
-    return display_;
-  }
-  gfx::Display GetPrimaryDisplay() const override {
-    return display_;
-  }
-  void AddObserver(gfx::DisplayObserver* observer) override {}
-  void RemoveObserver(gfx::DisplayObserver* observer) override {}
-
- private:
-  gfx::Display display_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeScreen);
-};
-
-class ManifestIconSelectorTest : public testing::Test  {
- protected:
-  ManifestIconSelectorTest() {}
   ~ManifestIconSelectorTest() override {}
 
   GURL FindBestMatchingIcon(const std::vector<content::Manifest::Icon>& icons) {
     return ManifestIconSelector::FindBestMatchingIcon(
-        icons,
-        GetPreferredIconSizeInDp(),
-        &fake_screen_);
+        icons, GetPreferredIconSizeInDp(), &test_screen_);
   }
 
   void SetDisplayDeviceScaleFactor(float device_scale_factor) {
-    fake_screen_.SetDisplayDeviceScaleFactor(device_scale_factor);
+    test_screen_.display()->set_device_scale_factor(device_scale_factor);
   }
 
   static int GetPreferredIconSizeInDp() {
     return kPreferredIconSize;
   }
 
   static content::Manifest::Icon CreateIcon(
       const std::string& url,
       const std::string& type,
       double density,
       const std::vector<gfx::Size> sizes) {
     content::Manifest::Icon icon;
     icon.src = GURL(url);
     if (!type.empty())
       icon.type = base::NullableString16(base::UTF8ToUTF16(type), false);
     icon.density = density;
     icon.sizes = sizes;
 
     return icon;
   }
 
  private:
-  FakeScreen fake_screen_;
+  gfx::test::TestScreen test_screen_;
 
   DISALLOW_COPY_AND_ASSIGN(ManifestIconSelectorTest);
 };
 
 TEST_F(ManifestIconSelectorTest, NoIcons) {
   // No icons should return the empty URL.
   std::vector<content::Manifest::Icon> icons;
   GURL url = FindBestMatchingIcon(icons);
   EXPECT_TRUE(url.is_empty());
 }
@@ skipping 302 matching lines @@
   // 'any' (ie. gfx::Size(0,0)) should be used if there is no icon of a
   // preferred size. An icon with the current device scale factor is preferred
   // over one with the default density.
 
   // 'any' with preferred size => preferred size
   {
     std::vector<gfx::Size> sizes_1;
     sizes_1.push_back(gfx::Size(GetPreferredIconSizeInDp(),
                                 GetPreferredIconSizeInDp()));
     std::vector<gfx::Size> sizes_2;
-    sizes_2.push_back(gfx::Size(0,0));
+    sizes_2.push_back(gfx::Size(0, 0));
 
     std::vector<content::Manifest::Icon> icons;
     icons.push_back(CreateIcon("http://foo.com/icon.png", "", 1.0, sizes_1));
     icons.push_back(CreateIcon("http://foo.com/icon_no.png", "", 1.0, sizes_2));
 
     GURL url = FindBestMatchingIcon(icons);
     EXPECT_EQ("http://foo.com/icon.png", url.spec());
   }
 
   // 'any' with nearly preferred size => any
   {
     std::vector<gfx::Size> sizes_1;
     sizes_1.push_back(gfx::Size(GetPreferredIconSizeInDp() + 1,
                                 GetPreferredIconSizeInDp() + 1));
     std::vector<gfx::Size> sizes_2;
-    sizes_2.push_back(gfx::Size(0,0));
+    sizes_2.push_back(gfx::Size(0, 0));
 
     std::vector<content::Manifest::Icon> icons;
     icons.push_back(CreateIcon("http://foo.com/icon_no.png", "", 1.0, sizes_1));
     icons.push_back(CreateIcon("http://foo.com/icon.png", "", 1.0, sizes_2));
 
     GURL url = FindBestMatchingIcon(icons);
     EXPECT_EQ("http://foo.com/icon.png", url.spec());
   }
 
   // 'any' on default density and current density => current density.
   {
     std::vector<gfx::Size> sizes;
-    sizes.push_back(gfx::Size(0,0));
+    sizes.push_back(gfx::Size(0, 0));
 
     std::vector<content::Manifest::Icon> icons;
     icons.push_back(CreateIcon("http://foo.com/icon_no.png", "", 1.0, sizes));
     icons.push_back(CreateIcon("http://foo.com/icon.png", "", 3.0, sizes));
 
     SetDisplayDeviceScaleFactor(3.0f);
     GURL url = FindBestMatchingIcon(icons);
     EXPECT_EQ("http://foo.com/icon.png", url.spec());
   }
 }