Update display::Display::kInvalidDisplayID constant.

services/ui/display/platform_screen_ozone.cc

 // Copyright 2016 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 "services/ui/display/platform_screen_ozone.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
 #include "third_party/skia/include/core/SkColor.h"
-#include "ui/display/types/display_constants.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/ozone/public/ozone_platform.h"
 
 namespace display {
 namespace {
 
 // Needed for DisplayConfigurator::ForceInitialConfigure.
 const SkColor kChromeOsBootColor = SkColorSetRGB(0xfe, 0xfe, 0xfe);
@@ skipping 81 matching lines @@
   return primary_display_id_;
 }
 
 void PlatformScreenOzone::ToggleAddRemoveDisplay() {
   if (!fake_display_controller_ || wait_for_display_config_update_)
     return;
 
   if (cached_displays_.size() == 1) {
     const gfx::Size& pixel_size = cached_displays_[0].metrics.pixel_size;
     wait_for_display_config_update_ =
-        fake_display_controller_->AddDisplay(pixel_size) !=
-        Display::kInvalidDisplayID;
+        fake_display_controller_->AddDisplay(pixel_size) != kInvalidDisplayId;
   } else if (cached_displays_.size() > 1) {
     wait_for_display_config_update_ =
         fake_display_controller_->RemoveDisplay(cached_displays_.back().id);
   } else {
     NOTREACHED();
   }
 }
 
 void PlatformScreenOzone::ToggleDisplayResolution() {
   DisplayInfo& display = cached_displays_[0];
@@ skipping 70 matching lines @@
   std::vector<int64_t> current_ids;
   for (ui::DisplaySnapshot* snapshot : snapshots)
     current_ids.push_back(snapshot->display_id());
 
   // Find cached displays with no matching snapshot and mark as removed.
   for (DisplayInfo& display : cached_displays_) {
     if (std::find(current_ids.begin(), current_ids.end(), display.id) ==
         current_ids.end()) {
       display.removed = true;
       if (primary_display_id_ == display.id)
-        primary_display_id_ = Display::kInvalidDisplayID;
+        primary_display_id_ = kInvalidDisplayId;
     }
   }
 }
 
 void PlatformScreenOzone::ProcessModifiedDisplays(
     const ui::DisplayConfigurator::DisplayStateList& snapshots) {
   for (ui::DisplaySnapshot* snapshot : snapshots) {
     auto iter = GetCachedDisplayIterator(snapshot->display_id());
     if (iter != cached_displays_.end()) {
       DisplayInfo& display_info = *iter;
@@ skipping 59 matching lines @@
         display_info.requested_size = mode->size();
     }
 
     // Move the origin so that next display is to the right of current display.
     next_display_origin_.Offset(display_info.metrics.bounds.width(), 0);
 
     cached_displays_.push_back(display_info);
     delegate_->OnDisplayAdded(display_info.id, display_info.metrics);
 
     // If we have no primary display then this one should be it.
-    if (primary_display_id_ == Display::kInvalidDisplayID) {
+    if (primary_display_id_ == kInvalidDisplayId) {
       primary_display_id_ = id;
       delegate_->OnPrimaryDisplayChanged(primary_display_id_);
     }
   }
 }
 
 PlatformScreenOzone::CachedDisplayIterator
 PlatformScreenOzone::GetCachedDisplayIterator(int64_t display_id) {
   return std::find_if(cached_displays_.begin(), cached_displays_.end(),
                       [display_id](const DisplayInfo& display_info) {
@@ skipping 20 matching lines @@
   return metrics;
 }
 
 void PlatformScreenOzone::OnDisplayModeChanged(
     const ui::DisplayConfigurator::DisplayStateList& displays) {
   ProcessRemovedDisplays(displays);
   ProcessModifiedDisplays(displays);
 
   // If the primary display is marked as removed we'll try to find a new primary
   // display and update the delegate before removing the old primary display.
-  if (primary_display_id_ == Display::kInvalidDisplayID) {
+  if (primary_display_id_ == kInvalidDisplayId) {
     for (const DisplayInfo& display : cached_displays_) {
       if (!display.removed) {
         primary_display_id_ = display.id;
         delegate_->OnPrimaryDisplayChanged(primary_display_id_);
         break;
       }
     }
   }
 
   UpdateCachedDisplays();
@@ skipping 34 matching lines @@
   return false;
 }
 
 void PlatformScreenOzone::Create(
     const service_manager::Identity& remote_identity,
     mojom::TestDisplayControllerRequest request) {
   test_bindings_.AddBinding(this, std::move(request));
 }
 
 }  // namespace display