ui/display/chromeos/display_configurator_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 "ui/display/chromeos/display_configurator.h"
   6
   7 #include <stdint.h>
   8
   9 #include <cmath>
  10 #include <cstdarg>
  11 #include <map>
  12 #include <string>
  13 #include <vector>
  14
  15 #include "base/compiler_specific.h"
  16 #include "base/format_macros.h"
  17 #include "base/memory/scoped_vector.h"
  18 #include "base/message_loop/message_loop.h"
  19 #include "base/strings/stringprintf.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21 #include "ui/display/chromeos/test/test_display_snapshot.h"
  22 #include "ui/display/types/chromeos/display_mode.h"
  23 #include "ui/display/types/chromeos/native_display_delegate.h"
  24
  25 namespace ui {
  26
  27 namespace {
  28
  29 // Strings returned by TestNativeDisplayDelegate::GetActionsAndClear() to
  30 // describe various actions that were performed.
  31 const char kInitXRandR[] = "init";
  32 const char kGrab[] = "grab";
  33 const char kUngrab[] = "ungrab";
  34 const char kSync[] = "sync";
  35 const char kForceDPMS[] = "dpms";
  36
  37 // String returned by TestNativeDisplayDelegate::GetActionsAndClear() if no
  38 // actions were requested.
  39 const char kNoActions[] = "";
  40
  41 std::string DisplaySnapshotToString(const DisplaySnapshot& output) {
  42   return base::StringPrintf("id=%" PRId64, output.display_id());
  43 }
  44
  45 // Returns a string describing a TestNativeDisplayDelegate::SetBackgroundColor()
  46 // call.
  47 std::string GetBackgroundAction(uint32_t color_argb) {
  48   return base::StringPrintf("background(0x%x)", color_argb);
  49 }
  50
  51 // Returns a string describing a TestNativeDisplayDelegate::AddOutputMode()
  52 // call.
  53 std::string GetAddOutputModeAction(const DisplaySnapshot& output,
  54                                    const DisplayMode* mode) {
  55   return base::StringPrintf("add_mode(output=%" PRId64 ",mode=%s)",
  56                             output.display_id(),
  57                             mode->ToString().c_str());
  58 }
  59
  60 // Returns a string describing a TestNativeDisplayDelegate::Configure()
  61 // call.
  62 std::string GetCrtcAction(const DisplaySnapshot& output,
  63                           const DisplayMode* mode,
  64                           const gfx::Point& origin) {
  65   return base::StringPrintf("crtc(display=[%s],x=%d,y=%d,mode=[%s])",
  66                             DisplaySnapshotToString(output).c_str(),
  67                             origin.x(),
  68                             origin.y(),
  69                             mode ? mode->ToString().c_str() : "NULL");
  70 }
  71
  72 // Returns a string describing a TestNativeDisplayDelegate::CreateFramebuffer()
  73 // call.
  74 std::string GetFramebufferAction(const gfx::Size& size,
  75                                  const DisplaySnapshot* out1,
  76                                  const DisplaySnapshot* out2) {
  77   return base::StringPrintf(
  78       "framebuffer(width=%d,height=%d,display1=%s,display2=%s)",
  79       size.width(),
  80       size.height(),
  81       out1 ? DisplaySnapshotToString(*out1).c_str() : "NULL",
  82       out2 ? DisplaySnapshotToString(*out2).c_str() : "NULL");
  83 }
  84
  85 // Returns a string describing a TestNativeDisplayDelegate::SetHDCPState() call.
  86 std::string GetSetHDCPStateAction(const DisplaySnapshot& output,
  87                                   HDCPState state) {
  88   return base::StringPrintf(
  89       "set_hdcp(id=%" PRId64 ",state=%d)", output.display_id(), state);
  90 }
  91
  92 // Joins a sequence of strings describing actions (e.g. kScreenDim) such
  93 // that they can be compared against a string returned by
  94 // ActionLogger::GetActionsAndClear().  The list of actions must be
  95 // terminated by a NULL pointer.
  96 std::string JoinActions(const char* action, ...) {
  97   std::string actions;
  98
  99   va_list arg_list;
 100   va_start(arg_list, action);
 101   while (action) {
 102     if (!actions.empty())
 103       actions += ",";
 104     actions += action;
 105     action = va_arg(arg_list, const char*);
 106   }
 107   va_end(arg_list);
 108   return actions;
 109 }
 110
 111 class ActionLogger {
 112  public:
 113   ActionLogger() {}
 114
 115   void AppendAction(const std::string& action) {
 116     if (!actions_.empty())
 117       actions_ += ",";
 118     actions_ += action;
 119   }
 120
 121   // Returns a comma-separated string describing the actions that were
 122   // requested since the previous call to GetActionsAndClear() (i.e.
 123   // results are non-repeatable).
 124   std::string GetActionsAndClear() {
 125     std::string actions = actions_;
 126     actions_.clear();
 127     return actions;
 128   }
 129
 130  private:
 131   std::string actions_;
 132
 133   DISALLOW_COPY_AND_ASSIGN(ActionLogger);
 134 };
 135
 136 class TestTouchscreenDelegate
 137     : public DisplayConfigurator::TouchscreenDelegate {
 138  public:
 139   // Ownership of |log| remains with the caller.
 140   explicit TestTouchscreenDelegate(ActionLogger* log)
 141       : log_(log),
 142         configure_touchscreens_(false) {}
 143   virtual ~TestTouchscreenDelegate() {}
 144
 145   void set_configure_touchscreens(bool state) {
 146     configure_touchscreens_ = state;
 147   }
 148
 149   // DisplayConfigurator::TouchscreenDelegate implementation:
 150   virtual void AssociateTouchscreens(
 151       DisplayConfigurator::DisplayStateList* outputs) OVERRIDE {
 152     if (configure_touchscreens_) {
 153       for (size_t i = 0; i < outputs->size(); ++i)
 154         (*outputs)[i].touch_device_id = i + 1;
 155     }
 156   }
 157
 158  private:
 159   ActionLogger* log_;  // Not owned.
 160
 161   bool configure_touchscreens_;
 162
 163   DISALLOW_COPY_AND_ASSIGN(TestTouchscreenDelegate);
 164 };
 165
 166 class TestNativeDisplayDelegate : public NativeDisplayDelegate {
 167  public:
 168   // Ownership of |log| remains with the caller.
 169   explicit TestNativeDisplayDelegate(ActionLogger* log)
 170       : max_configurable_pixels_(0),
 171         hdcp_state_(HDCP_STATE_UNDESIRED),
 172         log_(log) {}
 173   virtual ~TestNativeDisplayDelegate() {}
 174
 175   const std::vector<DisplaySnapshot*>& outputs() const { return outputs_; }
 176   void set_outputs(const std::vector<DisplaySnapshot*>& outputs) {
 177     outputs_ = outputs;
 178   }
 179
 180   void set_max_configurable_pixels(int pixels) {
 181     max_configurable_pixels_ = pixels;
 182   }
 183
 184   void set_hdcp_state(HDCPState state) { hdcp_state_ = state; }
 185
 186   // DisplayConfigurator::Delegate overrides:
 187   virtual void Initialize() OVERRIDE { log_->AppendAction(kInitXRandR); }
 188   virtual void GrabServer() OVERRIDE { log_->AppendAction(kGrab); }
 189   virtual void UngrabServer() OVERRIDE { log_->AppendAction(kUngrab); }
 190   virtual void SyncWithServer() OVERRIDE { log_->AppendAction(kSync); }
 191   virtual void SetBackgroundColor(uint32_t color_argb) OVERRIDE {
 192     log_->AppendAction(GetBackgroundAction(color_argb));
 193   }
 194   virtual void ForceDPMSOn() OVERRIDE { log_->AppendAction(kForceDPMS); }
 195   virtual std::vector<DisplaySnapshot*> GetDisplays() OVERRIDE {
 196     return outputs_;
 197   }
 198   virtual void AddMode(const DisplaySnapshot& output,
 199                        const DisplayMode* mode) OVERRIDE {
 200     log_->AppendAction(GetAddOutputModeAction(output, mode));
 201   }
 202   virtual bool Configure(const DisplaySnapshot& output,
 203                          const DisplayMode* mode,
 204                          const gfx::Point& origin) OVERRIDE {
 205     log_->AppendAction(GetCrtcAction(output, mode, origin));
 206
 207     if (max_configurable_pixels_ == 0)
 208       return true;
 209
 210     if (!mode)
 211       return false;
 212
 213     return mode->size().GetArea() <= max_configurable_pixels_;
 214   }
 215   virtual void CreateFrameBuffer(const gfx::Size& size) OVERRIDE {
 216     log_->AppendAction(
 217         GetFramebufferAction(size,
 218                              outputs_.size() >= 1 ? outputs_[0] : NULL,
 219                              outputs_.size() >= 2 ? outputs_[1] : NULL));
 220   }
 221   virtual bool GetHDCPState(const DisplaySnapshot& output,
 222                             HDCPState* state) OVERRIDE {
 223     *state = hdcp_state_;
 224     return true;
 225   }
 226
 227   virtual bool SetHDCPState(const DisplaySnapshot& output,
 228                             HDCPState state) OVERRIDE {
 229     log_->AppendAction(GetSetHDCPStateAction(output, state));
 230     return true;
 231   }
 232
 233   virtual std::vector<ui::ColorCalibrationProfile>
 234   GetAvailableColorCalibrationProfiles(const DisplaySnapshot& output) OVERRIDE {
 235     return std::vector<ui::ColorCalibrationProfile>();
 236   }
 237
 238   virtual bool SetColorCalibrationProfile(
 239       const DisplaySnapshot& output,
 240       ui::ColorCalibrationProfile new_profile) OVERRIDE {
 241     return false;
 242   }
 243
 244   virtual void AddObserver(NativeDisplayObserver* observer) OVERRIDE {}
 245
 246   virtual void RemoveObserver(NativeDisplayObserver* observer) OVERRIDE {}
 247
 248  private:
 249   // Outputs to be returned by GetDisplays().
 250   std::vector<DisplaySnapshot*> outputs_;
 251
 252   // |max_configurable_pixels_| represents the maximum number of pixels that
 253   // Configure will support.  Tests can use this to force Configure
 254   // to fail if attempting to set a resolution that is higher than what
 255   // a device might support under a given circumstance.
 256   // A value of 0 means that no limit is enforced and Configure will
 257   // return success regardless of the resolution.
 258   int max_configurable_pixels_;
 259
 260   // Result value of GetHDCPState().
 261   HDCPState hdcp_state_;
 262
 263   ActionLogger* log_;  // Not owned.
 264
 265   DISALLOW_COPY_AND_ASSIGN(TestNativeDisplayDelegate);
 266 };
 267
 268 class TestObserver : public DisplayConfigurator::Observer {
 269  public:
 270   explicit TestObserver(DisplayConfigurator* configurator)
 271       : configurator_(configurator) {
 272     Reset();
 273     configurator_->AddObserver(this);
 274   }
 275   virtual ~TestObserver() { configurator_->RemoveObserver(this); }
 276
 277   int num_changes() const { return num_changes_; }
 278   int num_failures() const { return num_failures_; }
 279   const DisplayConfigurator::DisplayStateList& latest_outputs() const {
 280     return latest_outputs_;
 281   }
 282   MultipleDisplayState latest_failed_state() const {
 283     return latest_failed_state_;
 284   }
 285
 286   void Reset() {
 287     num_changes_ = 0;
 288     num_failures_ = 0;
 289     latest_outputs_.clear();
 290     latest_failed_state_ = MULTIPLE_DISPLAY_STATE_INVALID;
 291   }
 292
 293   // DisplayConfigurator::Observer overrides:
 294   virtual void OnDisplayModeChanged(
 295       const DisplayConfigurator::DisplayStateList& outputs) OVERRIDE {
 296     num_changes_++;
 297     latest_outputs_ = outputs;
 298   }
 299
 300   virtual void OnDisplayModeChangeFailed(MultipleDisplayState failed_new_state)
 301       OVERRIDE {
 302     num_failures_++;
 303     latest_failed_state_ = failed_new_state;
 304   }
 305
 306  private:
 307   DisplayConfigurator* configurator_;  // Not owned.
 308
 309   // Number of times that OnDisplayMode*() has been called.
 310   int num_changes_;
 311   int num_failures_;
 312
 313   // Parameters most recently passed to OnDisplayMode*().
 314   DisplayConfigurator::DisplayStateList latest_outputs_;
 315   MultipleDisplayState latest_failed_state_;
 316
 317   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 318 };
 319
 320 class TestStateController : public DisplayConfigurator::StateController {
 321  public:
 322   TestStateController() : state_(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED) {}
 323   virtual ~TestStateController() {}
 324
 325   void set_state(MultipleDisplayState state) { state_ = state; }
 326
 327   // DisplayConfigurator::StateController overrides:
 328   virtual MultipleDisplayState GetStateForDisplayIds(
 329       const std::vector<int64_t>& outputs) const OVERRIDE {
 330     return state_;
 331   }
 332   virtual bool GetResolutionForDisplayId(int64_t display_id,
 333                                          gfx::Size* size) const OVERRIDE {
 334     return false;
 335   }
 336
 337  private:
 338   MultipleDisplayState state_;
 339
 340   DISALLOW_COPY_AND_ASSIGN(TestStateController);
 341 };
 342
 343 class TestMirroringController
 344     : public DisplayConfigurator::SoftwareMirroringController {
 345  public:
 346   TestMirroringController() : software_mirroring_enabled_(false) {}
 347   virtual ~TestMirroringController() {}
 348
 349   virtual void SetSoftwareMirroring(bool enabled) OVERRIDE {
 350     software_mirroring_enabled_ = enabled;
 351   }
 352
 353   virtual bool SoftwareMirroringEnabled() const OVERRIDE {
 354     return software_mirroring_enabled_;
 355   }
 356
 357  private:
 358   bool software_mirroring_enabled_;
 359
 360   DISALLOW_COPY_AND_ASSIGN(TestMirroringController);
 361 };
 362
 363 class DisplayConfiguratorTest : public testing::Test {
 364  public:
 365   DisplayConfiguratorTest()
 366       : small_mode_(gfx::Size(1366, 768), false, 60.0f),
 367         big_mode_(gfx::Size(2560, 1600), false, 60.0f),
 368         observer_(&configurator_),
 369         test_api_(&configurator_) {}
 370   virtual ~DisplayConfiguratorTest() {}
 371
 372   virtual void SetUp() OVERRIDE {
 373     log_.reset(new ActionLogger());
 374
 375     native_display_delegate_ = new TestNativeDisplayDelegate(log_.get());
 376     touchscreen_delegate_ = new TestTouchscreenDelegate(log_.get());
 377     configurator_.SetDelegatesForTesting(
 378         scoped_ptr<NativeDisplayDelegate>(native_display_delegate_),
 379         scoped_ptr<DisplayConfigurator::TouchscreenDelegate>(
 380             touchscreen_delegate_));
 381
 382     configurator_.set_state_controller(&state_controller_);
 383     configurator_.set_mirroring_controller(&mirroring_controller_);
 384
 385     std::vector<const DisplayMode*> modes;
 386     modes.push_back(&small_mode_);
 387
 388     TestDisplaySnapshot* o = &outputs_[0];
 389     o->set_current_mode(&small_mode_);
 390     o->set_native_mode(&small_mode_);
 391     o->set_modes(modes);
 392     o->set_type(DISPLAY_CONNECTION_TYPE_INTERNAL);
 393     o->set_is_aspect_preserving_scaling(true);
 394     o->set_display_id(123);
 395     o->set_has_proper_display_id(true);
 396
 397     o = &outputs_[1];
 398     o->set_current_mode(&big_mode_);
 399     o->set_native_mode(&big_mode_);
 400     modes.push_back(&big_mode_);
 401     o->set_modes(modes);
 402     o->set_type(DISPLAY_CONNECTION_TYPE_HDMI);
 403     o->set_is_aspect_preserving_scaling(true);
 404     o->set_display_id(456);
 405     o->set_has_proper_display_id(true);
 406
 407     UpdateOutputs(2, false);
 408   }
 409
 410   // Predefined modes that can be used by outputs.
 411   const DisplayMode small_mode_;
 412   const DisplayMode big_mode_;
 413
 414  protected:
 415   // Configures |native_display_delegate_| to return the first |num_outputs|
 416   // entries from
 417   // |outputs_|. If |send_events| is true, also sends screen-change and
 418   // output-change events to |configurator_| and triggers the configure
 419   // timeout if one was scheduled.
 420   void UpdateOutputs(size_t num_outputs, bool send_events) {
 421     ASSERT_LE(num_outputs, arraysize(outputs_));
 422     std::vector<DisplaySnapshot*> outputs;
 423     for (size_t i = 0; i < num_outputs; ++i)
 424       outputs.push_back(&outputs_[i]);
 425     native_display_delegate_->set_outputs(outputs);
 426
 427     if (send_events) {
 428       configurator_.OnConfigurationChanged();
 429       test_api_.TriggerConfigureTimeout();
 430     }
 431   }
 432
 433   // Initializes |configurator_| with a single internal display.
 434   void InitWithSingleOutput() {
 435     UpdateOutputs(1, false);
 436     EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 437     configurator_.Init(false);
 438     EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 439     configurator_.ForceInitialConfigure(0);
 440     EXPECT_EQ(
 441         JoinActions(
 442             kGrab,
 443             kInitXRandR,
 444             GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL)
 445                 .c_str(),
 446             GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 447             kForceDPMS,
 448             kUngrab,
 449             NULL),
 450         log_->GetActionsAndClear());
 451   }
 452
 453   base::MessageLoop message_loop_;
 454   TestStateController state_controller_;
 455   TestMirroringController mirroring_controller_;
 456   DisplayConfigurator configurator_;
 457   TestObserver observer_;
 458   scoped_ptr<ActionLogger> log_;
 459   TestNativeDisplayDelegate* native_display_delegate_;  // not owned
 460   TestTouchscreenDelegate* touchscreen_delegate_;       // not owned
 461   DisplayConfigurator::TestApi test_api_;
 462
 463   TestDisplaySnapshot outputs_[2];
 464
 465  private:
 466   DISALLOW_COPY_AND_ASSIGN(DisplayConfiguratorTest);
 467 };
 468
 469 }  // namespace
 470
 471 TEST_F(DisplayConfiguratorTest, FindDisplayModeMatchingSize) {
 472   ScopedVector<const DisplayMode> modes;
 473
 474   // Fields are width, height, interlaced, refresh rate.
 475   modes.push_back(new DisplayMode(gfx::Size(1920, 1200), false, 60.0));
 476   // Different rates.
 477   modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 30.0));
 478   modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 50.0));
 479   modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 40.0));
 480   modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 0.0));
 481   // Interlaced vs non-interlaced.
 482   modes.push_back(new DisplayMode(gfx::Size(1280, 720), true, 60.0));
 483   modes.push_back(new DisplayMode(gfx::Size(1280, 720), false, 40.0));
 484   // Interlaced only.
 485   modes.push_back(new DisplayMode(gfx::Size(1024, 768), true, 0.0));
 486   modes.push_back(new DisplayMode(gfx::Size(1024, 768), true, 40.0));
 487   modes.push_back(new DisplayMode(gfx::Size(1024, 768), true, 60.0));
 488   // Mixed.
 489   modes.push_back(new DisplayMode(gfx::Size(1024, 600), true, 60.0));
 490   modes.push_back(new DisplayMode(gfx::Size(1024, 600), false, 40.0));
 491   modes.push_back(new DisplayMode(gfx::Size(1024, 600), false, 50.0));
 492   // Just one interlaced mode.
 493   modes.push_back(new DisplayMode(gfx::Size(640, 480), true, 60.0));
 494   // Refresh rate not available.
 495   modes.push_back(new DisplayMode(gfx::Size(320, 200), false, 0.0));
 496
 497   TestDisplaySnapshot output;
 498   output.set_modes(modes.get());
 499
 500   EXPECT_EQ(modes[0],
 501             DisplayConfigurator::FindDisplayModeMatchingSize(
 502                 output, gfx::Size(1920, 1200)));
 503
 504   // Should pick highest refresh rate.
 505   EXPECT_EQ(modes[2],
 506             DisplayConfigurator::FindDisplayModeMatchingSize(
 507                 output, gfx::Size(1920, 1080)));
 508
 509   // Should pick non-interlaced mode.
 510   EXPECT_EQ(modes[6],
 511             DisplayConfigurator::FindDisplayModeMatchingSize(
 512                 output, gfx::Size(1280, 720)));
 513
 514   // Interlaced only. Should pick one with the highest refresh rate in
 515   // interlaced mode.
 516   EXPECT_EQ(modes[9],
 517             DisplayConfigurator::FindDisplayModeMatchingSize(
 518                 output, gfx::Size(1024, 768)));
 519
 520   // Mixed: Should pick one with the highest refresh rate in
 521   // interlaced mode.
 522   EXPECT_EQ(modes[12],
 523             DisplayConfigurator::FindDisplayModeMatchingSize(
 524                 output, gfx::Size(1024, 600)));
 525
 526   // Just one interlaced mode.
 527   EXPECT_EQ(modes[13],
 528             DisplayConfigurator::FindDisplayModeMatchingSize(
 529                 output, gfx::Size(640, 480)));
 530
 531   // Refresh rate not available.
 532   EXPECT_EQ(modes[14],
 533             DisplayConfigurator::FindDisplayModeMatchingSize(
 534                 output, gfx::Size(320, 200)));
 535
 536   // No mode found.
 537   EXPECT_EQ(NULL,
 538             DisplayConfigurator::FindDisplayModeMatchingSize(
 539                 output, gfx::Size(1440, 900)));
 540 }
 541
 542 TEST_F(DisplayConfiguratorTest, ConnectSecondOutput) {
 543   InitWithSingleOutput();
 544
 545   // Connect a second output and check that the configurator enters
 546   // extended mode.
 547   observer_.Reset();
 548   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
 549   UpdateOutputs(2, true);
 550   const int kDualHeight = small_mode_.size().height() +
 551                           DisplayConfigurator::kVerticalGap +
 552                           big_mode_.size().height();
 553   EXPECT_EQ(
 554       JoinActions(
 555           kGrab,
 556           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
 557                                &outputs_[0],
 558                                &outputs_[1]).c_str(),
 559           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 560           GetCrtcAction(outputs_[1],
 561                         &big_mode_,
 562                         gfx::Point(0,
 563                                    small_mode_.size().height() +
 564                                        DisplayConfigurator::kVerticalGap))
 565               .c_str(),
 566           kUngrab,
 567           NULL),
 568       log_->GetActionsAndClear());
 569   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 570   EXPECT_EQ(1, observer_.num_changes());
 571
 572   observer_.Reset();
 573   EXPECT_TRUE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR));
 574   EXPECT_EQ(
 575       JoinActions(
 576           kGrab,
 577           GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
 578               .c_str(),
 579           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 580           GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
 581           kUngrab,
 582           NULL),
 583       log_->GetActionsAndClear());
 584   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 585   EXPECT_EQ(1, observer_.num_changes());
 586
 587   // Disconnect the second output.
 588   observer_.Reset();
 589   UpdateOutputs(1, true);
 590   EXPECT_EQ(
 591       JoinActions(
 592           kGrab,
 593           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
 594           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 595           kUngrab,
 596           NULL),
 597       log_->GetActionsAndClear());
 598   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 599   EXPECT_EQ(1, observer_.num_changes());
 600
 601   // Get rid of shared modes to force software mirroring.
 602   outputs_[1].set_modes(std::vector<const DisplayMode*>(1, &big_mode_));
 603   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
 604   UpdateOutputs(2, true);
 605   EXPECT_EQ(
 606       JoinActions(
 607           kGrab,
 608           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
 609                                &outputs_[0],
 610                                &outputs_[1]).c_str(),
 611           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 612           GetCrtcAction(outputs_[1],
 613                         &big_mode_,
 614                         gfx::Point(0,
 615                                    small_mode_.size().height() +
 616                                        DisplayConfigurator::kVerticalGap))
 617               .c_str(),
 618           kUngrab,
 619           NULL),
 620       log_->GetActionsAndClear());
 621   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 622
 623   observer_.Reset();
 624   EXPECT_TRUE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR));
 625   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
 626   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
 627             configurator_.display_state());
 628   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
 629   EXPECT_EQ(1, observer_.num_changes());
 630
 631   // Setting MULTIPLE_DISPLAY_STATE_DUAL_MIRROR should try to reconfigure.
 632   observer_.Reset();
 633   EXPECT_TRUE(
 634       configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED));
 635   EXPECT_EQ(JoinActions(NULL), log_->GetActionsAndClear());
 636   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 637   EXPECT_EQ(1, observer_.num_changes());
 638
 639   // Set back to software mirror mode.
 640   observer_.Reset();
 641   EXPECT_TRUE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR));
 642   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
 643   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
 644             configurator_.display_state());
 645   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
 646   EXPECT_EQ(1, observer_.num_changes());
 647
 648   // Disconnect the second output.
 649   observer_.Reset();
 650   UpdateOutputs(1, true);
 651   EXPECT_EQ(
 652       JoinActions(
 653           kGrab,
 654           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
 655           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 656           kUngrab,
 657           NULL),
 658       log_->GetActionsAndClear());
 659   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 660   EXPECT_EQ(1, observer_.num_changes());
 661 }
 662
 663 TEST_F(DisplayConfiguratorTest, SetDisplayPower) {
 664   InitWithSingleOutput();
 665
 666   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
 667   observer_.Reset();
 668   UpdateOutputs(2, true);
 669   EXPECT_EQ(
 670       JoinActions(
 671           kGrab,
 672           GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
 673               .c_str(),
 674           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 675           GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
 676           kUngrab,
 677           NULL),
 678       log_->GetActionsAndClear());
 679   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 680   EXPECT_EQ(1, observer_.num_changes());
 681
 682   // Turning off the internal display should switch the external display to
 683   // its native mode.
 684   observer_.Reset();
 685   configurator_.SetDisplayPower(
 686       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
 687       DisplayConfigurator::kSetDisplayPowerNoFlags);
 688   EXPECT_EQ(
 689       JoinActions(
 690           kGrab,
 691           GetFramebufferAction(big_mode_.size(), &outputs_[0], &outputs_[1])
 692               .c_str(),
 693           GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
 694           GetCrtcAction(outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
 695           kForceDPMS,
 696           kUngrab,
 697           NULL),
 698       log_->GetActionsAndClear());
 699   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_SINGLE, configurator_.display_state());
 700   EXPECT_EQ(1, observer_.num_changes());
 701
 702   // When all displays are turned off, the framebuffer should switch back
 703   // to the mirrored size.
 704   observer_.Reset();
 705   configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
 706                                 DisplayConfigurator::kSetDisplayPowerNoFlags);
 707   EXPECT_EQ(
 708       JoinActions(kGrab,
 709                   GetFramebufferAction(
 710                       small_mode_.size(), &outputs_[0], &outputs_[1]).c_str(),
 711                   GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
 712                   GetCrtcAction(outputs_[1], NULL, gfx::Point(0, 0)).c_str(),
 713                   kUngrab,
 714                   NULL),
 715       log_->GetActionsAndClear());
 716   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
 717   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 718   EXPECT_EQ(1, observer_.num_changes());
 719
 720   // Turn all displays on and check that mirroring is still used.
 721   observer_.Reset();
 722   configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
 723                                 DisplayConfigurator::kSetDisplayPowerNoFlags);
 724   EXPECT_EQ(
 725       JoinActions(
 726           kGrab,
 727           GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
 728               .c_str(),
 729           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 730           GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
 731           kForceDPMS,
 732           kUngrab,
 733           NULL),
 734       log_->GetActionsAndClear());
 735   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
 736   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 737   EXPECT_EQ(1, observer_.num_changes());
 738
 739   // Get rid of shared modes to force software mirroring.
 740   outputs_[1].set_modes(std::vector<const DisplayMode*>(1, &big_mode_));
 741   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
 742   observer_.Reset();
 743   UpdateOutputs(2, true);
 744   const int kDualHeight = small_mode_.size().height() +
 745                           DisplayConfigurator::kVerticalGap +
 746                           big_mode_.size().height();
 747   EXPECT_EQ(
 748       JoinActions(
 749           kGrab,
 750           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
 751                                &outputs_[0],
 752                                &outputs_[1]).c_str(),
 753           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 754           GetCrtcAction(outputs_[1],
 755                         &big_mode_,
 756                         gfx::Point(0,
 757                                    small_mode_.size().height() +
 758                                        DisplayConfigurator::kVerticalGap))
 759               .c_str(),
 760           kUngrab,
 761           NULL),
 762       log_->GetActionsAndClear());
 763   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
 764             configurator_.display_state());
 765   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
 766   EXPECT_EQ(1, observer_.num_changes());
 767
 768   // Turning off the internal display should switch the external display to
 769   // its native mode.
 770   observer_.Reset();
 771   configurator_.SetDisplayPower(
 772       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
 773       DisplayConfigurator::kSetDisplayPowerNoFlags);
 774   EXPECT_EQ(
 775       JoinActions(
 776           kGrab,
 777           GetFramebufferAction(big_mode_.size(), &outputs_[0], &outputs_[1])
 778               .c_str(),
 779           GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
 780           GetCrtcAction(outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
 781           kForceDPMS,
 782           kUngrab,
 783           NULL),
 784       log_->GetActionsAndClear());
 785   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_SINGLE, configurator_.display_state());
 786   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 787   EXPECT_EQ(1, observer_.num_changes());
 788
 789   // When all displays are turned off, the framebuffer should switch back
 790   // to the extended + software mirroring.
 791   observer_.Reset();
 792   configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
 793                                 DisplayConfigurator::kSetDisplayPowerNoFlags);
 794   EXPECT_EQ(
 795       JoinActions(
 796           kGrab,
 797           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
 798                                &outputs_[0],
 799                                &outputs_[1]).c_str(),
 800           GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
 801           GetCrtcAction(outputs_[1],
 802                         NULL,
 803                         gfx::Point(0,
 804                                    small_mode_.size().height() +
 805                                        DisplayConfigurator::kVerticalGap))
 806               .c_str(),
 807           kUngrab,
 808           NULL),
 809       log_->GetActionsAndClear());
 810   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
 811             configurator_.display_state());
 812   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
 813   EXPECT_EQ(1, observer_.num_changes());
 814
 815   // Turn all displays on and check that mirroring is still used.
 816   observer_.Reset();
 817   configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
 818                                 DisplayConfigurator::kSetDisplayPowerNoFlags);
 819   EXPECT_EQ(
 820       JoinActions(
 821           kGrab,
 822           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
 823                                &outputs_[0],
 824                                &outputs_[1]).c_str(),
 825           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 826           GetCrtcAction(outputs_[1],
 827                         &big_mode_,
 828                         gfx::Point(0,
 829                                    small_mode_.size().height() +
 830                                        DisplayConfigurator::kVerticalGap))
 831               .c_str(),
 832           kForceDPMS,
 833           kUngrab,
 834           NULL),
 835       log_->GetActionsAndClear());
 836   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
 837             configurator_.display_state());
 838   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
 839   EXPECT_EQ(1, observer_.num_changes());
 840 }
 841
 842 TEST_F(DisplayConfiguratorTest, SuspendAndResume) {
 843   InitWithSingleOutput();
 844
 845   // No preparation is needed before suspending when the display is already
 846   // on.  The configurator should still reprobe on resume in case a display
 847   // was connected while suspended.
 848   configurator_.SuspendDisplays();
 849   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 850   configurator_.ResumeDisplays();
 851   EXPECT_EQ(
 852       JoinActions(
 853           kGrab,
 854           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
 855           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 856           kForceDPMS,
 857           kUngrab,
 858           NULL),
 859       log_->GetActionsAndClear());
 860
 861   // Now turn the display off before suspending and check that the
 862   // configurator turns it back on and syncs with the server.
 863   configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
 864                                 DisplayConfigurator::kSetDisplayPowerNoFlags);
 865   EXPECT_EQ(
 866       JoinActions(
 867           kGrab,
 868           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
 869           GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
 870           kUngrab,
 871           NULL),
 872       log_->GetActionsAndClear());
 873
 874   configurator_.SuspendDisplays();
 875   EXPECT_EQ(
 876       JoinActions(
 877           kGrab,
 878           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
 879           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 880           kForceDPMS,
 881           kUngrab,
 882           kSync,
 883           NULL),
 884       log_->GetActionsAndClear());
 885
 886   configurator_.ResumeDisplays();
 887   EXPECT_EQ(
 888       JoinActions(
 889           kGrab,
 890           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
 891           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 892           kForceDPMS,
 893           kUngrab,
 894           NULL),
 895       log_->GetActionsAndClear());
 896
 897   // If a second, external display is connected, the displays shouldn't be
 898   // powered back on before suspending.
 899   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
 900   UpdateOutputs(2, true);
 901   EXPECT_EQ(
 902       JoinActions(
 903           kGrab,
 904           GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
 905               .c_str(),
 906           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 907           GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
 908           kUngrab,
 909           NULL),
 910       log_->GetActionsAndClear());
 911
 912   configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
 913                                 DisplayConfigurator::kSetDisplayPowerNoFlags);
 914   EXPECT_EQ(
 915       JoinActions(kGrab,
 916                   GetFramebufferAction(
 917                       small_mode_.size(), &outputs_[0], &outputs_[1]).c_str(),
 918                   GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
 919                   GetCrtcAction(outputs_[1], NULL, gfx::Point(0, 0)).c_str(),
 920                   kUngrab,
 921                   NULL),
 922       log_->GetActionsAndClear());
 923
 924   configurator_.SuspendDisplays();
 925   EXPECT_EQ(JoinActions(kGrab, kUngrab, kSync, NULL),
 926             log_->GetActionsAndClear());
 927
 928   // If a display is disconnected while suspended, the configurator should
 929   // pick up the change.
 930   UpdateOutputs(1, false);
 931   configurator_.ResumeDisplays();
 932   EXPECT_EQ(
 933       JoinActions(
 934           kGrab,
 935           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
 936           GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
 937           kUngrab,
 938           NULL),
 939       log_->GetActionsAndClear());
 940 }
 941
 942 TEST_F(DisplayConfiguratorTest, Headless) {
 943   UpdateOutputs(0, false);
 944   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 945   configurator_.Init(false);
 946   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 947   configurator_.ForceInitialConfigure(0);
 948   EXPECT_EQ(JoinActions(kGrab, kInitXRandR, kForceDPMS, kUngrab, NULL),
 949             log_->GetActionsAndClear());
 950
 951   // Not much should happen when the display power state is changed while
 952   // no displays are connected.
 953   configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
 954                                 DisplayConfigurator::kSetDisplayPowerNoFlags);
 955   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
 956   configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
 957                                 DisplayConfigurator::kSetDisplayPowerNoFlags);
 958   EXPECT_EQ(JoinActions(kGrab, kForceDPMS, kUngrab, NULL),
 959             log_->GetActionsAndClear());
 960
 961   // Connect an external display and check that it's configured correctly.
 962   outputs_[0].set_current_mode(outputs_[1].current_mode());
 963   outputs_[0].set_native_mode(outputs_[1].native_mode());
 964   outputs_[0].set_modes(outputs_[1].modes());
 965   outputs_[0].set_type(outputs_[1].type());
 966
 967   UpdateOutputs(1, true);
 968   EXPECT_EQ(
 969       JoinActions(
 970           kGrab,
 971           GetFramebufferAction(big_mode_.size(), &outputs_[0], NULL).c_str(),
 972           GetCrtcAction(outputs_[0], &big_mode_, gfx::Point(0, 0)).c_str(),
 973           kUngrab,
 974           NULL),
 975       log_->GetActionsAndClear());
 976 }
 977
 978 TEST_F(DisplayConfiguratorTest, StartWithTwoOutputs) {
 979   UpdateOutputs(2, false);
 980   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 981   configurator_.Init(false);
 982   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 983
 984   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
 985   configurator_.ForceInitialConfigure(0);
 986   EXPECT_EQ(
 987       JoinActions(
 988           kGrab,
 989           kInitXRandR,
 990           GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
 991               .c_str(),
 992           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
 993           GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
 994           kForceDPMS,
 995           kUngrab,
 996           NULL),
 997       log_->GetActionsAndClear());
 998 }
 999
1000 TEST_F(DisplayConfiguratorTest, InvalidMultipleDisplayStates) {
1001   UpdateOutputs(0, false);
1002   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
1003   configurator_.Init(false);
1004   configurator_.ForceInitialConfigure(0);
1005   observer_.Reset();
1006   EXPECT_TRUE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_HEADLESS));
1007   EXPECT_FALSE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_SINGLE));
1008   EXPECT_FALSE(
1009       configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR));
1010   EXPECT_FALSE(
1011       configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED));
1012   EXPECT_EQ(1, observer_.num_changes());
1013   EXPECT_EQ(3, observer_.num_failures());
1014
1015   UpdateOutputs(1, true);
1016   observer_.Reset();
1017   EXPECT_FALSE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_HEADLESS));
1018   EXPECT_TRUE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_SINGLE));
1019   EXPECT_FALSE(
1020       configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR));
1021   EXPECT_FALSE(
1022       configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED));
1023   EXPECT_EQ(1, observer_.num_changes());
1024   EXPECT_EQ(3, observer_.num_failures());
1025
1026   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
1027   UpdateOutputs(2, true);
1028   observer_.Reset();
1029   EXPECT_FALSE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_HEADLESS));
1030   EXPECT_FALSE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_SINGLE));
1031   EXPECT_TRUE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR));
1032   EXPECT_TRUE(
1033       configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED));
1034   EXPECT_EQ(2, observer_.num_changes());
1035   EXPECT_EQ(2, observer_.num_failures());
1036 }
1037
1038 TEST_F(DisplayConfiguratorTest, GetMultipleDisplayStateForDisplaysWithoutId) {
1039   outputs_[0].set_has_proper_display_id(false);
1040   UpdateOutputs(2, false);
1041   configurator_.Init(false);
1042   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
1043   configurator_.ForceInitialConfigure(0);
1044   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
1045             configurator_.display_state());
1046 }
1047
1048 TEST_F(DisplayConfiguratorTest, GetMultipleDisplayStateForDisplaysWithId) {
1049   outputs_[0].set_has_proper_display_id(true);
1050   UpdateOutputs(2, false);
1051   configurator_.Init(false);
1052   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
1053   configurator_.ForceInitialConfigure(0);
1054   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
1055 }
1056
1057 TEST_F(DisplayConfiguratorTest, UpdateCachedOutputsEvenAfterFailure) {
1058   InitWithSingleOutput();
1059   const DisplayConfigurator::DisplayStateList* cached =
1060       &configurator_.cached_displays();
1061   ASSERT_EQ(static_cast<size_t>(1), cached->size());
1062   EXPECT_EQ(outputs_[0].current_mode(), (*cached)[0].display->current_mode());
1063
1064   // After connecting a second output, check that it shows up in
1065   // |cached_displays_| even if an invalid state is requested.
1066   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_SINGLE);
1067   UpdateOutputs(2, true);
1068   cached = &configurator_.cached_displays();
1069   ASSERT_EQ(static_cast<size_t>(2), cached->size());
1070   EXPECT_EQ(outputs_[0].current_mode(), (*cached)[0].display->current_mode());
1071   EXPECT_EQ(outputs_[1].current_mode(), (*cached)[1].display->current_mode());
1072 }
1073
1074 TEST_F(DisplayConfiguratorTest, PanelFitting) {
1075   // Configure the internal display to support only the big mode and the
1076   // external display to support only the small mode.
1077   outputs_[0].set_current_mode(&big_mode_);
1078   outputs_[0].set_native_mode(&big_mode_);
1079   outputs_[0].set_modes(std::vector<const DisplayMode*>(1, &big_mode_));
1080
1081   outputs_[1].set_current_mode(&small_mode_);
1082   outputs_[1].set_native_mode(&small_mode_);
1083   outputs_[1].set_modes(std::vector<const DisplayMode*>(1, &small_mode_));
1084
1085   // The small mode should be added to the internal output when requesting
1086   // mirrored mode.
1087   UpdateOutputs(2, false);
1088   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
1089   configurator_.Init(true /* is_panel_fitting_enabled */);
1090   configurator_.ForceInitialConfigure(0);
1091   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
1092   EXPECT_EQ(
1093       JoinActions(
1094           kGrab,
1095           kInitXRandR,
1096           GetAddOutputModeAction(outputs_[0], &small_mode_).c_str(),
1097           GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
1098               .c_str(),
1099           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
1100           GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
1101           kForceDPMS,
1102           kUngrab,
1103           NULL),
1104       log_->GetActionsAndClear());
1105
1106   // Both outputs should be using the small mode.
1107   ASSERT_EQ(1, observer_.num_changes());
1108   ASSERT_EQ(static_cast<size_t>(2), observer_.latest_outputs().size());
1109   EXPECT_EQ(&small_mode_, observer_.latest_outputs()[0].mirror_mode);
1110   EXPECT_EQ(&small_mode_,
1111             observer_.latest_outputs()[0].display->current_mode());
1112   EXPECT_EQ(&small_mode_, observer_.latest_outputs()[1].mirror_mode);
1113   EXPECT_EQ(&small_mode_,
1114             observer_.latest_outputs()[1].display->current_mode());
1115
1116   // Also check that the newly-added small mode is present in the internal
1117   // snapshot that was passed to the observer (http://crbug.com/289159).
1118   const DisplayConfigurator::DisplayState& state =
1119       observer_.latest_outputs()[0];
1120   ASSERT_NE(state.display->modes().end(),
1121             std::find(state.display->modes().begin(),
1122                       state.display->modes().end(),
1123                       &small_mode_));
1124 }
1125
1126 TEST_F(DisplayConfiguratorTest, ContentProtection) {
1127   configurator_.Init(false);
1128   configurator_.ForceInitialConfigure(0);
1129   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
1130
1131   DisplayConfigurator::ContentProtectionClientId id =
1132       configurator_.RegisterContentProtectionClient();
1133   EXPECT_NE(0u, id);
1134
1135   // One output.
1136   UpdateOutputs(1, true);
1137   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
1138   uint32_t link_mask = 0;
1139   uint32_t protection_mask = 0;
1140   EXPECT_TRUE(configurator_.QueryContentProtectionStatus(
1141       id, outputs_[0].display_id(), &link_mask, &protection_mask));
1142   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_INTERNAL), link_mask);
1143   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_NONE),
1144             protection_mask);
1145   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
1146
1147   // Two outputs.
1148   UpdateOutputs(2, true);
1149   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
1150   EXPECT_TRUE(configurator_.QueryContentProtectionStatus(
1151       id, outputs_[1].display_id(), &link_mask, &protection_mask));
1152   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask);
1153   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_NONE),
1154             protection_mask);
1155   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
1156
1157   EXPECT_TRUE(configurator_.EnableContentProtection(
1158       id, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP));
1159   EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_DESIRED),
1160             log_->GetActionsAndClear());
1161
1162   // Enable protection.
1163   native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
1164   EXPECT_TRUE(configurator_.QueryContentProtectionStatus(
1165       id, outputs_[1].display_id(), &link_mask, &protection_mask));
1166   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask);
1167   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_HDCP),
1168             protection_mask);
1169   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
1170
1171   // Protections should be disabled after unregister.
1172   configurator_.UnregisterContentProtectionClient(id);
1173   EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_UNDESIRED),
1174             log_->GetActionsAndClear());
1175 }
1176
1177 TEST_F(DisplayConfiguratorTest, ContentProtectionTwoClients) {
1178   DisplayConfigurator::ContentProtectionClientId client1 =
1179       configurator_.RegisterContentProtectionClient();
1180   DisplayConfigurator::ContentProtectionClientId client2 =
1181       configurator_.RegisterContentProtectionClient();
1182   EXPECT_NE(client1, client2);
1183
1184   configurator_.Init(false);
1185   configurator_.ForceInitialConfigure(0);
1186   UpdateOutputs(2, true);
1187   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
1188
1189   // Clients never know state enableness for methods that they didn't request.
1190   EXPECT_TRUE(configurator_.EnableContentProtection(
1191       client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP));
1192   EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_DESIRED).c_str(),
1193             log_->GetActionsAndClear());
1194   native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
1195
1196   uint32_t link_mask = 0;
1197   uint32_t protection_mask = 0;
1198   EXPECT_TRUE(configurator_.QueryContentProtectionStatus(
1199       client1, outputs_[1].display_id(), &link_mask, &protection_mask));
1200   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask);
1201   EXPECT_EQ(CONTENT_PROTECTION_METHOD_HDCP, protection_mask);
1202
1203   EXPECT_TRUE(configurator_.QueryContentProtectionStatus(
1204       client2, outputs_[1].display_id(), &link_mask, &protection_mask));
1205   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask);
1206   EXPECT_EQ(CONTENT_PROTECTION_METHOD_NONE, protection_mask);
1207
1208   // Protections will be disabled only if no more clients request them.
1209   EXPECT_TRUE(configurator_.EnableContentProtection(
1210       client2, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_NONE));
1211   EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_DESIRED).c_str(),
1212             log_->GetActionsAndClear());
1213   EXPECT_TRUE(configurator_.EnableContentProtection(
1214       client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_NONE));
1215   EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_UNDESIRED).c_str(),
1216             log_->GetActionsAndClear());
1217 }
1218
1219 TEST_F(DisplayConfiguratorTest, HandleConfigureCrtcFailure) {
1220   InitWithSingleOutput();
1221
1222   ScopedVector<const DisplayMode> modes;
1223   // The first mode is the mode we are requesting DisplayConfigurator to choose.
1224   // The test will be setup so that this mode will fail and it will have to
1225   // choose the next best option.
1226   modes.push_back(new DisplayMode(gfx::Size(2560, 1600), false, 60.0));
1227   modes.push_back(new DisplayMode(gfx::Size(1024, 768), false, 60.0));
1228   modes.push_back(new DisplayMode(gfx::Size(1280, 720), false, 60.0));
1229   modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 60.0));
1230   modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 40.0));
1231
1232   for (unsigned int i = 0; i < arraysize(outputs_); i++) {
1233     outputs_[i].set_modes(modes.get());
1234     outputs_[i].set_current_mode(modes[0]);
1235     outputs_[i].set_native_mode(modes[0]);
1236   }
1237
1238   configurator_.Init(false);
1239
1240   // First test simply fails in MULTIPLE_DISPLAY_STATE_SINGLE mode. This is
1241   // probably unrealistic but we want to make sure any assumptions don't creep
1242   // in.
1243   native_display_delegate_->set_max_configurable_pixels(
1244       modes[2]->size().GetArea());
1245   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_SINGLE);
1246   UpdateOutputs(1, true);
1247
1248   EXPECT_EQ(
1249       JoinActions(
1250           kGrab,
1251           GetFramebufferAction(big_mode_.size(), &outputs_[0], NULL).c_str(),
1252           GetCrtcAction(outputs_[0], modes[0], gfx::Point(0, 0)).c_str(),
1253           GetCrtcAction(outputs_[0], modes[3], gfx::Point(0, 0)).c_str(),
1254           GetCrtcAction(outputs_[0], modes[2], gfx::Point(0, 0)).c_str(),
1255           kUngrab,
1256           NULL),
1257       log_->GetActionsAndClear());
1258
1259   // This test should attempt to configure a mirror mode that will not succeed
1260   // and should end up in extended mode.
1261   native_display_delegate_->set_max_configurable_pixels(
1262       modes[3]->size().GetArea());
1263   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
1264   UpdateOutputs(2, true);
1265
1266   EXPECT_EQ(
1267       JoinActions(
1268           kGrab,
1269           GetFramebufferAction(modes[0]->size(), &outputs_[0], &outputs_[1])
1270               .c_str(),
1271           GetCrtcAction(outputs_[0], modes[0], gfx::Point(0, 0)).c_str(),
1272           // First mode tried is expected to fail and it will
1273           // retry wil the 4th mode in the list.
1274           GetCrtcAction(outputs_[0], modes[3], gfx::Point(0, 0)).c_str(),
1275           // Then attempt to configure crtc1 with the first mode.
1276           GetCrtcAction(outputs_[1], modes[0], gfx::Point(0, 0)).c_str(),
1277           GetCrtcAction(outputs_[1], modes[3], gfx::Point(0, 0)).c_str(),
1278           // Since it was requested to go into mirror mode
1279           // and the configured modes were different, it
1280           // should now try and setup a valid configurable
1281           // extended mode.
1282           GetFramebufferAction(
1283               gfx::Size(modes[0]->size().width(),
1284                         modes[0]->size().height() + modes[0]->size().height() +
1285                             DisplayConfigurator::kVerticalGap),
1286               &outputs_[0],
1287               &outputs_[1]).c_str(),
1288           GetCrtcAction(outputs_[0], modes[0], gfx::Point(0, 0)).c_str(),
1289           GetCrtcAction(outputs_[0], modes[3], gfx::Point(0, 0)).c_str(),
1290           GetCrtcAction(outputs_[1],
1291                         modes[0],
1292                         gfx::Point(0,
1293                                    modes[0]->size().height() +
1294                                        DisplayConfigurator::kVerticalGap))
1295               .c_str(),
1296           GetCrtcAction(outputs_[1],
1297                         modes[3],
1298                         gfx::Point(0,
1299                                    modes[0]->size().height() +
1300                                        DisplayConfigurator::kVerticalGap))
1301               .c_str(),
1302           kUngrab,
1303           NULL),
1304       log_->GetActionsAndClear());
1305 }
1306
1307 }  // namespace ui