Create a mirror window.

ash/display/display_manager.cc

 // 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.
 
 #include "ash/display/display_manager.h"
 
 #include <cmath>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
+#include "ash/display/mirror_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/utf_string_conversions.h"
 #include "grit/ash_strings.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"
 #endif
 
 #if defined(OS_CHROMEOS)
+#include "ash/display/output_configurator_animation.h"
 #include "base/chromeos/chromeos_version.h"
 #include "chromeos/display/output_configurator.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "ui/aura/remote_root_window_host_win.h"
 #endif
 
 DECLARE_WINDOW_PROPERTY_TYPE(int64);
@@ skipping 33 matching lines @@
     return std::abs(scale - s) < kEpsilon;
   }
   float scale;
 };
 
 gfx::Display& GetInvalidDisplay() {
   static gfx::Display* invalid_display = new gfx::Display();
   return *invalid_display;
 }
 
+// Used to either create or close the mirror window
+// after all displays and associated RootWidows are
+// configured in UpdateDisplay.
+class MirrorWindowUpdater {
+ public:
+  virtual ~MirrorWindowUpdater() {}
+};
+
+class MirrorWindowCreator : public MirrorWindowUpdater {
+ public:
+  explicit MirrorWindowCreator(const DisplayInfo& display_info)
+      : display_info_(display_info) {
+  }
+
+  virtual ~MirrorWindowCreator() {
+    Shell::GetInstance()->mirror_window_controller()->
+        UpdateWindow(display_info_);
+  }
+
+ private:
+  const DisplayInfo display_info_;
+  DISALLOW_COPY_AND_ASSIGN(MirrorWindowCreator);
+};
+
+class MirrorWindowCloser : public MirrorWindowUpdater {
+ public:
+  MirrorWindowCloser() {}
+  virtual ~MirrorWindowCloser() {
+    Shell::GetInstance()->mirror_window_controller()->Close();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MirrorWindowCloser);
+};
+
 }  // namespace
 
 using aura::RootWindow;
 using aura::Window;
 using std::string;
 using std::vector;
 
 DEFINE_WINDOW_PROPERTY_KEY(int64, kDisplayIdKey,
                            gfx::Display::kInvalidDisplayID);
 
 DisplayManager::DisplayManager()
     : first_display_id_(gfx::Display::kInvalidDisplayID),
-      mirrored_display_id_(gfx::Display::kInvalidDisplayID),
       num_connected_displays_(0),
       force_bounds_changed_(false),
-      change_display_upon_host_resize_(false) {
+      change_display_upon_host_resize_(false),
+      software_mirroring_enabled_(false) {
 #if defined(OS_CHROMEOS)
   change_display_upon_host_resize_ = !base::chromeos::IsRunningOnChromeOS();
 #endif
   Init();
 }
 
 DisplayManager::~DisplayManager() {
 }
 
 // static
@@ skipping 210 matching lines @@
   if (updated_displays.size() == 1) {
     VLOG(1) << "OnNativeDisplaysChanged(1):" << updated_displays[0].ToString();
   } else {
     VLOG(1) << "OnNativeDisplaysChanged(" << updated_displays.size()
             << ") [0]=" << updated_displays[0].ToString()
             << ", [1]=" << updated_displays[1].ToString();
   }
 
   bool internal_display_connected = false;
   num_connected_displays_ = updated_displays.size();
-  mirrored_display_id_ = gfx::Display::kInvalidDisplayID;
+  mirrored_display_ = gfx::Display();
   DisplayInfoList new_display_info_list;
   for (DisplayInfoList::const_iterator iter = updated_displays.begin();
        iter != updated_displays.end();
        ++iter) {
     if (!internal_display_connected)
       internal_display_connected = IsInternalDisplayId(iter->id());
     // Mirrored monitors have the same y coordinates.
     int y = iter->bounds_in_pixel().y();
     if (y_coords.find(y) != y_coords.end()) {
       InsertAndUpdateDisplayInfo(*iter);
-      mirrored_display_id_ = iter->id();
+      mirrored_display_ = CreateDisplayFromDisplayInfoById(iter->id());
     } else {
       y_coords.insert(y);
       new_display_info_list.push_back(*iter);
     }
   }
   if (HasInternalDisplay() &&
       !internal_display_connected &&
       display_info_.find(gfx::Display::InternalDisplayId()) ==
       display_info_.end()) {
     DisplayInfo internal_display_info(
@@ skipping 25 matching lines @@
   DisplayList removed_displays;
   std::vector<size_t> changed_display_indices;
   std::vector<size_t> added_display_indices;
 
   DisplayList::iterator curr_iter = displays_.begin();
   DisplayInfoList::const_iterator new_info_iter = new_display_info_list.begin();
 
   DisplayList new_displays;
   bool update_mouse_location = false;
 
+  scoped_ptr<MirrorWindowUpdater> mirror_window_updater;
+  // TODO(oshima): We may want to use external as the source.
+  int mirrored_display_id = gfx::Display::kInvalidDisplayID;
+  if (software_mirroring_enabled_ && updated_display_info_list.size() == 2)
+    mirrored_display_id = updated_display_info_list[1].id();
+
   while (curr_iter != displays_.end() ||
          new_info_iter != new_display_info_list.end()) {
+    if (new_info_iter != new_display_info_list.end() &&
+        mirrored_display_id == new_info_iter->id()) {
+      InsertAndUpdateDisplayInfo(*new_info_iter);
+      mirrored_display_ = CreateDisplayFromDisplayInfoById(new_info_iter->id());
+      mirror_window_updater.reset(
+          new MirrorWindowCreator(display_info_[new_info_iter->id()]));
+      ++new_info_iter;
+      // Remove existing external dispaly if it is going to be mirrored.
+      if (curr_iter != displays_.end() &&
+          curr_iter->id() == mirrored_display_id) {
+        removed_displays.push_back(*curr_iter);
+        ++curr_iter;
+      }
+      update_mouse_location = true;
+      continue;
+    }
+
     if (curr_iter == displays_.end()) {
       // more displays in new list.
       added_display_indices.push_back(new_displays.size());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       new_displays.push_back(
           CreateDisplayFromDisplayInfoById(new_info_iter->id()));
       ++new_info_iter;
     } else if (new_info_iter == new_display_info_list.end()) {
       // more displays in current list.
       removed_displays.push_back(*curr_iter);
       ++curr_iter;
       update_mouse_location = true;
     } else if (curr_iter->id() == new_info_iter->id()) {
       const gfx::Display& current_display = *curr_iter;
       // Copy the info because |CreateDisplayFromInfo| updates the instance.
       const DisplayInfo current_display_info =
           GetDisplayInfo(current_display.id());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       gfx::Display new_display =
           CreateDisplayFromDisplayInfoById(new_info_iter->id());
       const DisplayInfo& new_display_info = GetDisplayInfo(new_display.id());
 
       bool host_window_bounds_changed =
           current_display_info.bounds_in_pixel() !=
           new_display_info.bounds_in_pixel();
 
-      // TODO(oshima): Rotating square dislay doesn't work as the size
-      // won't change. This doesn't cause a problem now as there is no
-      // such display. This will be fixed by comparing the rotation as
-      // well when the rotation variable is added to gfx::Display.
       if (force_bounds_changed_ ||
           host_window_bounds_changed ||
           (current_display.device_scale_factor() !=
            new_display.device_scale_factor()) ||
           (current_display_info.size_in_pixel() !=
-           new_display.GetSizeInPixel())) {
+           new_display.GetSizeInPixel()) ||
+          (current_display.rotation() != new_display.rotation())) {
 
         // Don't update mouse location if the display size has
         // changed due to rotation or zooming.
         if (host_window_bounds_changed)
           update_mouse_location = true;
 
         changed_display_indices.push_back(new_displays.size());
       }
 
       new_display.UpdateWorkAreaFromInsets(current_display.GetWorkAreaInsets());
       new_displays.push_back(new_display);
       ++curr_iter;
       ++new_info_iter;
     } else if (curr_iter->id() < new_info_iter->id()) {
       // more displays in current list between ids, which means it is deleted.
       removed_displays.push_back(*curr_iter);
       ++curr_iter;
       update_mouse_location = true;
     } else {
       // more displays in new list between ids, which means it is added.
       added_display_indices.push_back(new_displays.size());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       new_displays.push_back(
           CreateDisplayFromDisplayInfoById(new_info_iter->id()));
       ++new_info_iter;
     }
   }
 
+  // Try to close mirror window unless mirror window is necessary.
+  if (!mirror_window_updater.get())
+    mirror_window_updater.reset(new MirrorWindowCloser);
+
   // Do not update |displays_| if there's nothing to be updated. Without this,
   // it will not update the display layout, which causes the bug
   // http://crbug.com/155948.
   if (changed_display_indices.empty() && added_display_indices.empty() &&
       removed_displays.empty()) {
     return;
   }
 
   DisplayController* display_controller =
       Shell::GetInstance()->display_controller();
@@ skipping 61 matching lines @@
   }
 #endif
   return primary_candidate;
 }
 
 size_t DisplayManager::GetNumDisplays() const {
   return displays_.size();
 }
 
 bool DisplayManager::IsMirrored() const {
-  return mirrored_display_id_ != gfx::Display::kInvalidDisplayID;
+  return mirrored_display_.id() != gfx::Display::kInvalidDisplayID;
 }
 
 const gfx::Display& DisplayManager::GetDisplayNearestWindow(
     const Window* window) const {
   if (!window)
     return DisplayController::GetPrimaryDisplay();
   const RootWindow* root = window->GetRootWindow();
   DisplayManager* manager = const_cast<DisplayManager*>(this);
   return root ?
       manager->FindDisplayForRootWindow(root) :
@@ skipping 40 matching lines @@
   if (id == gfx::Display::kInvalidDisplayID)
     return l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
 
   std::map<int64, DisplayInfo>::const_iterator iter = display_info_.find(id);
   if (iter != display_info_.end() && !iter->second.name().empty())
     return iter->second.name();
 
   return base::StringPrintf("Display %d", static_cast<int>(id));
 }
 
-void DisplayManager::OnRootWindowResized(const aura::RootWindow* root,
-                                         const gfx::Size& old_size) {
-  if (change_display_upon_host_resize_) {
-    gfx::Display& display = FindDisplayForRootWindow(root);
-    gfx::Size old_display_size_in_pixel = display.GetSizeInPixel();
-    display_info_[display.id()].SetBounds(
-        gfx::Rect(root->GetHostOrigin(), root->GetHostSize()));
-    const gfx::Size& new_root_size = root->bounds().size();
-    if (old_size != new_root_size) {
-      display.SetSize(display_info_[display.id()].size_in_pixel());
-      Shell::GetInstance()->screen()->NotifyBoundsChanged(display);
-    }
-  }
-}
-
 void DisplayManager::SetMirrorMode(bool mirrored) {
   if (num_connected_displays() <= 1)
     return;
 
 #if defined(OS_CHROMEOS)
   if (base::chromeos::IsRunningOnChromeOS()) {
     chromeos::OutputState new_state = mirrored ?
         chromeos::STATE_DUAL_MIRROR : chromeos::STATE_DUAL_EXTENDED;
     Shell::GetInstance()->output_configurator()->SetDisplayMode(new_state);
-  } else {
-    // TODO(oshima): Compositor based mirroring.
+    return;
+  }
+#endif
+  SetSoftwareMirroring(mirrored);
+  DisplayInfoList display_info_list;
+  int count = 0;
+  for (std::map<int64, DisplayInfo>::const_iterator iter =
+           display_info_.begin();
+       count < 2; ++iter, ++count) {
+    display_info_list.push_back(GetDisplayInfo(iter->second.id()));
+  }
+  UpdateDisplays(display_info_list);
+#if defined(OS_CHROMEOS)
+  if (Shell::GetInstance()->output_configurator_animation()) {
+    Shell::GetInstance()->output_configurator_animation()->
+        StartFadeInAnimation();
   }
 #endif
 }
 
 void DisplayManager::AddRemoveDisplay() {
   DCHECK(!displays_.empty());
   std::vector<DisplayInfo> new_display_info_list;
   new_display_info_list.push_back(
       GetDisplayInfo(DisplayController::GetPrimaryDisplay().id()));
-  // Add if there is only one display.
-  if (displays_.size() == 1) {
+  // Add if there is only one display connected.
+  if (num_connected_displays() == 1) {
     // Layout the 2nd display below the primary as with the real device.
     aura::RootWindow* primary = Shell::GetPrimaryRootWindow();
     gfx::Rect host_bounds =
         gfx::Rect(primary->GetHostOrigin(),  primary->GetHostSize());
     new_display_info_list.push_back(DisplayInfo::CreateFromSpec(
         base::StringPrintf(
             "%d+%d-500x400", host_bounds.x(), host_bounds.bottom())));
   }
   num_connected_displays_ = new_display_info_list.size();
   UpdateDisplays(new_display_info_list);
 }
 
 void DisplayManager::ToggleDisplayScaleFactor() {
   DCHECK(!displays_.empty());
   std::vector<DisplayInfo> new_display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     DisplayInfo display_info = GetDisplayInfo(iter->id());
     display_info.set_device_scale_factor(
         display_info.device_scale_factor() == 1.0f ? 2.0f : 1.0f);
     new_display_info_list.push_back(display_info);
   }
   UpdateDisplays(new_display_info_list);
 }
 
+void DisplayManager::OnRootWindowResized(const aura::RootWindow* root,
+                                         const gfx::Size& old_size) {
+  if (change_display_upon_host_resize_) {
+    gfx::Display& display = FindDisplayForRootWindow(root);
+    gfx::Size old_display_size_in_pixel = display.GetSizeInPixel();
+    display_info_[display.id()].SetBounds(
+        gfx::Rect(root->GetHostOrigin(), root->GetHostSize()));
+    const gfx::Size& new_root_size = root->bounds().size();
+    if (old_size != new_root_size) {
+      display.SetSize(display_info_[display.id()].size_in_pixel());
+      Shell::GetInstance()->screen()->NotifyBoundsChanged(display);
+    }
+  }
+}
+
+void DisplayManager::SetSoftwareMirroring(bool enabled) {
+  software_mirroring_enabled_ = enabled;
+  mirrored_display_ = gfx::Display();
+}
+
 int64 DisplayManager::GetDisplayIdForUIScaling() const {
   // UI Scaling is effective only on internal display.
   int64 display_id = gfx::Display::InternalDisplayId();
 #if defined(OS_WIN)
   display_id = first_display_id();
 #endif
   return display_id;
 }
 
 void DisplayManager::Init() {
@@ skipping 11 matching lines @@
   first_display_id_ = displays_[0].id();
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshUseFirstDisplayAsInternal))
     gfx::Display::SetInternalDisplayId(first_display_id_);
   num_connected_displays_ = displays_.size();
 }
 
 gfx::Display& DisplayManager::FindDisplayForRootWindow(
     const aura::RootWindow* root_window) {
   int64 id = root_window->GetProperty(kDisplayIdKey);
+  // RootWindow needs Display to determine it's device scale factor.
+  // TODO(oshima): We don't need full display info for mirror
+  // window. Refactor so that RootWindow doesn't use it.
+  if (mirrored_display_.id() == id)
+    return mirrored_display_;
+
   // if id is |kInvaildDisplayID|, it's being deleted.
   DCHECK(id != gfx::Display::kInvalidDisplayID);
   gfx::Display& display = FindDisplayForId(id);
   DCHECK(display.is_valid());
   return display;
 }
 
 gfx::Display& DisplayManager::FindDisplayForId(int64 id) {
   for (DisplayList::iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
@@ skipping 34 matching lines @@
   // always (0,0) and the secondary display's bounds will be updated
   // by |DisplayController::UpdateDisplayBoundsForLayout|.
   new_display.SetScaleAndBounds(
       display_info.device_scale_factor(), gfx::Rect(bounds_in_pixel.size()));
   new_display.set_rotation(display_info.rotation());
   return new_display;
 }
 
 }  // namespace internal
 }  // namespace ash