Move kInvalidDisplayID to display_constants.h.

ui/display/manager/managed_display_info.cc

 // Copyright (c) 2013 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/managed_display_info.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 121 matching lines @@
     const scoped_refptr<display::ManagedDisplayMode>& other) const {
   const float kEpsilon = 0.0001f;
   return size_ == other->size_ &&
          std::abs(ui_scale_ - other->ui_scale_) < kEpsilon &&
          std::abs(device_scale_factor_ - other->device_scale_factor_) <
              kEpsilon;
 }
 
 // static
 ManagedDisplayInfo ManagedDisplayInfo::CreateFromSpec(const std::string& spec) {
-  return CreateFromSpecWithID(spec, display::Display::kInvalidDisplayID);
+  return CreateFromSpecWithID(spec, kInvalidDisplayId);
 }
 
 // static
 ManagedDisplayInfo ManagedDisplayInfo::CreateFromSpecWithID(
     const std::string& spec,
     int64_t id) {
 #if defined(OS_WIN)
   gfx::Rect bounds_in_native(
       gfx::Size(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN)));
 #else
@@ skipping 86 matching lines @@
             new ManagedDisplayMode(size, refresh_rate, is_interlaced, false,
                                    1.0, device_scale_factor)));
       }
     }
     scoped_refptr<display::ManagedDisplayMode> dm = display_modes[native_mode];
     display_modes[native_mode] = new ManagedDisplayMode(
         dm->size(), dm->refresh_rate(), dm->is_interlaced(), true,
         dm->ui_scale(), dm->device_scale_factor());
   }
 
-  if (id == display::Display::kInvalidDisplayID)
+  if (id == kInvalidDisplayId)
     id = synthesized_display_id++;
   display::ManagedDisplayInfo display_info(
       id, base::StringPrintf("Display-%d", static_cast<int>(id)), has_overscan);
   display_info.set_device_scale_factor(device_scale_factor);
   display_info.SetRotation(rotation, display::Display::ROTATION_SOURCE_ACTIVE);
   display_info.set_configured_ui_scale(ui_scale);
   display_info.SetBounds(bounds_in_native);
   display_info.SetManagedDisplayModes(display_modes);
 
   // To test the overscan, it creates the default 5% overscan.
   if (has_overscan) {
     int width = bounds_in_native.width() / device_scale_factor / 40;
     int height = bounds_in_native.height() / device_scale_factor / 40;
     display_info.SetOverscanInsets(gfx::Insets(height, width, height, width));
     display_info.UpdateDisplaySize();
   }
 
   DVLOG(1) << "DisplayInfoFromSpec info=" << display_info.ToString()
            << ", spec=" << spec;
   return display_info;
 }
 
 // static
 void ManagedDisplayInfo::SetUse125DSFForUIScalingForTest(bool enable) {
   use_125_dsf_for_ui_scaling = enable;
 }
 
 ManagedDisplayInfo::ManagedDisplayInfo()
-    : id_(display::Display::kInvalidDisplayID),
+    : id_(kInvalidDisplayId),
       has_overscan_(false),
       active_rotation_source_(display::Display::ROTATION_SOURCE_UNKNOWN),
       touch_support_(display::Display::TOUCH_SUPPORT_UNKNOWN),
       device_scale_factor_(1.0f),
       device_dpi_(kDpi96),
       overscan_insets_in_dip_(0, 0, 0, 0),
       configured_ui_scale_(1.0f),
       native_(false),
       is_aspect_preserving_scaling_(false),
       clear_overscan_insets_(false),
@@ skipping 205 matching lines @@
 
 void ManagedDisplayInfo::ClearInputDevices() {
   input_devices_.clear();
 }
 
 void ResetDisplayIdForTest() {
   synthesized_display_id = kSynthesizedDisplayIdStart;
 }
 
 }  // namespace display