Update display::Display::kInvalidDisplayID constant.

chrome/browser/extensions/display_info_provider_chromeos.cc

 // Copyright 2014 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 "chrome/browser/extensions/display_info_provider_chromeos.h"
 
 #include <stdint.h>
 
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/resolution_notification_controller.h"
 #include "ash/shell.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/display/display_preferences.h"
 #include "chrome/browser/chromeos/display/overscan_calibrator.h"
 #include "extensions/common/api/system_display.h"
 #include "ui/display/display.h"
 #include "ui/display/manager/display_layout.h"
 #include "ui/display/manager/display_layout_builder.h"
 #include "ui/display/manager/display_manager.h"
+#include "ui/display/types/display_constants.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace extensions {
 
 namespace system_display = api::system_display;
 
 namespace {
 
 // Maximum allowed bounds origin absolute value.
@@ skipping 202 matching lines @@
                               int64_t primary_display_id,
                               std::string* error) {
   int64_t id = display.id();
   bool is_primary =
       id == primary_display_id || (info.is_primary && *info.is_primary);
 
   // If mirroring source id is set, a display with the given id should exist,
   // and if should not be the same as the target display's id.
   if (info.mirroring_source_id && !info.mirroring_source_id->empty()) {
     int64_t mirroring_id = GetDisplay(*info.mirroring_source_id).id();
-    if (mirroring_id == display::Display::kInvalidDisplayID) {
+    if (mirroring_id == display::kInvalidDisplayId) {
       *error = "Display " + *info.mirroring_source_id + " not found.";
       return false;
     }
 
     if (*info.mirroring_source_id == base::Int64ToString(id)) {
       *error = "Not allowed to mirror self.";
       return false;
     }
   }
 
@@ skipping 131 matching lines @@
     const std::string& display_id_str,
     const system_display::DisplayProperties& info,
     std::string* error) {
   display::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   ash::DisplayConfigurationController* display_configuration_controller =
       ash::Shell::GetInstance()->display_configuration_controller();
 
   const display::Display target = GetDisplay(display_id_str);
 
-  if (target.id() == display::Display::kInvalidDisplayID) {
+  if (target.id() == display::kInvalidDisplayId) {
     *error = "Display not found.";
     return false;
   }
 
   int64_t display_id = target.id();
   const display::Display& primary =
       display::Screen::GetScreen()->GetPrimaryDisplay();
 
   if (!ValidateParamsForDisplay(info, target, display_manager, primary.id(),
                                 error)) {
@@ skipping 49 matching lines @@
     const DisplayLayoutList& layouts) {
   display::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   display::DisplayLayoutBuilder builder(
       display_manager->GetCurrentDisplayLayout());
 
   bool have_root = false;
   builder.ClearPlacements();
   for (const system_display::DisplayLayout& layout : layouts) {
     display::Display display = GetDisplay(layout.id);
-    if (display.id() == display::Display::kInvalidDisplayID) {
+    if (display.id() == display::kInvalidDisplayId) {
       LOG(ERROR) << "Invalid layout: display id not found: " << layout.id;
       return false;
     }
     display::Display parent = GetDisplay(layout.parent_id);
-    if (parent.id() == display::Display::kInvalidDisplayID) {
+    if (parent.id() == display::kInvalidDisplayId) {
       if (have_root) {
         LOG(ERROR) << "Invalid layout: multople roots.";
         return false;
       }
       have_root = true;
       continue;  // No placement for root (primary) display.
     }
     display::DisplayPlacement::Position position =
         GetDisplayPlacementPosition(layout.position);
     builder.AddDisplayPlacement(display.id(), parent.id(), position,
@@ skipping 81 matching lines @@
     return DisplayInfoProvider::DisplayLayoutList();
 
   display::Screen* screen = display::Screen::GetScreen();
   std::vector<display::Display> displays = screen->GetAllDisplays();
 
   DisplayLayoutList result;
   for (const display::Display& display : displays) {
     const display::DisplayPlacement placement =
         display_manager->GetCurrentDisplayLayout().FindPlacementById(
             display.id());
-    if (placement.display_id == display::Display::kInvalidDisplayID)
+    if (placement.display_id == display::kInvalidDisplayId)
       continue;
     system_display::DisplayLayout display_layout;
     display_layout.id = base::Int64ToString(placement.display_id);
     display_layout.parent_id = base::Int64ToString(placement.parent_display_id);
     display_layout.position = GetLayoutPosition(placement.position);
     display_layout.offset = placement.offset;
     result.push_back(std::move(display_layout));
   }
   return result;
 }
 
 bool DisplayInfoProviderChromeOS::OverscanCalibrationStart(
     const std::string& id) {
   VLOG(1) << "OverscanCalibrationStart: " << id;
   const display::Display display = GetDisplay(id);
-  if (display.id() == display::Display::kInvalidDisplayID)
+  if (display.id() == display::kInvalidDisplayId)
     return false;
   auto insets =
       ash::Shell::GetInstance()->window_tree_host_manager()->GetOverscanInsets(
           display.id());
   overscan_calibrators_[id].reset(
       new chromeos::OverscanCalibrator(display, insets));
   return true;
 }
 
 bool DisplayInfoProviderChromeOS::OverscanCalibrationAdjust(
@@ skipping 37 matching lines @@
     return nullptr;
   return iter->second.get();
 }
 
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   return new DisplayInfoProviderChromeOS();
 }
 
 }  // namespace extensions