Update DisplayConfigurator to use the asynchronous tasks

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>
 #include <string>
 #include <vector>
 
 #include "base/event_types.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/timer/timer.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/display/display_export.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/native_display_observer.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace gfx {
 class Point;
 class Size;
 }
 
 namespace ui {
 struct DisplayConfigureRequest;
 class DisplayMode;
 class DisplaySnapshot;
 class NativeDisplayDelegate;
+class UpdateDisplayConfigurationTask;
 
 // This class interacts directly with the system display configurator.
 class DISPLAY_EXPORT DisplayConfigurator : public NativeDisplayObserver {
  public:
   typedef uint64_t ContentProtectionClientId;
   static const ContentProtectionClientId kInvalidClientId = 0;
 
   struct DisplayState {
     DisplayState();
 
@@ skipping 121 matching lines @@
 
   // 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();
   virtual ~DisplayConfigurator();
 
-  MultipleDisplayState display_state() const { return display_state_; }
+  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<DisplayState>& cached_displays() const {
     return cached_displays_;
   }
 
   // Called when an external process no longer needs to control the display
   // and Chrome can take control.
@@ skipping 29 matching lines @@
   void ForceInitialConfigure(uint32_t background_color_argb);
 
   // Stop handling display configuration events/requests.
   void PrepareForExit();
 
   // Called when powerd notifies us that some set of displays should be turned
   // on or off.  This requires enabling or disabling the CRTC associated with
   // the display(s) in question so that the low power state is engaged.
   // |flags| contains bitwise-or-ed kSetDisplayPower* values. Returns true if
   // the system successfully enters (or was already in) |power_state|.
-  bool SetDisplayPower(chromeos::DisplayPowerState power_state, int flags);
+  void SetDisplayPower(chromeos::DisplayPowerState power_state, int flags);
 
   // Force switching the display mode to |new_state|. Returns false if
   // switching failed (possibly because |new_state| is invalid for the
   // current set of connected displays).
-  bool SetDisplayMode(MultipleDisplayState new_state);
+  void SetDisplayMode(MultipleDisplayState new_state);
 
   // NativeDisplayDelegate::Observer overrides:
   virtual void OnConfigurationChanged() override;
 
   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.
@@ skipping 31 matching lines @@
   // Checks the available color profiles for |display_id| and fills the result
   // into |profiles|.
   std::vector<ui::ColorCalibrationProfile> GetAvailableColorCalibrationProfiles(
       int64_t display_id);
 
   // Updates the color calibration to |new_profile|.
   bool SetColorCalibrationProfile(int64_t display_id,
                                   ui::ColorCalibrationProfile new_profile);
 
  private:
+  class DisplayLayoutManagerImpl;
+
   // Mapping a display_id to a protection request bitmask.
   typedef std::map<int64_t, uint32_t> ContentProtections;
   // Mapping a client to its protection request.
   typedef std::map<ContentProtectionClientId, ContentProtections>
       ProtectionRequests;
 
   // Performs platform specific delegate initialization.
   scoped_ptr<NativeDisplayDelegate> CreatePlatformNativeDisplayDelegate();
 
-  // Updates |cached_displays_| to contain currently-connected displays. Calls
-  // |delegate_->GetDisplays()| and then does additional work, like finding the
-  // mirror mode and setting user-preferred modes. Note that the server must be
-  // grabbed via |delegate_->GrabServer()| first.
-  void UpdateCachedDisplays();
-
-  // Helper method for UpdateCachedDisplays() that initializes the passed-in
-  // displays' |mirror_mode| fields by looking for a mode in |internal_display|
-  // and |external_display| having the same resolution. Returns false if a
-  // shared
-  // mode wasn't found or created.
-  //
-  // |try_panel_fitting| allows creating a panel-fitting mode for
-  // |internal_display| instead of only searching for a matching mode (note that
-  // it may lead to a crash if |internal_info| is not capable of panel fitting).
-  //
-  // |preserve_aspect| limits the search/creation only to the modes having the
-  // native aspect ratio of |external_display|.
-  bool FindMirrorMode(DisplayState* internal_display,
-                      DisplayState* external_display,
-                      bool try_panel_fitting,
-                      bool preserve_aspect);
-
   // Configures displays. Invoked by |configure_timer_|.
   void ConfigureDisplays();
 
   // Restores |requested_power_state_| after the system has resumed,
   // additionally forcing a probe. Invoked by |configure_timer_|.
   void RestoreRequestedPowerStateAfterResume();
 
   // Notifies observers about an attempted state change.
   void NotifyObservers(bool success, MultipleDisplayState attempted_state);
 
-  // Switches to the state specified in |display_state| and |power_state|.
-  // If the hardware mirroring failed and |mirroring_controller_| is set,
-  // it switches to |STATE_DUAL_EXTENDED| and calls |SetSoftwareMirroring()|
-  // to enable software based mirroring.
-  // On success, updates |display_state_|, |power_state_|, and
-  // |cached_displays_| and returns true.
-  bool EnterStateOrFallBackToSoftwareMirroring(
-      MultipleDisplayState display_state,
-      chromeos::DisplayPowerState power_state);
-
-  // Switches to the state specified in |display_state| and |power_state|.
-  // On success, updates |display_state_|, |power_state_|, and
-  // |cached_displays_| and returns true.
-  bool EnterState(MultipleDisplayState display_state,
-                  chromeos::DisplayPowerState power_state);
-
   // Returns the display state that should be used with |cached_displays_| while
   // in |power_state|.
   MultipleDisplayState ChooseDisplayState(
       chromeos::DisplayPowerState power_state) const;
 
   // Returns the ratio between mirrored mode area and native mode area:
   // (mirror_mode_width * mirrow_mode_height) / (native_width * native_height)
   float GetMirroredDisplayAreaRatio(const DisplayState& display);
 
   // Returns true if in either hardware or software mirroring mode.
   bool IsMirroring() const;
 
   // Applies display protections according to requests.
   bool ApplyProtections(const ContentProtections& requests);
 
+  // If |configuration_task_| isn't initialized, initialize it and start the

[Daniel Erat, 2014/12/12 20:36:30]

nit: s/initialize/initializes/, s/start/starts/

[dnicoara, 2014/12/12 20:56:24]

Done.

+  // configuration task.
+  void RunPendingConfiguration();
+
+  // Callback for |configuration_taks_|. When the configuration process finishes
+  // this is called with the result (|success|) and the updated display state.
+  void OnConfigured(bool success,
+                    const std::vector<DisplayState>& displays,
+                    const gfx::Size& framebuffer_size,
+                    MultipleDisplayState new_display_state,
+                    chromeos::DisplayPowerState new_power_state);
+
+  // Helps in identifying if a configuration task needs to be scheduled.
+  // Return true if any of the |requested_*| parameters have been updated. False
+  // otherwise.
+  bool ShouldRunConfigurationTask() const;
+
   StateController* state_controller_;
   SoftwareMirroringController* mirroring_controller_;
   scoped_ptr<NativeDisplayDelegate> native_display_delegate_;
 
   // Used to enable modes which rely on panel fitting.
   bool is_panel_fitting_enabled_;
 
   // This is detected by the constructor to determine whether or not we should
   // be enabled.  If we aren't running on ChromeOS, we can't assume that the
   // Xrandr X11 extension is supported.
   // If this flag is set to false, any attempts to change the display
   // configuration to immediately fail without changing the state.
   bool configure_display_;
 
-  // The current display state.
-  MultipleDisplayState display_state_;
+  // Current configuration state.
+  MultipleDisplayState current_display_state_;
+  chromeos::DisplayPowerState current_power_state_;
 
-  gfx::Size framebuffer_size_;
+  // Pending requests. These values are used when triggering the next display
+  // configuration.
+  //
+  // Stores the user requested state or INVALID if nothing was requested.
+  MultipleDisplayState requested_display_state_;
 
-  // The last-requested and current power state. These may differ if
-  // configuration fails: SetDisplayMode() needs the last-requested state while
-  // SetDisplayPower() needs the current state.
+  // Stores the requested power state.
   chromeos::DisplayPowerState requested_power_state_;
-  chromeos::DisplayPowerState current_power_state_;
+
+  // True if |requested_power_state_| has been changed due to a user request.
+  bool requested_power_state_change_;
+
+  // Bitwise-or value of the |kSetDisplayPower*| flags defined above.
+  int requested_power_flags_;
+
+  // True if the caller wants to force the display configuration process.
+  bool force_configure_;
 
   // Most-recently-used display configuration. Note that the actual
   // configuration changes asynchronously.
   DisplayStateList cached_displays_;
 
+  // Most-recently-used framebuffer size.
+  gfx::Size framebuffer_size_;
+
   ObserverList<Observer> observers_;
 
   // The timer to delay configuring displays. This is used to aggregate multiple
   // display configuration events when they are reported in short time spans.
   // See comment for NativeDisplayEventDispatcherX11 for more details.
   base::OneShotTimer<DisplayConfigurator> configure_timer_;
 
   // Id for next display protection client.
   ContentProtectionClientId next_display_protection_client_id_;
 
   // Display protection requests of each client.
   ProtectionRequests client_protection_requests_;
 
   // Display controlled by an external entity.
   bool display_externally_controlled_;
 
+  scoped_ptr<DisplayLayoutManager> layout_manager_;
+
+  scoped_ptr<UpdateDisplayConfigurationTask> configuration_task_;
+
+  // 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_