Create a mirror window.

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>
 
 #include "ash/ash_export.h"
 #include "ash/display/display_info.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "ui/aura/root_window_observer.h"
 #include "ui/aura/window.h"
+#include "ui/gfx/display.h"
 
 namespace gfx {
 class Display;
 class Insets;
 class Rect;
 }
 
 namespace ash {
 class AcceleratorControllerTest;
 namespace test {
@@ skipping 97 matching lines @@
   // Returns the logical number of displays. This returns 1
   // when displays are mirrored.
   size_t GetNumDisplays() const;
 
   // 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 IsMirrored() const;
-  int64 mirrored_display_id() const { return mirrored_display_id_; }
+  int64 mirrored_display_id() const { return mirrored_display_.id(); }
 
   // Returns the display object nearest given |window|.
   const gfx::Display& GetDisplayNearestPoint(
       const gfx::Point& point) const;
 
   // Returns the display object nearest given |point|.
   const gfx::Display& GetDisplayNearestWindow(
       const aura::Window* window) const;
 
   // Returns the display that most closely intersects |match_rect|.
   const gfx::Display& GetDisplayMatching(
       const gfx::Rect& match_rect)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;
 
-  // RootWindowObserver overrides:
-  virtual void OnRootWindowResized(const aura::RootWindow* root,
-                                   const gfx::Size& new_size) OVERRIDE;
-
   // 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();
 
+  // RootWindowObserver overrides:
+  virtual void OnRootWindowResized(const aura::RootWindow* root,
+                                   const gfx::Size& new_size) OVERRIDE;
+
+  // TODO(oshima): This will be SoftwareMirroringController override:
+  void SetSoftwareMirroring(bool enabled);
+
  private:
   FRIEND_TEST_ALL_PREFIXES(ExtendedDesktopTest, ConvertPoint);
   FRIEND_TEST_ALL_PREFIXES(DisplayManagerTest, TestNativeDisplaysChanged);
   FRIEND_TEST_ALL_PREFIXES(DisplayManagerTest,
                            NativeDisplaysChangedAfterPrimaryChange);
   FRIEND_TEST_ALL_PREFIXES(DisplayManagerTest, AutomaticOverscanInsets);
   friend class ash::AcceleratorControllerTest;
   friend class test::DisplayManagerTestApi;
   friend class DisplayManagerTest;
   friend class test::SystemGestureEventFilterTest;
@@ skipping 17 matching lines @@
   // can be different from |new_info| (due to overscan state), so
   // you must use |GetDisplayInfo| to get the correct DisplayInfo for
   // a display.
   void InsertAndUpdateDisplayInfo(const DisplayInfo& new_info);
 
   // Creates a display object from the DisplayInfo for |display_id|.
   gfx::Display CreateDisplayFromDisplayInfoById(int64 display_id);
 
   int64 first_display_id_;
 
-  int64 mirrored_display_id_;
+  gfx::Display mirrored_display_;
 
   // List of current active dispays.
   DisplayList displays_;
 
   int num_connected_displays_;
 
   bool force_bounds_changed_;
 
   // The mapping from the display ID to its internal data.
   std::map<int64, DisplayInfo> display_info_;
 
   // 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 wil update the display properly. This is set to false
   // on device as well as during the unit tests.
   bool change_display_upon_host_resize_;
 
+  bool software_mirroring_enabled_;
+
   DISALLOW_COPY_AND_ASSIGN(DisplayManager);
 };
 
 extern const aura::WindowProperty<int64>* const kDisplayIdKey;
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  // ASH_DISPLAY_DISPLAY_MANAGER_H_