Delay display configuration after waking up from suspend with multi displays

ui/display/chromeos/display_configurator.h

 // Copyright 2014 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.
 
 #ifndef UI_DISPLAY_CHROMEOS_DISPLAY_CONFIGURATOR_H_
 #define UI_DISPLAY_CHROMEOS_DISPLAY_CONFIGURATOR_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 140 matching lines @@
 
   // Gap between screens so cursor at bottom of active display doesn't
   // partially appear on top of inactive display. Higher numbers guard
   // against larger cursors, but also waste more memory.
   // For simplicity, this is hard-coded to avoid the complexity of always
   // determining the DPI of the screen and rationalizing which screen we
   // need to use for the DPI calculation.
   // See crbug.com/130188 for initial discussion.
   static const int kVerticalGap = 60;
 
+  // The delay to perform configuration after RRNotify. See the comment for
+  // |configure_timer_|.
+  static const int kConfigureDelayMs = 500;
+
+  // The delay to perform configuration after waking up from suspend when in
+  // multi display mode. Should be bigger than |kConfigureDelayMs|. Generally
+  // big enough for external displays to be detected and added.
+  // crbug.com/614624.
+  static const int kResumeConfigureMultiDisplayDelayMs = 2000;
+
   // Returns the mode within |display| that matches the given size with highest
   // refresh rate. Returns None if no matching display was found.
   static const DisplayMode* FindDisplayModeMatchingSize(
       const DisplaySnapshot& display,
       const gfx::Size& size);
 
   DisplayConfigurator();
   ~DisplayConfigurator() override;
 
   MultipleDisplayState display_state() const { return current_display_state_; }
   chromeos::DisplayPowerState requested_power_state() const {
     return requested_power_state_;
   }
   const gfx::Size framebuffer_size() const { return framebuffer_size_; }
   const std::vector<DisplaySnapshot*>& cached_displays() const {
     return cached_displays_;
   }
+  void set_state_controller(StateController* controller) {
+    state_controller_ = controller;
+  }
+  void set_mirroring_controller(SoftwareMirroringController* controller) {
+    mirroring_controller_ = controller;
+  }
+  void set_configure_display(bool configure_display) {
+    configure_display_ = configure_display;
+  }
+  chromeos::DisplayPowerState current_power_state() const {
+    return current_power_state_;
+  }
 
   // Called when an external process no longer needs to control the display
   // and Chrome can take control.
   void TakeControl(const DisplayControlCallback& callback);
 
   // Called when an external process needs to control the display and thus
   // Chrome should relinquish it.
   void RelinquishControl(const DisplayControlCallback& callback);
 
-  void set_state_controller(StateController* controller) {
-    state_controller_ = controller;
-  }
-  void set_mirroring_controller(SoftwareMirroringController* controller) {
-    mirroring_controller_ = controller;
-  }
-
   // Replaces |native_display_delegate_| with the delegate passed in and sets
   // |configure_display_| to true. Should be called before Init().
   void SetDelegateForTesting(
       std::unique_ptr<NativeDisplayDelegate> display_delegate);
 
   // Sets the initial value of |power_state_|.  Must be called before Start().
   void SetInitialDisplayPower(chromeos::DisplayPowerState power_state);
 
   // Initialization, must be called right after constructor.
   // |is_panel_fitting_enabled| indicates hardware panel fitting support.
@@ skipping 30 matching lines @@
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Sets all the displays into pre-suspend mode; usually this means
   // configure them for their resume state. This allows faster resume on
   // machines where display configuration is slow. On completion of the display
   // configuration |callback| is executed.
   void SuspendDisplays(const ConfigurationCallback& callback);
 
   // Reprobes displays to handle changes made while the system was
-  // suspended.
+  // suspended. ResumeDisplaysWithCallback() invokes |callback| when display
+  // configuration is complete.
   void ResumeDisplays();
+  void ResumeDisplaysWithCallback(const ConfigurationCallback& callback);

[Daniel Erat, 2016/10/24 16:31:04]

instead of having two methods, please just make ResumeDisplays take a callback
and update the existing callers to pass base::DoNothing.

also, please update the comments on SuspendDisplays and ResumeDisplays to
mention that the callbacks can be executed either synchronously or
asynchronously.

[afakhry, 2016/10/25 00:37:10]

Done. 

base::DoNothing() won't work though, it's void(void) and we need a void(bool).

 
   // Registers a client for display protection and requests a client id. Returns
   // 0 if requesting failed.
   ContentProtectionClientId RegisterContentProtectionClient();
 
   // Unregisters the client.
   void UnregisterContentProtectionClient(ContentProtectionClientId client_id);
 
   // Queries link status and protection status. |callback| is used to respond
   // to the query.
@@ skipping 19 matching lines @@
   bool SetColorCalibrationProfile(int64_t display_id,
                                   ui::ColorCalibrationProfile new_profile);
 
   // Enables/disables virtual display.
   int64_t AddVirtualDisplay(const gfx::Size& display_size);
   bool RemoveVirtualDisplay(int64_t display_id);
 
   // Returns true if there is at least one display on.
   bool IsDisplayOn() const;
 
-  void set_configure_display(bool configure_display) {
-    configure_display_ = configure_display;
-  }
-
   // Sets the gamma, degamma and correction matrix for |display_id| to the
   // values in |degamma_lut|, |gamma_lut| and |correction_matrix|.
   bool SetColorCorrection(int64_t display_id,
                           const std::vector<GammaRampRGBEntry>& degamma_lut,
                           const std::vector<GammaRampRGBEntry>& gamma_lut,
                           const std::vector<float>& correction_matrix);
 
  private:
   class DisplayLayoutManagerImpl;
 
@@ skipping 165 matching lines @@
 
   // This must be the last variable.
   base::WeakPtrFactory<DisplayConfigurator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayConfigurator);
 };
 
 }  // namespace ui
 
 #endif  // UI_DISPLAY_CHROMEOS_DISPLAY_CONFIGURATOR_H_