Try to enable software mirror mode in UI message loop after Init()

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>
@@ skipping 85 matching lines @@
 }
 
 void MaybeInitInternalDisplay(int64 id) {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshUseFirstDisplayAsInternal))
     gfx::Display::SetInternalDisplayId(id);
 }
 
 // Scoped objects used to either create or close the mirror window
 // at specific timing.
-class MirrorWindowCreator {
+class MirrorWindowUpdater {
  public:
-  MirrorWindowCreator(DisplayManager::Delegate* delegate,
-                      const DisplayInfo& display_info)
-      : delegate_(delegate),
-        display_info_(display_info) {
+  MirrorWindowUpdater(DisplayManager* manager,
+                      DisplayManager::Delegate* delegate)
+      : manager_(manager),
+        delegate_(delegate),
+        enabled_(manager_->software_mirroring_enabled() &&
+                 manager_->mirrored_display().is_valid()) {
   }
 
-  virtual ~MirrorWindowCreator() {
-    if (delegate_)
-      delegate_->CreateOrUpdateMirrorWindow(display_info_);
+  ~MirrorWindowUpdater() {
+    if (!delegate_)
+      return;
+
+    if (enabled_) {
+      DisplayInfo display_info = manager_->GetDisplayInfo(
+          manager_->mirrored_display().id());
+      delegate_->CreateOrUpdateMirrorWindow(display_info);
+    } else {
+      delegate_->CloseMirrorWindow();
+    }
   }
 
- private:
-  DisplayManager::Delegate* delegate_;
-  const DisplayInfo display_info_;
-  DISALLOW_COPY_AND_ASSIGN(MirrorWindowCreator);
-};
-
-class MirrorWindowCloser {
- public:
-  explicit MirrorWindowCloser(DisplayManager::Delegate* delegate)
-      : delegate_(delegate)  {}
-
-  virtual ~MirrorWindowCloser() {
-    if (delegate_)
-      delegate_->CloseMirrorWindow();
-  }
+  bool enabled() const { return enabled_; }
 
  private:
+  DisplayManager* manager_;
   DisplayManager::Delegate* delegate_;
-
-  DISALLOW_COPY_AND_ASSIGN(MirrorWindowCloser);
+  bool enabled_;
+  DISALLOW_COPY_AND_ASSIGN(MirrorWindowUpdater);
 };
 
 }  // namespace
 
 using std::string;
 using std::vector;
 
 DisplayManager::DisplayManager()
     : delegate_(NULL),
       layout_store_(new DisplayLayoutStore),
@@ skipping 50 matching lines @@
         return scales[i - 1];
       return scales[i];
     }
   }
   // Fallback to 1.0f if the |scale| wasn't in the list.
   return 1.0f;
 }
 
 void DisplayManager::InitFromCommandLine() {
   DisplayInfoList info_list;
-
-  const string size_str = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-      switches::kAshHostWindowBounds);
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  const string size_str =
+      command_line->GetSwitchValueASCII(switches::kAshHostWindowBounds);
   vector<string> parts;
   base::SplitString(size_str, ',', &parts);
   for (vector<string>::const_iterator iter = parts.begin();
        iter != parts.end(); ++iter) {
     info_list.push_back(DisplayInfo::CreateFromSpec(*iter));
   }
   if (info_list.size())
     MaybeInitInternalDisplay(info_list[0].id());
+  if (info_list.size() > 1 &&
+      command_line->HasSwitch(switches::kAshEnableSoftwareMirroring)) {
+    SetSoftwareMirroring(true);
+  }
   OnNativeDisplaysChanged(info_list);
 }
 
 // static
 void DisplayManager::UpdateDisplayBoundsForLayoutById(
     const DisplayLayout& layout,
     const gfx::Display& primary_display,
     int64 secondary_display_id) {
   DCHECK_NE(gfx::Display::kInvalidDisplayID, secondary_display_id);
   UpdateDisplayBoundsForLayout(
@@ skipping 301 matching lines @@
             DisplayInfoSortFunctor());
   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;
 
-  scoped_ptr<MirrorWindowCreator> mirror_window_creater;
-
   // Use the internal display or 1st as the mirror source, then scale
   // the root window so that it matches the external display's
   // resolution. This is necessary in order for scaling to work while
   // mirrored.
   int64 mirrored_display_id = gfx::Display::kInvalidDisplayID;
   if (software_mirroring_enabled_ && new_display_info_list.size() == 2)
     mirrored_display_id = new_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()) {
       DisplayInfo info = *new_info_iter;
       info.SetOverscanInsets(gfx::Insets());
       InsertAndUpdateDisplayInfo(info);
-
       mirrored_display_ = CreateDisplayFromDisplayInfoById(new_info_iter->id());
-      mirror_window_creater.reset(new MirrorWindowCreator(
-          delegate_, 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;
       }
       continue;
     }
 
@@ skipping 44 matching lines @@
     } 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;
     }
   }
 
-  scoped_ptr<MirrorWindowCloser> mirror_window_closer;
-  // Try to close mirror window unless mirror window is necessary.
-  if (!mirror_window_creater.get())
-    mirror_window_closer.reset(new MirrorWindowCloser(delegate_));
+  scoped_ptr<MirrorWindowUpdater> mirror_window_updater(
+      new MirrorWindowUpdater(this, delegate_));
 
   // 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;
   }
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(!removed_displays.empty());
@@ skipping 18 matching lines @@
   displays_.insert(displays_.end(), removed_displays.begin(),
                    removed_displays.end());
 
   for (DisplayList::const_reverse_iterator iter = removed_displays.rbegin();
        iter != removed_displays.rend(); ++iter) {
     Shell::GetInstance()->screen()->NotifyDisplayRemoved(displays_.back());
     displays_.pop_back();
   }
   // Close the mirror window here to avoid creating two compositor on
   // one display.
-  mirror_window_closer.reset();
+  if (!mirror_window_updater->enabled())
+    mirror_window_updater.reset();
   for (std::vector<size_t>::iterator iter = added_display_indices.begin();
        iter != added_display_indices.end(); ++iter) {
     Shell::GetInstance()->screen()->NotifyDisplayAdded(displays_[*iter]);
   }
   // Create the mirror window after all displays are added so that
   // it can mirror the display newly added. This can happen when switching
   // from dock mode to software mirror mode.
-  mirror_window_creater.reset();
+  mirror_window_updater.reset();
   for (std::vector<size_t>::iterator iter = changed_display_indices.begin();
        iter != changed_display_indices.end(); ++iter) {
     Shell::GetInstance()->screen()->NotifyBoundsChanged(displays_[*iter]);
   }
   if (delegate_)
     delegate_->PostDisplayConfigurationChange();
 
 #if defined(USE_X11) && defined(OS_CHROMEOS)
   if (!changed_display_indices.empty() && base::chromeos::IsRunningOnChromeOS())
     ui::ClearX11DefaultRootWindow();
@@ skipping 123 matching lines @@
     if (software_mirroring_enabled_ && mirrored_display_.id() == display_id)
       return false;
     gfx::Display* display = FindDisplayForId(display_id);
     display->SetSize(display_info_[display_id].size_in_pixel());
     Shell::GetInstance()->screen()->NotifyBoundsChanged(*display);
     return true;
   }
   return false;
 }
 
+void DisplayManager::CreateMirrorWindowIfAny() {
+  MirrorWindowUpdater updater(this, delegate_);
+}
+
 gfx::Display* DisplayManager::FindDisplayForId(int64 id) {
   for (DisplayList::iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     if ((*iter).id() == id)
       return &(*iter);
   }
   DLOG(WARNING) << "Could not find display:" << id;
   return NULL;
 }
 
@@ skipping 63 matching lines @@
     gfx::Rect bounds =
         GetDisplayForId(displays->at(secondary_index).id()).bounds();
     UpdateDisplayBoundsForLayout(
         layout, displays->at(primary_index), &displays->at(secondary_index));
     *updated_index = secondary_index;
     return bounds != displays->at(secondary_index).bounds();
   }
   return false;
 }
 
+
 // static
 void DisplayManager::UpdateDisplayBoundsForLayout(
     const DisplayLayout& layout,
     const gfx::Display& primary_display,
     gfx::Display* secondary_display) {
   DCHECK_EQ("0,0", primary_display.bounds().origin().ToString());
 
   const gfx::Rect& primary_bounds = primary_display.bounds();
   const gfx::Rect& secondary_bounds = secondary_display->bounds();
   gfx::Point new_secondary_origin = primary_bounds.origin();
@@ skipping 29 matching lines @@
       break;
   }
   gfx::Insets insets = secondary_display->GetWorkAreaInsets();
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 }  // namespace internal
 }  // namespace ash