DisplayManager Cleanup

rename
 "mirrored -> mirroring" (as the display is not the source)
 "mirroring_dislpay -> software_mirroring_display"
 "IsMirrored -> IsInMirroredDisplay"

fixed typo

BUG=None
TBR=rockot@chromium.org

Review URL: https://codereview.chromium.org/1097823002

Cr-Commit-Position: refs/heads/master@{#326060}

13 files changed, 122 insertions, 148 deletions

diff --git a/ash/display/display_controller.cc b/ash/display/display_controller.cc
index 166a76f..445e804 100644
--- a/ash/display/display_controller.cc
+++ b/ash/display/display_controller.cc
@@ -436,10 +436,9 @@ void DisplayController::ToggleMirrorMode() {
   Shell* shell = Shell::GetInstance();
   DisplayConfiguratorAnimation* animation =
       shell->display_configurator_animation();
-  animation->StartFadeOutAnimation(
-      base::Bind(&DisplayController::SetMirrorModeAfterAnimation,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 !display_manager->IsMirrored()));
+  animation->StartFadeOutAnimation(base::Bind(
+      &DisplayController::SetMirrorModeAfterAnimation,
+      weak_ptr_factory_.GetWeakPtr(), !display_manager->IsInMirrorMode()));
 #endif
 }
 
@@ -781,7 +780,7 @@ void DisplayController::PostDisplayConfigurationChange() {
   DisplayLayoutStore* layout_store = display_manager->layout_store();
   if (display_manager->num_connected_displays() > 1) {
     DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
-    layout_store->UpdateMirrorStatus(pair, display_manager->IsMirrored());
+    layout_store->UpdateMirrorStatus(pair, display_manager->IsInMirrorMode());
     DisplayLayout layout = layout_store->GetRegisteredDisplayLayout(pair);
 
     if (Shell::GetScreen()->GetNumDisplays() > 1 ) {
diff --git a/ash/display/display_manager.cc b/ash/display/display_manager.cc
index b731ded..c027d3d 100644
--- a/ash/display/display_manager.cc
+++ b/ash/display/display_manager.cc
@@ -118,11 +118,10 @@ DisplayManager::DisplayManager()
       force_bounds_changed_(false),
       change_display_upon_host_resize_(false),
       second_display_mode_(EXTENDED),
-      mirrored_display_id_(gfx::Display::kInvalidDisplayID),
+      mirroring_display_id_(gfx::Display::kInvalidDisplayID),
       registered_internal_display_rotation_lock_(false),
       registered_internal_display_rotation_(gfx::Display::ROTATE_0),
       weak_ptr_factory_(this) {
-
 #if defined(OS_CHROMEOS)
   // Enable only on the device so that DisplayManagerFontTest passes.
   if (base::SysInfo::IsRunningOnChromeOS())
@@ -233,14 +232,14 @@ DisplayLayout DisplayManager::GetCurrentDisplayLayout() {
 }
 
 DisplayIdPair DisplayManager::GetCurrentDisplayIdPair() const {
-  if (IsMirrored()) {
+  if (IsInMirrorMode()) {
     if (software_mirroring_enabled()) {
       CHECK_EQ(2u, num_connected_displays());
       // This comment is to make it easy to distinguish the crash
       // between two checks.
       CHECK_EQ(1u, displays_.size());
     }
-    return std::make_pair(displays_[0].id(), mirrored_display_id_);
+    return std::make_pair(displays_[0].id(), mirroring_display_id_);
   } else {
     CHECK_LE(2u, displays_.size());
     int64 id_at_zero = displays_[0].id();
@@ -607,8 +606,8 @@ void DisplayManager::OnNativeDisplaysChanged(
 
   bool internal_display_connected = false;
   num_connected_displays_ = updated_displays.size();
-  mirrored_display_id_ = gfx::Display::kInvalidDisplayID;
-  mirroring_display_ = gfx::Display();
+  mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
+  software_mirroring_display_ = gfx::Display();
   DisplayInfoList new_display_info_list;
   for (DisplayInfoList::const_iterator iter = updated_displays.begin();
        iter != updated_displays.end();
@@ -619,7 +618,7 @@ void DisplayManager::OnNativeDisplaysChanged(
     gfx::Point origin = iter->bounds_in_native().origin();
     if (origins.find(origin) != origins.end()) {
       InsertAndUpdateDisplayInfo(*iter);
-      mirrored_display_id_ = iter->id();
+      mirroring_display_id_ = iter->id();
     } else {
       origins.insert(origin);
       new_display_info_list.push_back(*iter);
@@ -680,6 +679,11 @@ void DisplayManager::UpdateDisplays(
   std::sort(new_display_info_list.begin(),
             new_display_info_list.end(),
             DisplayInfoSortFunctor());
+
+  if (second_display_mode_ == MIRRORING && new_display_info_list.size() == 2)
+    CreateSoftwareMirroringDisplay(&new_display_info_list);
+
+  DisplayList new_displays;
   DisplayList removed_displays;
   std::map<size_t, uint32_t> display_changes;
   std::vector<size_t> added_display_indices;
@@ -687,43 +691,8 @@ void DisplayManager::UpdateDisplays(
   DisplayList::iterator curr_iter = displays_.begin();
   DisplayInfoList::const_iterator new_info_iter = new_display_info_list.begin();
 
-  DisplayList new_displays;
-
-  // 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 mirroing_display_id = gfx::Display::kInvalidDisplayID;
-
-  if (second_display_mode_ != EXTENDED && new_display_info_list.size() == 2) {
-    bool zero_is_source =
-        first_display_id_ == new_display_info_list[0].id() ||
-        gfx::Display::InternalDisplayId() == new_display_info_list[0].id();
-    DCHECK_EQ(MIRRORING, second_display_mode_);
-    mirrored_display_id_ = new_display_info_list[zero_is_source ? 1 : 0].id();
-    mirroing_display_id = mirrored_display_id_;
-  }
-
   while (curr_iter != displays_.end() ||
          new_info_iter != new_display_info_list.end()) {
-    if (new_info_iter != new_display_info_list.end() &&
-        mirroing_display_id == new_info_iter->id()) {
-      DisplayInfo info = *new_info_iter;
-      info.SetOverscanInsets(gfx::Insets());
-      InsertAndUpdateDisplayInfo(info);
-      mirroring_display_ =
-          CreateDisplayFromDisplayInfoById(mirroing_display_id);
-      ++new_info_iter;
-      // Remove existing external display if it is going to be used as
-      // mirroring display.
-      if (curr_iter != displays_.end() &&
-          curr_iter->id() == mirroing_display_id) {
-        removed_displays.push_back(*curr_iter);
-        ++curr_iter;
-      }
-      continue;
-    }
-
     if (curr_iter == displays_.end()) {
       // more displays in new list.
       added_display_indices.push_back(new_displays.size());
@@ -805,29 +774,6 @@ void DisplayManager::UpdateDisplays(
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(clear_focus);
 
-  // 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 (display_changes.empty() && added_display_indices.empty() &&
-      removed_displays.empty()) {
-    // When changing from software mirroring mode to sinlge display
-    // mode, it is possible there is no need to update |displays_| and
-    // we early out here. But we still need to update the mirroring
-    // window and call the PostDisplayConfigurationChange() cause
-    // there are some clients need to act on this,
-    // e.g. TouchTransformerController needs to adjust the
-    // TouchTransformer when/ switching from dual displays to single
-    // display.
-    if (delegate_) {
-      if (HasSoftwareMirroringDisplay())
-        CreateMirrorWindowAsyncIfAny();
-      else
-        delegate_->CloseMirroringDisplay();
-      delegate_->PostDisplayConfigurationChange();
-    }
-    return;
-  }
-
   std::vector<size_t> updated_indices;
   if (UpdateNonPrimaryDisplayBoundsForLayout(&new_displays, &updated_indices)) {
     for (std::vector<size_t>::iterator it = updated_indices.begin();
@@ -938,8 +884,8 @@ size_t DisplayManager::GetNumDisplays() const {
   return displays_.size();
 }
 
-bool DisplayManager::IsMirrored() const {
-  return mirrored_display_id_ != gfx::Display::kInvalidDisplayID;
+bool DisplayManager::IsInMirrorMode() const {
+  return mirroring_display_id_ != gfx::Display::kInvalidDisplayID;
 }
 
 const DisplayInfo& DisplayManager::GetDisplayInfo(int64 display_id) const {
@@ -1016,8 +962,8 @@ void DisplayManager::AddRemoveDisplay() {
             "%d+%d-500x400", host_bounds.x(), host_bounds.bottom())));
   }
   num_connected_displays_ = new_display_info_list.size();
-  mirrored_display_id_ = gfx::Display::kInvalidDisplayID;
-  mirroring_display_ = gfx::Display();
+  mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
+  software_mirroring_display_ = gfx::Display();
   UpdateDisplays(new_display_info_list);
 }
 
@@ -1047,8 +993,8 @@ bool DisplayManager::SoftwareMirroringEnabled() const {
 
 void DisplayManager::SetSecondDisplayMode(SecondDisplayMode mode) {
   second_display_mode_ = mode;
-  mirrored_display_id_ = gfx::Display::kInvalidDisplayID;
-  mirroring_display_ = gfx::Display();
+  mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
+  software_mirroring_display_ = gfx::Display();
 }
 
 bool DisplayManager::UpdateDisplayBounds(int64 display_id,
@@ -1056,7 +1002,7 @@ bool DisplayManager::UpdateDisplayBounds(int64 display_id,
   if (change_display_upon_host_resize_) {
     display_info_[display_id].SetBounds(new_bounds);
     // Don't notify observers if the mirrored window has changed.
-    if (software_mirroring_enabled() && mirrored_display_id_ == display_id)
+    if (software_mirroring_enabled() && mirroring_display_id_ == display_id)
       return false;
     gfx::Display* display = FindDisplayForId(display_id);
     display->SetSize(display_info_[display_id].size_in_pixel());
@@ -1100,6 +1046,31 @@ void DisplayManager::UpdateInternalDisplayModeListForTest() {
   SetInternalDisplayModeList(info);
 }
 
+void DisplayManager::CreateSoftwareMirroringDisplay(
+    DisplayInfoList* display_info_list) {
+  // 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.
+  bool zero_is_source =
+      first_display_id_ == (*display_info_list)[0].id() ||
+      gfx::Display::InternalDisplayId() == (*display_info_list)[0].id();
+  DCHECK_EQ(MIRRORING, second_display_mode_);
+  mirroring_display_id_ = (*display_info_list)[zero_is_source ? 1 : 0].id();
+  int64 display_id = mirroring_display_id_;
+  auto iter = std::find_if(display_info_list->begin(), display_info_list->end(),
+                           [display_id](const DisplayInfo& info) {
+                             return info.id() == display_id;
+                           });
+  DCHECK(iter != display_info_list->end());
+  DisplayInfo info = *iter;
+  info.SetOverscanInsets(gfx::Insets());
+  InsertAndUpdateDisplayInfo(info);
+  software_mirroring_display_ =
+      CreateDisplayFromDisplayInfoById(mirroring_display_id_);
+  display_info_list->erase(iter);
+}
+
 gfx::Display* DisplayManager::FindDisplayForId(int64 id) {
   for (DisplayList::iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
@@ -1112,8 +1083,8 @@ gfx::Display* DisplayManager::FindDisplayForId(int64 id) {
 
 void DisplayManager::AddMirrorDisplayInfoIfAny(
     std::vector<DisplayInfo>* display_info_list) {
-  if (software_mirroring_enabled() && IsMirrored())
-    display_info_list->push_back(GetDisplayInfo(mirrored_display_id_));
+  if (software_mirroring_enabled() && IsInMirrorMode())
+    display_info_list->push_back(GetDisplayInfo(mirroring_display_id_));
 }
 
 void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info) {
@@ -1215,14 +1186,14 @@ bool DisplayManager::UpdateNonPrimaryDisplayBoundsForLayout(
 
 void DisplayManager::CreateMirrorWindowIfAny() {
   if (HasSoftwareMirroringDisplay() && delegate_) {
-    DisplayInfo display_info = GetDisplayInfo(mirroring_display_.id());
+    DisplayInfo display_info = GetDisplayInfo(software_mirroring_display_.id());
     delegate_->CreateOrUpdateMirroringDisplay(display_info);
   }
 }
 
 bool DisplayManager::HasSoftwareMirroringDisplay() {
   return second_display_mode_ != DisplayManager::EXTENDED &&
-      mirroring_display_.is_valid();
+         software_mirroring_display_.is_valid();
 }
 
 // static
diff --git a/ash/display/display_manager.h b/ash/display/display_manager.h
index 092d2b0..59e6259 100644
--- a/ash/display/display_manager.h
+++ b/ash/display/display_manager.h
@@ -244,12 +244,12 @@ class ASH_EXPORT DisplayManager
   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_; }
+  bool IsInMirrorMode() const;
+  int64 mirroring_display_id() const { return mirroring_display_id_; }
 
   // Returns the display used for software mirrroring.
-  const gfx::Display& mirroring_display() const {
-    return mirroring_display_;
+  const gfx::Display& software_mirroring_display() const {
+    return software_mirroring_display_;
   }
 
   // Retuns the display info associated with |display_id|.
@@ -316,16 +316,21 @@ private:
   friend class test::SystemGestureEventFilterTest;
 
   typedef std::vector<gfx::Display> DisplayList;
+  typedef std::vector<DisplayInfo> DisplayInfoList;
 
   void set_change_display_upon_host_resize(bool value) {
     change_display_upon_host_resize_ = value;
   }
 
+  // Creates software mirroring display related information. The display
+  // used to mirror the content is removed from the |display_info_list|.
+  void CreateSoftwareMirroringDisplay(DisplayInfoList* display_info_list);
+
   gfx::Display* FindDisplayForId(int64 id);
 
   // Add the mirror display's display info if the software based
   // mirroring is in use.
-  void AddMirrorDisplayInfoIfAny(std::vector<DisplayInfo>* display_info_list);
+  void AddMirrorDisplayInfoIfAny(DisplayInfoList* display_info_list);
 
   // Inserts and update the DisplayInfo according to the overscan
   // state. Note that The DisplayInfo stored in the |internal_display_info_|
@@ -390,8 +395,8 @@ private:
   bool change_display_upon_host_resize_;
 
   SecondDisplayMode second_display_mode_;
-  int64 mirrored_display_id_;
-  gfx::Display mirroring_display_;
+  int64 mirroring_display_id_;
+  gfx::Display software_mirroring_display_;
 
   // User preference for rotation lock of the internal display.
   bool registered_internal_display_rotation_lock_;
diff --git a/ash/display/display_manager_unittest.cc b/ash/display/display_manager_unittest.cc
index 4fc4057..9ed1039 100644
--- a/ash/display/display_manager_unittest.cc
+++ b/ash/display/display_manager_unittest.cc
@@ -487,7 +487,7 @@ TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
   const DisplayInfo external_display_info =
       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
-  const DisplayInfo mirrored_display_info =
+  const DisplayInfo mirroring_display_info =
       CreateDisplayInfo(mirror_id, gfx::Rect(0, 0, 500, 500));
 
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
@@ -502,7 +502,7 @@ TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
   EXPECT_EQ(default_bounds,
             display_manager()->GetDisplayAt(0).bounds().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
 
   if (!SupportsMultipleDisplays())
     return;
@@ -516,7 +516,7 @@ TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(external_id).bounds_in_native().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
   EXPECT_EQ(external_id, Shell::GetScreen()->GetPrimaryDisplay().id());
 
   EXPECT_EQ(internal_display_id, gfx::Display::InternalDisplayId());
@@ -535,7 +535,7 @@ TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(10).bounds_in_native().ToString());
   EXPECT_EQ(2U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
   EXPECT_EQ(ToDisplayName(internal_display_id),
             display_manager()->GetDisplayNameForId(internal_display_id));
 
@@ -548,7 +548,7 @@ TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(10).bounds_in_native().ToString());
   EXPECT_EQ(2U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
   EXPECT_EQ(ToDisplayName(internal_display_id),
             display_manager()->GetDisplayNameForId(internal_display_id));
 
@@ -559,21 +559,21 @@ TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
   EXPECT_EQ("0,0 500x500",
             GetDisplayForId(internal_display_id).bounds().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
 
   // External display was changed during suspend.
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
 
   // suspend...
   display_info_list.clear();
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
 
   // and resume with different external display.
   display_info_list.push_back(internal_display_info);
@@ -581,20 +581,20 @@ TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
 
   // mirrored...
   display_info_list.clear();
   display_info_list.push_back(internal_display_info);
-  display_info_list.push_back(mirrored_display_info);
+  display_info_list.push_back(mirroring_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ("0,0 500x500",
             GetDisplayForId(internal_display_id).bounds().ToString());
   EXPECT_EQ(2U, display_manager()->num_connected_displays());
-  EXPECT_EQ(11U, display_manager()->mirrored_display_id());
-  EXPECT_TRUE(display_manager()->IsMirrored());
+  EXPECT_EQ(11U, display_manager()->mirroring_display_id());
+  EXPECT_TRUE(display_manager()->IsInMirrorMode());
 
   // Test display name.
   EXPECT_EQ(ToDisplayName(internal_display_id),
@@ -612,7 +612,7 @@ TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
   EXPECT_EQ("0,0 500x500",
             GetDisplayForId(internal_display_id).bounds().ToString());
   EXPECT_EQ("500,0 100x100",
@@ -627,7 +627,7 @@ TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(external_id).bounds_in_native().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
 
   // Switched to another display
   display_info_list.clear();
@@ -638,7 +638,7 @@ TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
       "0,0 500x500",
       GetDisplayInfoForId(internal_display_id).bounds_in_native().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
-  EXPECT_FALSE(display_manager()->IsMirrored());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
 }
 
 // Make sure crash does not happen if add and remove happens at the same time.
@@ -1217,13 +1217,13 @@ TEST_F(DisplayManagerTest, SoftwareMirroring) {
   EXPECT_EQ("400x500", test_api.GetHost()->GetBounds().size().ToString());
   EXPECT_EQ("300x400",
             test_api.GetHost()->window()->bounds().size().ToString());
-  EXPECT_TRUE(display_manager->IsMirrored());
+  EXPECT_TRUE(display_manager->IsInMirrorMode());
 
   display_manager->SetMirrorMode(false);
   EXPECT_TRUE(display_observer.changed_and_reset());
   EXPECT_EQ(NULL, test_api.GetHost());
   EXPECT_EQ(2U, display_manager->GetNumDisplays());
-  EXPECT_FALSE(display_manager->IsMirrored());
+  EXPECT_FALSE(display_manager->IsInMirrorMode());
 
   // Make sure the mirror window has the pixel size of the
   // source display.
@@ -1268,14 +1268,14 @@ TEST_F(DisplayManagerTest, SingleDisplayToSoftwareMirroring) {
   display_manager->SetSecondDisplayMode(DisplayManager::MIRRORING);
   UpdateDisplay("600x400,600x400");
 
-  EXPECT_TRUE(display_manager->IsMirrored());
+  EXPECT_TRUE(display_manager->IsInMirrorMode());
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
   DisplayController* display_controller =
       ash::Shell::GetInstance()->display_controller();
   EXPECT_TRUE(display_controller->mirror_window_controller()->GetWindow());
 
   UpdateDisplay("600x400");
-  EXPECT_FALSE(display_manager->IsMirrored());
+  EXPECT_FALSE(display_manager->IsInMirrorMode());
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
   EXPECT_FALSE(display_controller->mirror_window_controller()->GetWindow());
 }
diff --git a/ash/display/mirror_window_controller.cc b/ash/display/mirror_window_controller.cc
index 1a08296..c7e5acf 100644
--- a/ash/display/mirror_window_controller.cc
+++ b/ash/display/mirror_window_controller.cc
@@ -125,7 +125,7 @@ void MirrorWindowController::UpdateWindow(const DisplayInfo& display_info) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   const DisplayInfo& source_display_info = display_manager->GetDisplayInfo(
       Shell::GetScreen()->GetPrimaryDisplay().id());
-  DCHECK(display_manager->IsMirrored());
+  DCHECK(display_manager->IsInMirrorMode());
   scoped_ptr<RootWindowTransformer> transformer(
       CreateRootWindowTransformerForMirroredDisplay(source_display_info,
                                                     display_info));
@@ -136,7 +136,7 @@ void MirrorWindowController::UpdateWindow() {
   if (ash_host_.get()) {
     DisplayManager* display_manager = Shell::GetInstance()->display_manager();
     const DisplayInfo& mirror_display_info = display_manager->GetDisplayInfo(
-        display_manager->mirrored_display_id());
+        display_manager->mirroring_display_id());
     UpdateWindow(mirror_display_info);
   }
 }
@@ -175,11 +175,11 @@ aura::Window* MirrorWindowController::GetWindow() {
 scoped_ptr<RootWindowTransformer>
 MirrorWindowController::CreateRootWindowTransformer() const {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  const DisplayInfo& mirror_display_info = display_manager->GetDisplayInfo(
-      display_manager->mirrored_display_id());
+  const DisplayInfo& mirror_display_info =
+      display_manager->GetDisplayInfo(display_manager->mirroring_display_id());
   const DisplayInfo& source_display_info = display_manager->GetDisplayInfo(
       Shell::GetScreen()->GetPrimaryDisplay().id());
-  DCHECK(display_manager->IsMirrored());
+  DCHECK(display_manager->IsInMirrorMode());
   return scoped_ptr<RootWindowTransformer>(
       CreateRootWindowTransformerForMirroredDisplay(source_display_info,
                                                     mirror_display_info));
diff --git a/ash/display/mirror_window_controller_unittest.cc b/ash/display/mirror_window_controller_unittest.cc
index 15bdefa..c1fe0cb 100644
--- a/ash/display/mirror_window_controller_unittest.cc
+++ b/ash/display/mirror_window_controller_unittest.cc
@@ -283,8 +283,8 @@ TEST_F(MirrorWindowControllerTest, MAYBE_DockMode) {
   EXPECT_EQ(internal_id, internal_display_id);
 
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
-  EXPECT_TRUE(display_manager->IsMirrored());
-  EXPECT_EQ(external_id, display_manager->mirrored_display_id());
+  EXPECT_TRUE(display_manager->IsInMirrorMode());
+  EXPECT_EQ(external_id, display_manager->mirroring_display_id());
 
   // dock mode.
   display_info_list.clear();
@@ -292,7 +292,7 @@ TEST_F(MirrorWindowControllerTest, MAYBE_DockMode) {
   display_manager->SetSecondDisplayMode(DisplayManager::MIRRORING);
   display_manager->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
-  EXPECT_FALSE(display_manager->IsMirrored());
+  EXPECT_FALSE(display_manager->IsInMirrorMode());
 
   // back to software mirroring.
   display_info_list.clear();
@@ -301,13 +301,13 @@ TEST_F(MirrorWindowControllerTest, MAYBE_DockMode) {
   display_manager->SetSecondDisplayMode(DisplayManager::MIRRORING);
   display_manager->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
-  EXPECT_TRUE(display_manager->IsMirrored());
-  EXPECT_EQ(external_id, display_manager->mirrored_display_id());
+  EXPECT_TRUE(display_manager->IsInMirrorMode());
+  EXPECT_EQ(external_id, display_manager->mirroring_display_id());
 }
 
 TEST_F(MirrorOnBootTest, MAYBE_MirrorOnBoot) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  EXPECT_TRUE(display_manager->IsMirrored());
+  EXPECT_TRUE(display_manager->IsInMirrorMode());
   RunAllPendingInMessageLoop();
   test::MirrorWindowTestApi test_api;
   EXPECT_TRUE(test_api.GetHost());
diff --git a/ash/display/screen_ash.cc b/ash/display/screen_ash.cc
index 271b8e6..10ee7c7 100644
--- a/ash/display/screen_ash.cc
+++ b/ash/display/screen_ash.cc
@@ -165,8 +165,8 @@ gfx::Display ScreenAsh::GetDisplayNearestWindow(gfx::NativeView window) const {
   DisplayManager* display_manager = GetDisplayManager();
   // RootWindow needs Display to determine its device scale factor
   // for non desktop display.
-  if (display_manager->mirroring_display().id() == id)
-    return display_manager->mirroring_display();
+  if (display_manager->software_mirroring_display().id() == id)
+    return display_manager->software_mirroring_display();
   return display_manager->GetDisplayForId(id);
 }
 
diff --git a/ash/system/chromeos/tray_display.cc b/ash/system/chromeos/tray_display.cc
index 10f9ede..9a61897 100644
--- a/ash/system/chromeos/tray_display.cc
+++ b/ash/system/chromeos/tray_display.cc
@@ -52,9 +52,9 @@ base::string16 GetDisplaySize(int64 display_id) {
 
   // We don't show display size for mirrored display. Fallback
   // to empty string if this happens on release build.
-  bool mirrored_display = display_manager->mirrored_display_id() == display_id;
-  DCHECK(!mirrored_display);
-  if (mirrored_display)
+  bool mirroring = display_manager->mirroring_display_id() == display_id;
+  DCHECK(!mirroring);
+  if (mirroring)
     return base::string16();
 
   DCHECK(display->is_valid());
@@ -66,7 +66,7 @@ base::string16 GetDisplaySize(int64 display_id) {
 base::string16 GetDisplayInfoLine(int64 display_id) {
   const DisplayInfo& display_info =
       GetDisplayManager()->GetDisplayInfo(display_id);
-  if (GetDisplayManager()->mirrored_display_id() == display_id)
+  if (GetDisplayManager()->mirroring_display_id() == display_id)
     return GetDisplayName(display_id);
 
   base::string16 size_text = GetDisplaySize(display_id);
@@ -186,7 +186,7 @@ class DisplayView : public ActionableView {
   // mirroring.
   static base::string16 GetExternalDisplayName() {
     DisplayManager* display_manager = GetDisplayManager();
-    DCHECK(!display_manager->IsMirrored());
+    DCHECK(!display_manager->IsInMirrorMode());
 
     int64 external_id = gfx::Display::kInvalidDisplayID;
     for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
@@ -236,11 +236,11 @@ class DisplayView : public ActionableView {
           IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED_NO_INTERNAL);
     }
 
-    if (display_manager->IsMirrored()) {
+    if (display_manager->IsInMirrorMode()) {
       if (GetDisplayManager()->HasInternalDisplay()) {
         return l10n_util::GetStringFUTF16(
             IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING,
-            GetDisplayName(display_manager->mirrored_display_id()));
+            GetDisplayName(display_manager->mirroring_display_id()));
       }
       return l10n_util::GetStringUTF16(
           IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING_NO_INTERNAL);
diff --git a/ash/system/chromeos/tray_display_unittest.cc b/ash/system/chromeos/tray_display_unittest.cc
index d2a1641..e289fa2 100644
--- a/ash/system/chromeos/tray_display_unittest.cc
+++ b/ash/system/chromeos/tray_display_unittest.cc
@@ -65,10 +65,10 @@ base::string16 GetSecondDisplayName() {
           ScreenUtil::GetSecondaryDisplay().id()));
 }
 
-base::string16 GetMirroredDisplayName() {
+base::string16 GetMirroringDisplayName() {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   return base::UTF8ToUTF16(display_manager->GetDisplayNameForId(
-      display_manager->mirrored_display_id()));
+      display_manager->mirroring_display_id()));
 }
 
 class TrayDisplayTest : public ash::test::AshTestBase {
@@ -228,8 +228,8 @@ TEST_F(TrayDisplayTest, InternalDisplay) {
   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
   EXPECT_TRUE(IsDisplayVisibleInTray());
 
-  expected = l10n_util::GetStringFUTF16(
-      IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING, GetMirroredDisplayName());
+  expected = l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING,
+                                        GetMirroringDisplayName());
   EXPECT_EQ(expected, GetTrayDisplayText());
   EXPECT_EQ(GetMirroredTooltipText(expected, GetFirstDisplayName(), "400x400"),
             GetTrayDisplayTooltipText());
@@ -270,8 +270,8 @@ TEST_F(TrayDisplayTest, InternalDisplayResized) {
   UpdateDisplay("400x400@1.5,200x200");
   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
   EXPECT_TRUE(IsDisplayVisibleInTray());
-  expected = l10n_util::GetStringFUTF16(
-      IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING, GetMirroredDisplayName());
+  expected = l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING,
+                                        GetMirroringDisplayName());
   EXPECT_EQ(expected, GetTrayDisplayText());
   EXPECT_EQ(GetMirroredTooltipText(expected, GetFirstDisplayName(), "600x600"),
             GetTrayDisplayTooltipText());
@@ -325,8 +325,8 @@ TEST_F(TrayDisplayTest, ExternalDisplayResized) {
   UpdateDisplay("400x400,200x200@1.5");
   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
   EXPECT_TRUE(IsDisplayVisibleInTray());
-  expected = l10n_util::GetStringFUTF16(
-      IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING, GetMirroredDisplayName());
+  expected = l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING,
+                                        GetMirroringDisplayName());
   EXPECT_EQ(expected, GetTrayDisplayText());
   EXPECT_EQ(GetMirroredTooltipText(expected, GetFirstDisplayName(), "400x400"),
             GetTrayDisplayTooltipText());
@@ -480,10 +480,9 @@ TEST_F(TrayDisplayTest, DisplayNotifications) {
   CloseNotification();
   display_manager->SetSoftwareMirroring(true);
   UpdateDisplay("400x400,200x200");
-  EXPECT_EQ(
-      l10n_util::GetStringFUTF16(
-          IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING, GetMirroredDisplayName()),
-      GetDisplayNotificationText());
+  EXPECT_EQ(l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING,
+                                       GetMirroringDisplayName()),
+            GetDisplayNotificationText());
   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 
   // Back to extended.
diff --git a/ash/touch/touch_transformer_controller.cc b/ash/touch/touch_transformer_controller.cc
index 8adb644..d2582c0 100644
--- a/ash/touch/touch_transformer_controller.cc
+++ b/ash/touch/touch_transformer_controller.cc
@@ -174,7 +174,7 @@ void TouchTransformerController::UpdateTouchTransformer() const {
   gfx::Size fb_size =
       Shell::GetInstance()->display_configurator()->framebuffer_size();
 
-  if (display_manager->IsMirrored()) {
+  if (display_manager->IsInMirrorMode()) {
     if (GetDisplayManager()->software_mirroring_enabled()) {
       // In extended but software mirroring mode, there is a WindowTreeHost for
       // each display, but all touches are forwarded to the primary root
diff --git a/chrome/browser/extensions/display_info_provider_chromeos.cc b/chrome/browser/extensions/display_info_provider_chromeos.cc
index 60c6e6c..fda4b63 100644
--- a/chrome/browser/extensions/display_info_provider_chromeos.cc
+++ b/chrome/browser/extensions/display_info_provider_chromeos.cc
@@ -318,7 +318,7 @@ bool DisplayInfoProviderChromeOS::SetInfo(const std::string& display_id_str,
 
   // Process 'mirroringSourceId' parameter.
   if (info.mirroring_source_id &&
-      info.mirroring_source_id->empty() == display_manager->IsMirrored()) {
+      info.mirroring_source_id->empty() == display_manager->IsInMirrorMode()) {
     display_controller->ToggleMirrorMode();
   }
 
@@ -361,9 +361,9 @@ void DisplayInfoProviderChromeOS::UpdateDisplayUnitInfoForPlatform(
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   unit->name = display_manager->GetDisplayNameForId(display.id());
-  if (display_manager->IsMirrored()) {
+  if (display_manager->IsInMirrorMode()) {
     unit->mirroring_source_id =
-        base::Int64ToString(display_manager->mirrored_display_id());
+        base::Int64ToString(display_manager->mirroring_display_id());
   }
 
   // TODO(hshi): determine the DPI of the screen.
diff --git a/chrome/browser/extensions/display_info_provider_chromeos_unittest.cc b/chrome/browser/extensions/display_info_provider_chromeos_unittest.cc
index 493e54c..28d3eab 100644
--- a/chrome/browser/extensions/display_info_provider_chromeos_unittest.cc
+++ b/chrome/browser/extensions/display_info_provider_chromeos_unittest.cc
@@ -253,12 +253,12 @@ TEST_F(DisplayInfoProviderChromeosTest, GetMirroring) {
   ASSERT_TRUE(DisplayExists(display_id_secondary)) << display_id_secondary
                                                    << " not found";
 
-  ASSERT_FALSE(GetDisplayManager()->IsMirrored());
+  ASSERT_FALSE(GetDisplayManager()->IsInMirrorMode());
   EXPECT_TRUE(result[0]->mirroring_source_id.empty());
   EXPECT_TRUE(result[1]->mirroring_source_id.empty());
 
   GetDisplayManager()->SetMirrorMode(true);
-  ASSERT_TRUE(GetDisplayManager()->IsMirrored());
+  ASSERT_TRUE(GetDisplayManager()->IsInMirrorMode());
 
   result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
 
@@ -268,7 +268,7 @@ TEST_F(DisplayInfoProviderChromeosTest, GetMirroring) {
             result[0]->mirroring_source_id);
 
   GetDisplayManager()->SetMirrorMode(false);
-  ASSERT_FALSE(GetDisplayManager()->IsMirrored());
+  ASSERT_FALSE(GetDisplayManager()->IsInMirrorMode());
 
   result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
 
diff --git a/chrome/browser/ui/webui/options/chromeos/display_options_handler.cc b/chrome/browser/ui/webui/options/chromeos/display_options_handler.cc
index d354743..a345d8a 100644
--- a/chrome/browser/ui/webui/options/chromeos/display_options_handler.cc
+++ b/chrome/browser/ui/webui/options/chromeos/display_options_handler.cc
@@ -260,7 +260,7 @@ void DisplayOptionsHandler::SendAllDisplayInfo() {
 void DisplayOptionsHandler::SendDisplayInfo(
     const std::vector<gfx::Display>& displays) {
   DisplayManager* display_manager = GetDisplayManager();
-  base::FundamentalValue mirroring(display_manager->IsMirrored());
+  base::FundamentalValue mirroring(display_manager->IsInMirrorMode());
 
   int64 primary_id = ash::Shell::GetScreen()->GetPrimaryDisplay().id();
   base::ListValue js_displays;