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 {
+  std::vector<std::string> result;
+  for (std::map<int64, std::string>::const_iterator iter =
+           display_names_.begin(); iter != display_names_.end(); ++iter) {
+    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 76 matching lines @@
 }
 
 std::string MultiDisplayManager::GetDisplayNameFor(
     const gfx::Display& display) {
   if (HasInternalDisplay() && IsInternalDisplayId(display.id())) {
     ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
     return UTF16ToUTF8(
         bundle.GetLocalizedString(IDS_ASH_INTERNAL_DISPLAY_NAME));
   }
 
-#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
+  std::map<int64, std::string>::const_iterator iter =
+      display_names_.find(display.id());
+  if (iter != display_names_.end())
+    return iter->second;
+
   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;
+  std::string result;

[oshima, 2012/11/02 06:33:56]

this isn't used?

[Jun Mukai, 2012/11/02 16:09:07]

Done.

+  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 (!HasInternalDisplay() || !IsInternalDisplayId(id))

[oshima, 2012/11/02 06:33:56]

is it simpler to set inernal display's name here rather than checking here and
GetDisplayNameFor?

[Jun Mukai, 2012/11/02 16:09:07]

Done.

+        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