Automatically set the overscan insets if the output has the flag and no preference is set.

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 <string>
 #include <vector>
 
 #include "ash/display/display_controller.h"
@@ skipping 54 matching lines @@
 #if defined(OS_CHROMEOS)
 int64 GetDisplayIdForOutput(XID output) {
   uint16 manufacturer_id = 0;
   uint32 serial_number = 0;
   ui::GetOutputDeviceData(
       output, &manufacturer_id, &serial_number, NULL);
   return gfx::Display::GetID(manufacturer_id, serial_number);
 }
 #endif
 
+gfx::Insets GetDefaultDisplayOverscan(const gfx::Display& display) {
+  // Currently we assume 5% overscan and hope for the best if TV claims it
+  // overscan, but doesn't expose how much.
+  int width = display.bounds().width() / 40;
+  int height = display.bounds().height() / 40;
+  return gfx::Insets(height, width, height, width);
+}
+
 }  // namespace
 
 using aura::RootWindow;
 using aura::Window;
 using std::string;
 using std::vector;
 
 DEFINE_WINDOW_PROPERTY_KEY(int64, kDisplayIdKey,
                            gfx::Display::kInvalidDisplayID);
 
@@ skipping 54 matching lines @@
     const gfx::Display& display = *iter;
     if (display.bounds().Contains(point_in_screen))
       return display;
   }
   return GetInvalidDisplay();
 }
 
 void DisplayManager::SetOverscanInsets(int64 display_id,
                                        const gfx::Insets& insets_in_dip) {
   display_info_[display_id].overscan_insets_in_dip = insets_in_dip;
+  display_info_[display_id].has_custom_overscan_insets = true;
 
   // Copies the |displays_| because UpdateDisplays() compares the passed
   // displays and its internal |displays_|.
   DisplayList displays = displays_;
   UpdateDisplays(displays);
 }
 
 gfx::Insets DisplayManager::GetOverscanInsets(int64 display_id) const {
   std::map<int64, DisplayInfo>::const_iterator it =
       display_info_.find(display_id);
@@ skipping 35 matching lines @@
       if (!internal_display_.get()) {
         internal_display_.reset(new gfx::Display(internal_display_id_,
                                                  gfx::Rect(800, 600)));
       }
       new_displays.push_back(*internal_display_.get());
     }
   } else {
     new_displays = updated_displays;
   }
 
+  RefreshDisplayInfo();
+
   for (DisplayList::const_iterator iter = new_displays.begin();
        iter != new_displays.end(); ++iter) {
     std::map<int64, DisplayInfo>::iterator info =
         display_info_.find(iter->id());
     if (info != display_info_.end()) {
       info->second.original_bounds_in_pixel = iter->bounds_in_pixel();
+      if (info->second.has_overscan && !info->second.has_custom_overscan_insets)
+        info->second.overscan_insets_in_dip = GetDefaultDisplayOverscan(*iter);
     } else {
       display_info_[iter->id()].original_bounds_in_pixel =
           iter->bounds_in_pixel();
     }
   }
 
   UpdateDisplays(new_displays);
-  RefreshDisplayNames();
 }
 
 void DisplayManager::UpdateDisplays(
     const std::vector<gfx::Display>& updated_displays) {
   DisplayList new_displays = updated_displays;
 
   for (DisplayList::iterator iter = new_displays.begin();
        iter != new_displays.end(); ++iter) {
     std::map<int64, DisplayInfo>::const_iterator info =
         display_info_.find(iter->id());
@@ skipping 189 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();
+  RefreshDisplayInfo();
 
 #if defined(OS_WIN)
   if (base::win::GetVersion() >= base::win::VERSION_WIN8)
     aura::SetUseFullscreenHostWindow(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);
@@ skipping 105 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 DisplayManager::RefreshDisplayNames() {
+DisplayManager::DisplayInfo::DisplayInfo()
+  : has_overscan(false),
+    has_custom_overscan_insets(false) {
+}
+
+void DisplayManager::RefreshDisplayInfo() {
 #if defined(OS_CHROMEOS)
   if (!base::chromeos::IsRunningOnChromeOS())
     return;
 #endif
 
 #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;
     ui::GetOutputDeviceData(
         outputs[i], &manufacturer_id, &serial_number, &name);
     int64 id = gfx::Display::GetID(manufacturer_id, serial_number);
     if (IsInternalDisplayId(id)) {
       display_info_[id].name =
           l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME);
     } else if (!name.empty()) {
       display_info_[id].name = name;
     }
+
+    ui::GetOutputOverscanFlag(outputs[i], &display_info_[id].has_overscan);
   }
 #endif
 }
 
 void DisplayManager::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());
   }
 }
 
+void DisplayManager::SetHasOverscanFlagForTest(int64 id, bool has_overscan) {
+  display_info_[id].has_overscan = has_overscan;
+}
+
 }  // namespace internal
 }  // namespace ash