Add delay to FakeDisplayDelegate::Configure().

ui/display/fake_display_delegate.cc

 // Copyright 2016 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 "ui/display/fake_display_delegate.h"
 
 #include <inttypes.h>
 
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
+#include "base/time/time.h"
 #include "ui/display/display.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/native_display_observer.h"
 #include "ui/display/util/display_util.h"
 
 namespace display {
 
 namespace {
 
 // The EDID specification marks the top bit of the manufacturer id as reserved.
 const uint16_t kReservedManufacturerID = 1 << 15;
 
 // A random product name hash.
 const uint32_t kProductCodeHash = base::Hash("Very Generic Display");
 
+// Delay for Configure() in milliseconds.
+constexpr int64_t kConfigureDisplayDelayMs = 200;

[rjkroege, 2016/11/29 19:12:32]

idea: how about making it a random variable? To better capture the underlying
reality. 

[kylechar, 2016/11/29 21:51:41]

That would neat to enable but I don't think tests should run with a  random
delay (in order to not produce flakey tests). This at least makes the callstack
more realistic since the callback won't happen immediately.

I could add a flag like --config-delay and have parsing logic that supports
either \d+ (fixed delay) or \d+,\d+ (min and max of random delay) but adds
complexity I'm not sure will get used?

[kylechar, 2016/12/01 03:43:09]

Will land as is for now. I'll add random delay option if it seems useful for
testing in the future.

+
 }  // namespace
 
 FakeDisplayDelegate::FakeDisplayDelegate() {}
 
 FakeDisplayDelegate::~FakeDisplayDelegate() {}
 
 int64_t FakeDisplayDelegate::AddDisplay(const gfx::Size& display_size) {
   DCHECK(!display_size.IsEmpty());
 
   if (next_display_id_ == 0xFF) {
@@ skipping 91 matching lines @@
   callback.Run(displays);
 }
 
 void FakeDisplayDelegate::AddMode(const ui::DisplaySnapshot& output,
                                   const ui::DisplayMode* mode) {}
 
 void FakeDisplayDelegate::Configure(const ui::DisplaySnapshot& output,
                                     const ui::DisplayMode* mode,
                                     const gfx::Point& origin,
                                     const ui::ConfigureCallback& callback) {
-  // Check the display mode is appropriate for the display snapshot.
-  for (const auto& existing_mode : output.modes()) {
-    if (existing_mode.get() == mode) {
-      callback.Run(true);
-      return;
+  bool configure_success = false;
+
+  if (!mode) {
+    // This is a request to turn off the display.
+    configure_success = true;
+  } else {
+    // Check that |mode| is appropriate for the display snapshot.
+    for (const auto& existing_mode : output.modes()) {
+      if (existing_mode.get() == mode) {
+        configure_success = true;
+        break;
+      }
     }
   }
 
-  callback.Run(false);
+  configure_callback_ = base::Bind(callback, configure_success);
+  configure_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromMilliseconds(kConfigureDisplayDelayMs),
+      this, &FakeDisplayDelegate::ConfigureDone);
 }
 
 void FakeDisplayDelegate::CreateFrameBuffer(const gfx::Size& size) {}
 
 void FakeDisplayDelegate::GetHDCPState(
     const ui::DisplaySnapshot& output,
     const ui::GetHDCPStateCallback& callback) {
   callback.Run(false, ui::HDCP_STATE_UNDESIRED);
 }
 
@@ skipping 26 matching lines @@
 
 void FakeDisplayDelegate::AddObserver(ui::NativeDisplayObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeDisplayDelegate::RemoveObserver(ui::NativeDisplayObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 FakeDisplayController* FakeDisplayDelegate::GetFakeDisplayController() {
-  return static_cast<FakeDisplayController*>(this);
+  return this;
 }
 
 bool FakeDisplayDelegate::InitializeFromSpecString(const std::string& str) {
   // Start without any displays.
   if (str == "none")
     return true;
 
   // Split on commas and parse each display string.
   for (const std::string& part : base::SplitString(
            str, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
@@ skipping 14 matching lines @@
 }
 
 void FakeDisplayDelegate::OnConfigurationChanged() {
   if (!initialized_)
     return;
 
   for (ui::NativeDisplayObserver& observer : observers_)
     observer.OnConfigurationChanged();
 }
 
+void FakeDisplayDelegate::ConfigureDone() {
+  DCHECK(!configure_callback_.is_null());
+  configure_callback_.Run();
+  configure_callback_.Reset();
+}
+
 }  // namespace display