Caches the display names in MultiDisplayManager.

ash/display/multi_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/multi_display_manager.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/display/display_controller.h"
@@ skipping 111 matching lines @@
 bool MultiDisplayManager::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const RootWindow* root = window->GetRootWindow();
   gfx::Display& display = FindDisplayForRootWindow(root);
   gfx::Rect old_work_area = display.work_area();
   display.UpdateWorkAreaFromInsets(insets);
   return old_work_area != display.work_area();
 }
 
+std::vector<std::string> MultiDisplayManager::GetExternalDisplayNames() const {

[Daniel Erat, 2012/11/02 16:46:17]

this method seems a bit tricky; it returns an ordered list of names but skips
over the internal display.  is there any way that you could change the caller so
it just passes the external display that it cares about to GetDisplayNameFor()
instead?

[Jun Mukai, 2012/11/02 18:04:35]

Thanks for the comment.  Removed this method and changed the code structure a
bit.

+  std::vector<std::string> result;
+  for (std::map<int64, std::string>::const_iterator iter =
+           display_names_.begin(); iter != display_names_.end(); ++iter) {
+    if (!IsInternalDisplayId(iter->first))
+      result.push_back(iter->second);
+  }
+
+  return result;
+}
+
 const gfx::Display& MultiDisplayManager::GetDisplayForId(int64 id) const {
   return const_cast<MultiDisplayManager*>(this)->FindDisplayForId(id);
 }
 
 const gfx::Display& MultiDisplayManager::FindDisplayContainingPoint(
     const gfx::Point& point_in_screen) const {
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     const gfx::Display& display = *iter;
     if (display.bounds().Contains(point_in_screen))
@@ skipping 134 matching lines @@
 
   // 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;
   }
 
   displays_ = new_displays;
+  RefreshDisplayNames();
+
   // Temporarily add displays to be removed because display object
   // being removed are accessed during shutting down the root.
   displays_.insert(displays_.end(), removed_displays.begin(),
                    removed_displays.end());
   for (std::vector<size_t>::iterator iter = changed_display_indices.begin();
        iter != changed_display_indices.end(); ++iter) {
     NotifyBoundsChanged(displays_[*iter]);
   }
   for (std::vector<size_t>::iterator iter = added_display_indices.begin();
        iter != added_display_indices.end(); ++iter) {
@@ skipping 68 matching lines @@
     int area = intersect.width() * intersect.height();
     if (area > max) {
       max = area;
       matching = &(*iter);
     }
   }
   // Fallback to the primary display if there is no matching display.
   return matching ? *matching : DisplayController::GetPrimaryDisplay();
 }
 
 std::string MultiDisplayManager::GetDisplayNameFor(

[Daniel Erat, 2012/11/02 16:46:17]

nit (doesn't need to be addressed here): putting "For" on the end of this method
name is pretty uncommon in the chrome source that i've seen.  i'd rename this to
either GetDisplayName() or GetNameForDisplay()

[Jun Mukai, 2012/11/02 18:04:35]

Can we do that in another CL?  This is used in many places.

[Daniel Erat, 2012/11/02 18:59:04]

Sure, sounds fine.

     const gfx::Display& display) {
-  if (HasInternalDisplay() && IsInternalDisplayId(display.id())) {
-    ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
-    return UTF16ToUTF8(
-        bundle.GetLocalizedString(IDS_ASH_INTERNAL_DISPLAY_NAME));
-  }
+  std::map<int64, std::string>::const_iterator iter =
+      display_names_.find(display.id());
+  if (iter != display_names_.end())
+    return iter->second;
 
-#if defined(USE_X11)
-  std::vector<XID> outputs;
-  if (display.id() != gfx::Display::kInvalidDisplayID &&
-      ui::GetOutputDeviceHandles(&outputs)) {
-    for (size_t i = 0; i < outputs.size(); ++i) {
-      uint16 manufacturer_id = 0;
-      uint32 serial_number = 0;
-      std::string name;
-      if (ui::GetOutputDeviceData(
-              outputs[i], &manufacturer_id, &serial_number, &name) &&
-          display.id() ==
-          gfx::Display::GetID(manufacturer_id, serial_number)) {
-        return name;
-      }
-    }
-  }
-#endif
   return base::StringPrintf("Display %d", static_cast<int>(display.id()));
 }
 
 void MultiDisplayManager::OnRootWindowResized(const aura::RootWindow* root,
                                               const gfx::Size& old_size) {
   if (!use_fullscreen_host_window()) {
     gfx::Display& display = FindDisplayForRootWindow(root);
     if (display.size() != root->GetHostSize()) {
       display.SetSize(root->GetHostSize());
       NotifyBoundsChanged(display);
@@ skipping 10 matching lines @@
     for (size_t i = 0; i < output_names.size(); ++i) {
       if (chromeos::OutputConfigurator::IsInternalOutputName(
               output_names[i])) {
         internal_display_id_ = GetDisplayIdForOutput(outputs[i]);
         break;
       }
     }
   }
 #endif
 
+  RefreshDisplayNames();
+
 #if defined(OS_WIN)
   if (base::win::GetVersion() >= base::win::VERSION_WIN8)
     set_use_fullscreen_host_window(true);
 #endif
   // TODO(oshima): Move this logic to DisplayChangeObserver.
   const string size_str = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kAuraHostWindowSize);
   vector<string> parts;
   base::SplitString(size_str, ',', &parts);
   for (vector<string>::const_iterator iter = parts.begin();
@@ skipping 97 matching lines @@
   }
 
   aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
   aura::client::ScreenPositionClient* client =
       aura::client::GetScreenPositionClient(root_window);
   client->ConvertPointFromScreen(root_window, &target_location);
 
   root_window->MoveCursorTo(target_location);
 }
 
+void MultiDisplayManager::RefreshDisplayNames() {
+  display_names_.clear();
+
+  if (!base::chromeos::IsRunningOnChromeOS())
+    return;
+
+#if defined(USE_X11)
+  std::vector<XID> outputs;
+  if (!ui::GetOutputDeviceHandles(&outputs))
+    return;
+
+  for (size_t i = 0; i < outputs.size(); ++i) {
+    uint16 manufacturer_id = 0;
+    uint32 serial_number = 0;
+    std::string name;
+    if (ui::GetOutputDeviceData(
+            outputs[i], &manufacturer_id, &serial_number, &name)) {
+      int64 id = gfx::Display::GetID(manufacturer_id, serial_number);
+      if (IsInternalDisplayId(id)) {
+        ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
+        display_names_[id] = UTF16ToUTF8(
+            bundle.GetLocalizedString(IDS_ASH_INTERNAL_DISPLAY_NAME));
+      } else {
+        display_names_[id] = name;
+      }
+    }
+  }
+#endif
+}
+
 void MultiDisplayManager::SetDisplayIdsForTest(DisplayList* to_update) const {
   DisplayList::iterator iter_to_update = to_update->begin();
   DisplayList::const_iterator iter = displays_.begin();
   for (; iter != displays_.end() && iter_to_update != to_update->end();
        ++iter, ++iter_to_update) {
     (*iter_to_update).set_id((*iter).id());
   }
 }
 
 }  // namespace internal
 }  // namespace ash