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

content/browser/media/capture/web_contents_video_capture_device_unittest.cc

 // Copyright (c) 2012 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 "content/browser/media/capture/web_contents_video_capture_device.h"
 
 #include "base/bind_helpers.h"
 #include "base/debug/debugger.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 20 matching lines @@
 #include "media/base/video_util.h"
 #include "media/base/yuv_convert.h"
 #include "skia/ext/platform_canvas.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/layout.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/screen.h"
+#include "ui/gfx/test/test_screen.h"
 
 namespace content {
 namespace {
 
 const int kTestWidth = 320;
 const int kTestHeight = 240;
 const int kTestFramesPerSecond = 20;
 const float kTestDeviceScaleFactor = 2.0f;
 const SkColor kNothingYet = 0xdeadbeef;
 const SkColor kNotInterested = ~kNothingYet;
@@ skipping 482 matching lines @@
  private:
   base::Lock lock_;
   bool error_encountered_;
   SkColor wait_color_yuv_;
   gfx::Size wait_size_;
   scoped_ptr<StubClient> client_;
 
   DISALLOW_COPY_AND_ASSIGN(StubClientObserver);
 };
 
-// A dummy implementation of gfx::Screen, since WebContentsVideoCaptureDevice
-// needs access to a gfx::Display's device scale factor.
-class FakeScreen : public gfx::Screen {
- public:
-  FakeScreen() : the_one_display_(0x1337, gfx::Rect(0, 0, 2560, 1440)) {
-    the_one_display_.set_device_scale_factor(kTestDeviceScaleFactor);
-  }
-  ~FakeScreen() override {}
-
-  // gfx::Screen implementation (only what's needed for testing).
-  gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
-  gfx::NativeWindow GetWindowUnderCursor() override { return NULL; }
-  gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override {
-    return NULL;
-  }
-  int GetNumDisplays() const override { return 1; }
-  std::vector<gfx::Display> GetAllDisplays() const override {
-    return std::vector<gfx::Display>(1, the_one_display_);
-  }
-  gfx::Display GetDisplayNearestWindow(gfx::NativeView view) const override {
-    return the_one_display_;
-  }
-  gfx::Display GetDisplayNearestPoint(const gfx::Point& point) const override {
-    return the_one_display_;
-  }
-  gfx::Display GetDisplayMatching(const gfx::Rect& match_rect) const override {
-    return the_one_display_;
-  }
-  gfx::Display GetPrimaryDisplay() const override { return the_one_display_; }
-  void AddObserver(gfx::DisplayObserver* observer) override {}
-  void RemoveObserver(gfx::DisplayObserver* observer) override {}
-
- private:
-  gfx::Display the_one_display_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeScreen);
-};
-
 // Test harness that sets up a minimal environment with necessary stubs.
 class WebContentsVideoCaptureDeviceTest : public testing::Test {
  public:
   // This is public because C++ method pointer scoping rules are silly and make
   // this hard to use with Bind().
   void ResetWebContents() {
     web_contents_.reset();
   }
 
  protected:
   void SetUp() override {
-    gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, &fake_screen_);
-    ASSERT_EQ(&fake_screen_, gfx::Screen::GetNativeScreen());
+    test_screen_.display()->set_id(0x1337);
+    test_screen_.display()->set_bounds(gfx::Rect(0, 0, 2560, 1440));
+    test_screen_.display()->set_device_scale_factor(kTestDeviceScaleFactor);
+
+    gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, &test_screen_);
+    ASSERT_EQ(&test_screen_, gfx::Screen::GetNativeScreen());
 
     // TODO(nick): Sadness and woe! Much "mock-the-world" boilerplate could be
     // eliminated here, if only we could use RenderViewHostTestHarness. The
     // catch is that we need our TestRenderViewHost to support a
     // CopyFromBackingStore operation that we control. To accomplish that,
     // either RenderViewHostTestHarness would have to support installing a
     // custom RenderViewHostFactory, or else we implant some kind of delegated
     // CopyFromBackingStore functionality into TestRenderViewHost itself.
 
     render_process_host_factory_.reset(new MockRenderProcessHostFactory());
@@ skipping 44 matching lines @@
 
     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, NULL);
   }
 
   // Accessors.
   CaptureTestSourceController* source() { return &controller_; }
   WebContents* web_contents() const { return web_contents_.get(); }
   media::VideoCaptureDevice* device() { return device_.get(); }
 
   // Returns the device scale factor of the capture target's native view.  This
-  // is necessary because, architecturally, the FakeScreen implementation is
+  // is necessary because, architecturally, the TestScreen implementation is
   // ignored on Mac platforms (when determining the device scale factor for a
   // particular window).
   float GetDeviceScaleFactor() const {
     RenderWidgetHostView* const view =
         web_contents_->GetRenderViewHost()->GetView();
     CHECK(view);
     return ui::GetScaleFactorForNativeView(view->GetNativeView());
   }
 
   void SimulateDrawEvent() {
@@ skipping 27 matching lines @@
         as_web_contents_impl->GetMainFrame()->GetRenderWidgetHost(), true);
   }
 
   void DestroyVideoCaptureDevice() { device_.reset(); }
 
   StubClientObserver* client_observer() {
     return &client_observer_;
   }
 
  private:
-  FakeScreen fake_screen_;
+  gfx::test::TestScreen test_screen_;
 
   StubClientObserver client_observer_;
 
   // The controller controls which pixel patterns to produce.
   CaptureTestSourceController controller_;
 
   // Self-registering RenderProcessHostFactory.
   scoped_ptr<MockRenderProcessHostFactory> render_process_host_factory_;
 
   // Creates capture-capable RenderViewHosts whose pixel content production is
@@ skipping 328 matching lines @@
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColorAndFrameSize(
       SK_ColorBLACK, gfx::Size(kTestWidth,
                                kTestWidth * arbitrary_source_size.height() /
                                    arbitrary_source_size.width())));
 
   device()->StopAndDeAllocate();
 }
 
 }  // namespace
 }  // namespace content