Update display::Display::kInvalidDisplayID constant.

ash/display/window_tree_host_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/window_tree_host_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 #include <memory>
@@ skipping 28 matching lines @@
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method_factory.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/compositor.h"
 #include "ui/display/display.h"
 #include "ui/display/manager/display_layout.h"
 #include "ui/display/manager/display_layout_store.h"
 #include "ui/display/manager/display_manager.h"
 #include "ui/display/screen.h"
+#include "ui/display/types/display_constants.h"
 #include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/public/activation_client.h"
 
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"  // nogncheck
 #include "ui/gfx/x/x11_types.h"  // nogncheck
 
 // Including this at the bottom to avoid other
 // potential conflict with chrome headers.
 #include <X11/extensions/Xrandr.h>
@@ skipping 172 matching lines @@
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHostManager
 
 WindowTreeHostManager::WindowTreeHostManager()
     : primary_tree_host_for_replace_(nullptr),
       focus_activation_store_(new FocusActivationStore()),
       cursor_window_controller_(new CursorWindowController()),
       mirror_window_controller_(new MirrorWindowController()),
-      cursor_display_id_for_restore_(display::Display::kInvalidDisplayID),
+      cursor_display_id_for_restore_(display::kInvalidDisplayId),
       weak_ptr_factory_(this) {
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
-  primary_display_id = display::Display::kInvalidDisplayID;
+  primary_display_id = display::kInvalidDisplayId;
 }
 
 WindowTreeHostManager::~WindowTreeHostManager() {}
 
 void WindowTreeHostManager::Start() {
   display::Screen::GetScreen()->AddObserver(this);
   Shell::GetInstance()->display_manager()->set_delegate(this);
 }
 
 void WindowTreeHostManager::Shutdown() {
@@ skipping 30 matching lines @@
   for (auto rwc : to_delete)
     delete rwc;
   delete primary_rwc;
 }
 
 void WindowTreeHostManager::CreatePrimaryHost(
     const AshWindowTreeHostInitParams& init_params) {
   const display::Display& primary_candidate =
       GetDisplayManager()->GetPrimaryDisplayCandidate();
   primary_display_id = primary_candidate.id();
-  CHECK_NE(display::Display::kInvalidDisplayID, primary_display_id);
+  CHECK_NE(display::kInvalidDisplayId, primary_display_id);
   AddWindowTreeHostForDisplay(primary_candidate, init_params);
 }
 
 void WindowTreeHostManager::InitHosts() {
   RootWindowController::CreateForPrimaryDisplay(
       window_tree_hosts_[primary_display_id]);
   display::DisplayManager* display_manager = GetDisplayManager();
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const display::Display& display = display_manager->GetDisplayAt(i);
     if (primary_display_id != display.id()) {
@@ skipping 10 matching lines @@
 void WindowTreeHostManager::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowTreeHostManager::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 // static
 int64_t WindowTreeHostManager::GetPrimaryDisplayId() {
-  CHECK_NE(display::Display::kInvalidDisplayID, primary_display_id);
+  CHECK_NE(display::kInvalidDisplayId, primary_display_id);
   return primary_display_id;
 }
 
 aura::Window* WindowTreeHostManager::GetPrimaryRootWindow() {
   return GetRootWindowForDisplayId(primary_display_id);
 }
 
 aura::Window* WindowTreeHostManager::GetRootWindowForDisplayId(int64_t id) {
   AshWindowTreeHost* host = GetAshWindowTreeHostForDisplayId(id);
   return host ? GetWindow(host) : nullptr;
@@ skipping 50 matching lines @@
     RootWindowController* controller =
         GetRootWindowController(GetWindow(it->second));
     if (controller)
       controllers.push_back(controller);
   }
   return controllers;
 }
 
 void WindowTreeHostManager::SetPrimaryDisplayId(int64_t id) {
   // TODO(oshima): Move primary display management to DisplayManager.
-  DCHECK_NE(display::Display::kInvalidDisplayID, id);
-  if (id == display::Display::kInvalidDisplayID || primary_display_id == id ||
+  DCHECK_NE(display::kInvalidDisplayId, id);
+  if (id == display::kInvalidDisplayId || primary_display_id == id ||
       window_tree_hosts_.size() < 2) {
     return;
   }
   // TODO(oshima): Implement swapping primary for 2> displays.
   if (GetDisplayManager()->GetNumDisplays() > 2)
     return;
 
   const display::Display& new_primary_display =
       GetDisplayManager()->GetDisplayForId(id);
   if (!new_primary_display.is_valid()) {
@@ skipping 144 matching lines @@
   dst_root_window->MoveCursorTo(target_location_in_root);
 #endif
 }
 
 bool WindowTreeHostManager::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const aura::Window* root_window = window->GetRootWindow();
   int64_t id = GetRootWindowSettings(root_window)->display_id;
   // if id is |kInvaildDisplayID|, it's being deleted.
-  DCHECK(id != display::Display::kInvalidDisplayID);
+  DCHECK(id != display::kInvalidDisplayId);
   return GetDisplayManager()->UpdateWorkAreaOfDisplay(id, insets);
 }
 
 void WindowTreeHostManager::OnDisplayAdded(const display::Display& display) {
 #if defined(OS_CHROMEOS)
   // If we're switching from/to offscreen WTH, we need to
   // create new WTH for primary display instead of reusing.
   if (primary_tree_host_for_replace_ &&
       (GetRootWindowSettings(GetWindow(primary_tree_host_for_replace_))
                ->display_id == display::DisplayManager::kUnifiedDisplayId ||
        display.id() == display::DisplayManager::kUnifiedDisplayId)) {
-    DCHECK_EQ(display::Display::kInvalidDisplayID, primary_display_id);
+    DCHECK_EQ(display::kInvalidDisplayId, primary_display_id);
     primary_display_id = display.id();
 
     AshWindowTreeHost* ash_host =
         AddWindowTreeHostForDisplay(display, AshWindowTreeHostInitParams());
     RootWindowController::CreateForSecondaryDisplay(ash_host);
 
     // Magnifier controllers keep pointers to the current root window.
     // Update them here to avoid accessing them later.
     Shell::GetInstance()->magnification_controller()->SwitchTargetRootWindow(
         ash_host->AsWindowTreeHost()->window(), false);
@@ skipping 38 matching lines @@
     window_tree_hosts_[display.id()] = primary_tree_host_for_replace_;
     GetRootWindowSettings(GetWindow(primary_tree_host_for_replace_))
         ->display_id = display.id();
     primary_tree_host_for_replace_ = nullptr;
     const display::ManagedDisplayInfo& display_info =
         GetDisplayManager()->GetDisplayInfo(display.id());
     AshWindowTreeHost* ash_host = window_tree_hosts_[display.id()];
     ash_host->AsWindowTreeHost()->SetBounds(display_info.bounds_in_native());
     SetDisplayPropertiesOnHost(ash_host, display);
   } else {
-    if (primary_display_id == display::Display::kInvalidDisplayID)
+    if (primary_display_id == display::kInvalidDisplayId)
       primary_display_id = display.id();
     DCHECK(!window_tree_hosts_.empty());
     AshWindowTreeHost* ash_host =
         AddWindowTreeHostForDisplay(display, AshWindowTreeHostInitParams());
     RootWindowController::CreateForSecondaryDisplay(ash_host);
   }
 }
 
 void WindowTreeHostManager::DeleteHost(AshWindowTreeHost* host_to_delete) {
   ClearDisplayPropertiesOnHost(host_to_delete);
@@ skipping 10 matching lines @@
 void WindowTreeHostManager::OnDisplayRemoved(const display::Display& display) {
   AshWindowTreeHost* host_to_delete = window_tree_hosts_[display.id()];
   CHECK(host_to_delete) << display.ToString();
 
   // When the primary root window's display is removed, move the primary
   // root to the other display.
   if (primary_display_id == display.id()) {
     // Temporarily store the primary root window in
     // |primary_root_window_for_replace_| when replacing the display.
     if (window_tree_hosts_.size() == 1) {
-      primary_display_id = display::Display::kInvalidDisplayID;
+      primary_display_id = display::kInvalidDisplayId;
       primary_tree_host_for_replace_ = host_to_delete;
       // Display for root window will be deleted when the Primary RootWindow
       // is deleted by the Shell.
       window_tree_hosts_.erase(display.id());
       return;
     }
     for (const auto& pair : window_tree_hosts_) {
       if (pair.first != display.id()) {
         primary_display_id = pair.first;
         break;
       }
     }
-    CHECK_NE(display::Display::kInvalidDisplayID, primary_display_id);
+    CHECK_NE(display::kInvalidDisplayId, primary_display_id);
 
     AshWindowTreeHost* primary_host = host_to_delete;
     // Delete the other host instead.
     host_to_delete = window_tree_hosts_[primary_display_id];
     GetRootWindowSettings(GetWindow(host_to_delete))->display_id = display.id();
 
     // Setup primary root.
     window_tree_hosts_[primary_display_id] = primary_host;
     GetRootWindowSettings(GetWindow(primary_host))->display_id =
         primary_display_id;
@@ skipping 82 matching lines @@
 
   display::DisplayManager* display_manager = GetDisplayManager();
   display::DisplayLayoutStore* layout_store = display_manager->layout_store();
   if (display_manager->num_connected_displays() > 1) {
     display::DisplayIdList list = display_manager->GetCurrentDisplayIdList();
     const display::DisplayLayout& layout =
         layout_store->GetRegisteredDisplayLayout(list);
     layout_store->UpdateMultiDisplayState(
         list, display_manager->IsInMirrorMode(), layout.default_unified);
     if (display::Screen::GetScreen()->GetNumDisplays() > 1) {
-      SetPrimaryDisplayId(layout.primary_id ==
-                                  display::Display::kInvalidDisplayID
+      SetPrimaryDisplayId(layout.primary_id == display::kInvalidDisplayId
                               ? list[0]
                               : layout.primary_id);
     }
   }
 
   for (const display::Display& display :
        display_manager->active_display_list()) {
     bool output_is_secure =
         !display_manager->IsInMirrorMode() && display.IsInternal();
     GetAshWindowTreeHostForDisplayId(display.id())
@@ skipping 76 matching lines @@
   SetDisplayPropertiesOnHost(ash_host, display);
 
 #if defined(OS_CHROMEOS)
   if (switches::ConstrainPointerToRoot())
     ash_host->ConfineCursorToRootWindow();
 #endif
   return ash_host;
 }
 
 }  // namespace ash