Move kInvalidDisplayID to display_constants.h.

ui/display/manager/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 "ui/display/manager/display_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
@@ skipping 460 matching lines @@
 scoped_refptr<display::ManagedDisplayMode>
 DisplayManager::GetSelectedModeForDisplayId(int64_t id) const {
   std::map<int64_t, scoped_refptr<display::ManagedDisplayMode>>::const_iterator
       iter = display_modes_.find(id);
   if (iter == display_modes_.end())
     return scoped_refptr<display::ManagedDisplayMode>();
   return iter->second;
 }
 
 bool DisplayManager::IsDisplayUIScalingEnabled() const {
-  return GetDisplayIdForUIScaling() != display::Display::kInvalidDisplayID;
+  return GetDisplayIdForUIScaling() != kInvalidDisplayId;
 }
 
 gfx::Insets DisplayManager::GetOverscanInsets(int64_t display_id) const {
   std::map<int64_t, display::ManagedDisplayInfo>::const_iterator it =
       display_info_.find(display_id);
   return (it != display_info_.end()) ? it->second.overscan_insets_in_dip()
                                      : gfx::Insets();
 }
 
 void DisplayManager::SetColorCalibrationProfile(
@@ skipping 52 matching lines @@
   if (updated_displays.size() == 1) {
     VLOG(1) << "OnNativeDisplaysChanged(1):" << updated_displays[0].ToString();
   } else {
     VLOG(1) << "OnNativeDisplaysChanged(" << updated_displays.size()
             << ") [0]=" << updated_displays[0].ToString()
             << ", [1]=" << updated_displays[1].ToString();
   }
 
   bool internal_display_connected = false;
   num_connected_displays_ = updated_displays.size();
-  mirroring_display_id_ = display::Display::kInvalidDisplayID;
+  mirroring_display_id_ = kInvalidDisplayId;
   software_mirroring_display_list_.clear();
   DisplayInfoList new_display_info_list;
   for (DisplayInfoList::const_iterator iter = updated_displays.begin();
        iter != updated_displays.end(); ++iter) {
     if (!internal_display_connected)
       internal_display_connected =
           display::Display::IsInternalDisplayId(iter->id());
     // Mirrored monitors have the same origins.
     gfx::Point origin = iter->bounds_in_native().origin();
     if (origins.find(origin) != origins.end()) {
@@ skipping 301 matching lines @@
 }
 
 bool DisplayManager::IsActiveDisplayId(int64_t display_id) const {
   return std::find_if(active_display_list_.begin(), active_display_list_.end(),
                       [display_id](const display::Display& display) {
                         return display.id() == display_id;
                       }) != active_display_list_.end();
 }
 
 bool DisplayManager::IsInMirrorMode() const {
-  return mirroring_display_id_ != display::Display::kInvalidDisplayID;
+  return mirroring_display_id_ != kInvalidDisplayId;
 }
 
 void DisplayManager::SetUnifiedDesktopEnabled(bool enable) {
   unified_desktop_enabled_ = enable;
   // There is no need to update the displays in mirror mode. Doing
   // this in hardware mirroring mode can cause crash because display
   // info in hardware mirroring comes from DisplayConfigurator.
   if (!IsInMirrorMode())
     ReconfigureDisplays();
 }
 
 bool DisplayManager::IsInUnifiedMode() const {
   return multi_display_mode_ == UNIFIED &&
          !software_mirroring_display_list_.empty();
 }
 
 const display::ManagedDisplayInfo& DisplayManager::GetDisplayInfo(
     int64_t display_id) const {
-  DCHECK_NE(display::Display::kInvalidDisplayID, display_id);
+  DCHECK_NE(kInvalidDisplayId, display_id);
 
   std::map<int64_t, display::ManagedDisplayInfo>::const_iterator iter =
       display_info_.find(display_id);
   CHECK(iter != display_info_.end()) << display_id;
   return iter->second;
 }
 
 const display::Display DisplayManager::GetMirroringDisplayById(
     int64_t display_id) const {
   auto iter = std::find_if(software_mirroring_display_list_.begin(),
                            software_mirroring_display_list_.end(),
                            [display_id](const display::Display& display) {
                              return display.id() == display_id;
                            });
   return iter == software_mirroring_display_list_.end() ? display::Display()
                                                         : *iter;
 }
 
 std::string DisplayManager::GetDisplayNameForId(int64_t id) {
-  if (id == display::Display::kInvalidDisplayID)
+  if (id == kInvalidDisplayId)
     return delegate_->GetInternalDisplayNameString();
 
   std::map<int64_t, display::ManagedDisplayInfo>::const_iterator iter =
       display_info_.find(id);
   if (iter != display_info_.end() && !iter->second.name().empty())
     return iter->second.name();
 
   return base::StringPrintf("Display %d", static_cast<int>(id));
 }
 
 int64_t DisplayManager::GetDisplayIdForUIScaling() const {
   // UI Scaling is effective on internal display.
   return display::Display::HasInternalDisplay()
              ? display::Display::InternalDisplayId()
-             : display::Display::kInvalidDisplayID;
+             : kInvalidDisplayId;
 }
 
 void DisplayManager::SetMirrorMode(bool mirror) {
   // TODO(oshima): Enable mirror mode for 2> displays. crbug.com/589319.
   if (num_connected_displays() != 2)
     return;
 
 #if defined(OS_CHROMEOS)
   if (base::SysInfo::IsRunningOnChromeOS()) {
     ui::MultipleDisplayState new_state =
@@ skipping 20 matching lines @@
   if (num_connected_displays() == 1) {
     const int kVerticalOffsetPx = 100;
     // Layout the 2nd display below the primary as with the real device.
     gfx::Rect host_bounds = first_display.bounds_in_native();
     new_display_info_list.push_back(
         display::ManagedDisplayInfo::CreateFromSpec(base::StringPrintf(
             "%d+%d-600x%d", host_bounds.x(),
             host_bounds.bottom() + kVerticalOffsetPx, host_bounds.height())));
   }
   num_connected_displays_ = new_display_info_list.size();
-  mirroring_display_id_ = display::Display::kInvalidDisplayID;
+  mirroring_display_id_ = kInvalidDisplayId;
   software_mirroring_display_list_.clear();
   UpdateDisplaysWith(new_display_info_list);
 }
 
 void DisplayManager::ToggleDisplayScaleFactor() {
   DCHECK(!active_display_list_.empty());
   DisplayInfoList new_display_info_list;
   for (display::Displays::const_iterator iter = active_display_list_.begin();
        iter != active_display_list_.end(); ++iter) {
     display::ManagedDisplayInfo display_info = GetDisplayInfo(iter->id());
@@ skipping 20 matching lines @@
     MultiDisplayMode mode) {
   DCHECK_NE(MIRRORING, mode);
   display::DisplayIdList list = GetCurrentDisplayIdList();
   layout_store_->UpdateMultiDisplayState(list, IsInMirrorMode(),
                                          mode == UNIFIED);
   ReconfigureDisplays();
 }
 
 void DisplayManager::SetMultiDisplayMode(MultiDisplayMode mode) {
   multi_display_mode_ = mode;
-  mirroring_display_id_ = display::Display::kInvalidDisplayID;
+  mirroring_display_id_ = kInvalidDisplayId;
   software_mirroring_display_list_.clear();
 }
 
 void DisplayManager::ReconfigureDisplays() {
   DisplayInfoList display_info_list;
   for (const display::Display& display : active_display_list_) {
     if (display.id() == kUnifiedDisplayId)
       continue;
     display_info_list.push_back(GetDisplayInfo(display.id()));
   }
   for (const display::Display& display : software_mirroring_display_list_)
     display_info_list.push_back(GetDisplayInfo(display.id()));
-  mirroring_display_id_ = display::Display::kInvalidDisplayID;
+  mirroring_display_id_ = kInvalidDisplayId;
   software_mirroring_display_list_.clear();
   UpdateDisplaysWith(display_info_list);
 }
 
 bool DisplayManager::UpdateDisplayBounds(int64_t display_id,
                                          const gfx::Rect& new_bounds) {
   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() && mirroring_display_id_ == display_id)
@@ skipping 309 matching lines @@
     std::vector<size_t>* updated_indices) {
   if (display_list->size() == 1u)
     return;
 
   const display::DisplayLayout& layout =
       layout_store_->GetRegisteredDisplayLayout(
           display::CreateDisplayIdList(*display_list));
 
   // Ignore if a user has a old format (should be extremely rare)
   // and this will be replaced with DCHECK.
-  if (layout.primary_id == display::Display::kInvalidDisplayID)
+  if (layout.primary_id == kInvalidDisplayId)
     return;
 
   // display_list does not have translation set, so ApplyDisplayLayout cannot
   // provide accurate change information. We'll find the changes after the call.
   ApplyDisplayLayout(layout, display_list, nullptr);
   size_t num_displays = display_list->size();
   for (size_t index = 0; index < num_displays; ++index) {
     const display::Display& display = (*display_list)[index];
     int64_t id = display.id();
     const display::Display* active_display = FindDisplayForId(id);
@@ skipping 49 matching lines @@
 
 const display::Display& DisplayManager::GetSecondaryDisplay() const {
   CHECK_LE(2U, GetNumDisplays());
   return GetDisplayAt(0).id() ==
                  display::Screen::GetScreen()->GetPrimaryDisplay().id()
              ? GetDisplayAt(1)
              : GetDisplayAt(0);
 }
 
 }  // namespace display