Unified Desktop: hook up ash to allow unified desktop mode

ash/display/display_manager.h

 // Copyright (c) 2012 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 ASH_DISPLAY_DISPLAY_MANAGER_H_
 #define ASH_DISPLAY_DISPLAY_MANAGER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 21 matching lines @@
 class Screen;
 }
 
 namespace ash {
 class AcceleratorControllerTest;
 class DisplayController;
 class DisplayLayoutStore;
 class MouseWarpController;
 class ScreenAsh;
 
+typedef std::vector<DisplayInfo> DisplayInfoList;
+
 namespace test {
 class AshTestBase;
 class DisplayManagerTestApi;
 class SystemGestureEventFilterTest;
 }
 
 // DisplayManager maintains the current display configurations,
 // and notifies observers when configuration changes.
 //
 // TODO(oshima): Make this non internal.
 class ASH_EXPORT DisplayManager
 #if defined(OS_CHROMEOS)
     : public ui::DisplayConfigurator::SoftwareMirroringController
 #endif
       {
  public:
   class ASH_EXPORT Delegate {
    public:
     virtual ~Delegate() {}
 
-    // Create or updates the mirroring window with |display_info|.
+    // Create or updates the mirroring window with |display_info_list|.
     virtual void CreateOrUpdateMirroringDisplay(
-        const DisplayInfo& display_info) = 0;
+        const DisplayInfoList& display_info_list) = 0;
 
     // Closes the mirror window if exists.
     virtual void CloseMirroringDisplay() = 0;
 
     // Called before and after the display configuration changes.
     // When |clear_focus| is true, the implementation should
     // deactivate the active window and set the focus window to NULL.
     virtual void PreDisplayConfigurationChange(bool clear_focus) = 0;
     virtual void PostDisplayConfigurationChange() = 0;
   };
 
   typedef std::vector<gfx::Display> DisplayList;
 
   // How the second display will be used.
   // 1) EXTENDED mode extends the desktop to the second dislpay.
   // 2) MIRRORING mode copies the content of the primary display to
   //    the 2nd display. (Software Mirroring).
-  enum SecondDisplayMode {
+  // 3) UNIFIED mode.
+  enum MultiDisplayMode {
     EXTENDED,
-    MIRRORING
+    MIRRORING,
+    UNIFIED,
   };
 
+  static int64 kUnifiedDisplayId;
+
   DisplayManager();
 #if defined(OS_CHROMEOS)
   ~DisplayManager() override;
 #else
   virtual ~DisplayManager();
 #endif
 
   DisplayLayoutStore* layout_store() {
     return layout_store_.get();
   }
@@ skipping 143 matching lines @@
   }
 
   // Returns the number of connected displays. This returns 2
   // when displays are mirrored.
   size_t num_connected_displays() const { return num_connected_displays_; }
 
   // Returns the mirroring status.
   bool IsInMirrorMode() const;
   int64 mirroring_display_id() const { return mirroring_display_id_; }
 
-  // Returns the display used for software mirrroring.
-  const gfx::Display& software_mirroring_display() const {
-    return software_mirroring_display_;
-  }
+  bool IsInUnifiedMode() const;
+
+  // Returns the display used for software mirrroring. Returns invalid
+  // display if not found.
+  const gfx::Display GetMirroringDisplayById(int64 id) const;
 
   // Retuns the display info associated with |display_id|.
   const DisplayInfo& GetDisplayInfo(int64 display_id) const;
 
   // Returns the human-readable name for the display |id|.
   std::string GetDisplayNameForId(int64 id);
 
   // Returns the display id that is capable of UI scaling. On device,
   // this returns internal display's ID if its device scale factor is 2,
   // or invalid ID if such internal display doesn't exist. On linux
   // desktop, this returns the first display ID.
   int64 GetDisplayIdForUIScaling() const;
 
   // Change the mirror mode.
   void SetMirrorMode(bool mirrored);
 
   // Used to emulate display change when run in a desktop environment instead
   // of on a device.
   void AddRemoveDisplay();
   void ToggleDisplayScaleFactor();
 
   // SoftwareMirroringController override:
 #if defined(OS_CHROMEOS)
   void SetSoftwareMirroring(bool enabled) override;
   bool SoftwareMirroringEnabled() const override;
 #endif
   bool software_mirroring_enabled() const {
-    return second_display_mode_ == MIRRORING;
+    return multi_display_mode_ == MIRRORING;
   };
 
-  // Sets/gets second display mode.
-  void SetSecondDisplayMode(SecondDisplayMode mode);
-  SecondDisplayMode second_display_mode() const {
-    return second_display_mode_;
+  // Sets/gets multi display mode.
+  void SetMultiDisplayMode(MultiDisplayMode mode);
+  MultiDisplayMode multi_display_mode() const { return multi_display_mode_; }
+
+  // Sets/gets default multi display mode.
+  void SetDefaultMultiDisplayMode(MultiDisplayMode mode);
+  MultiDisplayMode default_multi_display_mode() const {
+    return default_multi_display_mode_;
   }
 
   // Update the bounds of the display given by |display_id|.
   bool UpdateDisplayBounds(int64 display_id,
                            const gfx::Rect& new_bounds);
 
   // Creates mirror window asynchronously if the software mirror mode
   // is enabled.
   void CreateMirrorWindowAsyncIfAny();
 
@@ skipping 92 matching lines @@
   // Selected display modes for displays. Key is the displays' ID.
   std::map<int64, DisplayMode> display_modes_;
 
   // When set to true, the host window's resize event updates
   // the display's size. This is set to true when running on
   // desktop environment (for debugging) so that resizing the host
   // window will update the display properly. This is set to false
   // on device as well as during the unit tests.
   bool change_display_upon_host_resize_;
 
-  SecondDisplayMode second_display_mode_;
+  MultiDisplayMode multi_display_mode_;
+  MultiDisplayMode default_multi_display_mode_;
+
   int64 mirroring_display_id_;
-  gfx::Display software_mirroring_display_;
+  DisplayList software_mirroring_display_list_;
 
   // User preference for rotation lock of the internal display.
   bool registered_internal_display_rotation_lock_;
 
   // User preference for the rotation of the internal display.
   gfx::Display::Rotation registered_internal_display_rotation_;
 
   base::WeakPtrFactory<DisplayManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayManager);
 };
 
 }  // namespace ash
 
 #endif  // ASH_DISPLAY_DISPLAY_MANAGER_H_