ui/display/chromeos/touchscreen_delegate_impl_unittest.cc

   1 // Copyright 2014 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 <vector>
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/memory/scoped_vector.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "ui/display/chromeos/display_configurator.h"
  11 #include "ui/display/chromeos/test/test_display_snapshot.h"
  12 #include "ui/display/chromeos/touchscreen_delegate_impl.h"
  13 #include "ui/display/types/chromeos/touchscreen_device_manager.h"
  14
  15 namespace ui {
  16
  17 namespace {
  18
  19 class MockTouchscreenDeviceManager : public TouchscreenDeviceManager {
  20  public:
  21   MockTouchscreenDeviceManager() {}
  22   virtual ~MockTouchscreenDeviceManager() {}
  23
  24   void AddDevice(const TouchscreenDevice& device) {
  25     devices_.push_back(device);
  26   }
  27
  28   // TouchscreenDeviceManager overrides:
  29   virtual std::vector<TouchscreenDevice> GetDevices() OVERRIDE {
  30     return devices_;
  31   }
  32
  33  private:
  34   std::vector<TouchscreenDevice> devices_;
  35
  36   DISALLOW_COPY_AND_ASSIGN(MockTouchscreenDeviceManager);
  37 };
  38
  39 }  // namespace
  40
  41 class TouchscreenDelegateImplTest : public testing::Test {
  42  public:
  43   TouchscreenDelegateImplTest() {}
  44   virtual ~TouchscreenDelegateImplTest() {}
  45
  46   virtual void SetUp() OVERRIDE {
  47     device_manager_ = new MockTouchscreenDeviceManager();
  48     delegate_.reset(new TouchscreenDelegateImpl(
  49         scoped_ptr<TouchscreenDeviceManager>(device_manager_)));
  50
  51     // Internal display will always match to internal touchscreen. If internal
  52     // touchscreen can't be detected, it is then associated to a touch screen
  53     // with matching size.
  54     TestDisplaySnapshot* snapshot = new TestDisplaySnapshot();
  55     DisplayMode* mode = new DisplayMode(gfx::Size(1920, 1080), false, 60.0);
  56     snapshot->set_type(DISPLAY_CONNECTION_TYPE_INTERNAL);
  57     snapshot->set_modes(std::vector<const DisplayMode*>(1, mode));
  58     snapshot->set_native_mode(mode);
  59     displays_.push_back(snapshot);
  60
  61     snapshot = new TestDisplaySnapshot();
  62     mode = new DisplayMode(gfx::Size(800, 600), false, 60.0);
  63     snapshot->set_modes(std::vector<const DisplayMode*>(1, mode));
  64     snapshot->set_native_mode(mode);
  65     displays_.push_back(snapshot);
  66
  67     // Display without native mode. Must not be matched to any touch screen.
  68     displays_.push_back(new TestDisplaySnapshot());
  69
  70     snapshot = new TestDisplaySnapshot();
  71     mode = new DisplayMode(gfx::Size(1024, 768), false, 60.0);
  72     snapshot->set_modes(std::vector<const DisplayMode*>(1, mode));
  73     snapshot->set_native_mode(mode);
  74     displays_.push_back(snapshot);
  75   }
  76
  77   virtual void TearDown() OVERRIDE {
  78     // The snapshots do not own the modes, so we need to delete them.
  79     for (size_t i = 0; i < displays_.size(); ++i) {
  80       if (displays_[i]->native_mode())
  81         delete displays_[i]->native_mode();
  82     }
  83
  84     displays_.clear();
  85   }
  86
  87   std::vector<DisplayConfigurator::DisplayState> GetDisplayStates() {
  88     std::vector<DisplayConfigurator::DisplayState> states(displays_.size());
  89     for (size_t i = 0; i < displays_.size(); ++i)
  90       states[i].display = displays_[i];
  91
  92     return states;
  93   }
  94
  95  protected:
  96   MockTouchscreenDeviceManager* device_manager_;  // Not owned.
  97   scoped_ptr<TouchscreenDelegateImpl> delegate_;
  98   ScopedVector<DisplaySnapshot> displays_;
  99
 100  private:
 101   DISALLOW_COPY_AND_ASSIGN(TouchscreenDelegateImplTest);
 102 };
 103
 104 TEST_F(TouchscreenDelegateImplTest, NoTouchscreens) {
 105   std::vector<DisplayConfigurator::DisplayState> display_states =
 106       GetDisplayStates();
 107   delegate_->AssociateTouchscreens(&display_states);
 108
 109   for (size_t i = 0; i < display_states.size(); ++i)
 110     EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[i].touch_device_id);
 111 }
 112
 113 TEST_F(TouchscreenDelegateImplTest, OneToOneMapping) {
 114   device_manager_->AddDevice(TouchscreenDevice(1, gfx::Size(800, 600), false));
 115   device_manager_->AddDevice(TouchscreenDevice(2, gfx::Size(1024, 768), false));
 116
 117   std::vector<DisplayConfigurator::DisplayState> display_states =
 118       GetDisplayStates();
 119   delegate_->AssociateTouchscreens(&display_states);
 120
 121   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[0].touch_device_id);
 122   EXPECT_EQ(1, display_states[1].touch_device_id);
 123   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[2].touch_device_id);
 124   EXPECT_EQ(2, display_states[3].touch_device_id);
 125 }
 126
 127 TEST_F(TouchscreenDelegateImplTest, MapToCorrectDisplaySize) {
 128   device_manager_->AddDevice(TouchscreenDevice(2, gfx::Size(1024, 768), false));
 129
 130   std::vector<DisplayConfigurator::DisplayState> display_states =
 131       GetDisplayStates();
 132   delegate_->AssociateTouchscreens(&display_states);
 133
 134   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[0].touch_device_id);
 135   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[1].touch_device_id);
 136   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[2].touch_device_id);
 137   EXPECT_EQ(2, display_states[3].touch_device_id);
 138 }
 139
 140 TEST_F(TouchscreenDelegateImplTest, MapWhenSizeDiffersByOne) {
 141   device_manager_->AddDevice(TouchscreenDevice(1, gfx::Size(801, 600), false));
 142   device_manager_->AddDevice(TouchscreenDevice(2, gfx::Size(1023, 768), false));
 143
 144   std::vector<DisplayConfigurator::DisplayState> display_states =
 145       GetDisplayStates();
 146   delegate_->AssociateTouchscreens(&display_states);
 147
 148   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[0].touch_device_id);
 149   EXPECT_EQ(1, display_states[1].touch_device_id);
 150   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[2].touch_device_id);
 151   EXPECT_EQ(2, display_states[3].touch_device_id);
 152 }
 153
 154 TEST_F(TouchscreenDelegateImplTest, MapWhenSizesDoNotMatch) {
 155   device_manager_->AddDevice(TouchscreenDevice(1, gfx::Size(1022, 768), false));
 156   device_manager_->AddDevice(TouchscreenDevice(2, gfx::Size(802, 600), false));
 157
 158   std::vector<DisplayConfigurator::DisplayState> display_states =
 159       GetDisplayStates();
 160   delegate_->AssociateTouchscreens(&display_states);
 161
 162   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[0].touch_device_id);
 163   EXPECT_EQ(1, display_states[1].touch_device_id);
 164   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[2].touch_device_id);
 165   EXPECT_EQ(2, display_states[3].touch_device_id);
 166 }
 167
 168 TEST_F(TouchscreenDelegateImplTest, MapInternalTouchscreen) {
 169   device_manager_->AddDevice(
 170       TouchscreenDevice(1, gfx::Size(1920, 1080), false));
 171   device_manager_->AddDevice(TouchscreenDevice(2, gfx::Size(9999, 888), true));
 172
 173   std::vector<DisplayConfigurator::DisplayState> display_states =
 174       GetDisplayStates();
 175   delegate_->AssociateTouchscreens(&display_states);
 176
 177   // Internal touchscreen is always mapped to internal display.
 178   EXPECT_EQ(2, display_states[0].touch_device_id);
 179   EXPECT_EQ(1, display_states[1].touch_device_id);
 180   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[2].touch_device_id);
 181   EXPECT_EQ(TouchscreenDevice::kInvalidId, display_states[3].touch_device_id);
 182 }
 183
 184 }  // namespace ui