Add IsInternal property to gfx::Display

ash/display/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 "ash/display/display_manager.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/display/display_controller.h"
@@ skipping 73 matching lines @@
 
 using aura::RootWindow;
 using aura::Window;
 using std::string;
 using std::vector;
 
 DEFINE_WINDOW_PROPERTY_KEY(int64, kDisplayIdKey,
                            gfx::Display::kInvalidDisplayID);
 
 DisplayManager::DisplayManager() :
-    internal_display_id_(gfx::Display::kInvalidDisplayID),
     force_bounds_changed_(false) {
   Init();
 }
 
 DisplayManager::~DisplayManager() {
 }
 
 // static
 void DisplayManager::CycleDisplay() {
   Shell::GetInstance()->display_manager()->CycleDisplayImpl();
 }
 
 // static
 void DisplayManager::ToggleDisplayScale() {
   Shell::GetInstance()->display_manager()->ScaleDisplayImpl();
 }
 
 bool DisplayManager::IsActiveDisplay(const gfx::Display& display) const {
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     if ((*iter).id() == display.id())
       return true;
   }
   return false;
 }
 
 bool DisplayManager::HasInternalDisplay() const {
-  return internal_display_id_ != gfx::Display::kInvalidDisplayID;
+  return gfx::Display::internal_display_id() != gfx::Display::kInvalidDisplayID;
 }
 
 bool DisplayManager::IsInternalDisplayId(int64 id) const {
-  return internal_display_id_ == id;
+  return gfx::Display::internal_display_id() == id;
 }
 
 bool DisplayManager::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const RootWindow* root = window->GetRootWindow();
   gfx::Display& display = FindDisplayForRootWindow(root);
   gfx::Rect old_work_area = display.work_area();
   display.UpdateWorkAreaFromInsets(insets);
   return old_work_area != display.work_area();
@@ skipping 41 matching lines @@
     // - the device is suspended. (kernel turns off all displays)
     // - the internal display's brightness is set to 0 and no external
     //   display is connected.
     // - the internal display's brightness is 0 and external display is
     //   disconnected.
     // The display will be updated when one of displays is turned on, and the
     // display list will be updated correctly.
     return;
   }
   DisplayList new_displays = updated_displays;
-  if (internal_display_id_ != gfx::Display::kInvalidDisplayID) {
+  if (HasInternalDisplay()) {
     bool internal_display_connected = false;
     for (DisplayList::const_iterator iter = updated_displays.begin();
          iter != updated_displays.end(); ++iter) {
-      if ((*iter).id() == internal_display_id_) {
+      if ((*iter).is_internal()) {
         internal_display_connected = true;
         // Update the internal display cache.
         internal_display_.reset(new gfx::Display);
         *internal_display_.get() = *iter;
         break;
       }
     }
     // If the internal display wasn't connected, use the cached value.
     if (!internal_display_connected) {
       // Internal display may be reported as disconnect during startup time.
       if (!internal_display_.get()) {
-        internal_display_.reset(new gfx::Display(internal_display_id_,
-                                                 gfx::Rect(800, 600)));
+        internal_display_.reset(
+            new gfx::Display(gfx::Display::internal_display_id(),
+                             gfx::Rect(800, 600)));
       }
       new_displays.push_back(*internal_display_.get());
     }
   } else {
     new_displays = updated_displays;
   }
 
   RefreshDisplayInfo();
 
   for (DisplayList::const_iterator iter = new_displays.begin();
@@ skipping 218 matching lines @@
 
 void DisplayManager::Init() {
 #if defined(OS_CHROMEOS)
   if (base::chromeos::IsRunningOnChromeOS()) {
     std::vector<XID> outputs;
     ui::GetOutputDeviceHandles(&outputs);
     std::vector<std::string> output_names = ui::GetOutputNames(outputs);
     for (size_t i = 0; i < output_names.size(); ++i) {
       if (chromeos::OutputConfigurator::IsInternalOutputName(
               output_names[i])) {
-        internal_display_id_ = GetDisplayIdForOutput(outputs[i], i);
+        gfx::Display::set_internal_display_id(
+            GetDisplayIdForOutput(outputs[i], i));
         break;
       }
     }
   }
 #endif
 
   RefreshDisplayInfo();
 
 #if defined(OS_WIN)
   if (base::win::GetVersion() >= base::win::VERSION_WIN8)
@@ skipping 68 matching lines @@
   gfx::Display display = aura::CreateDisplayFromSpec(spec);
 
   const gfx::Insets insets = display.GetWorkAreaInsets();
   const gfx::Rect& native_bounds = display.bounds_in_pixel();
   display.SetScaleAndBounds(display.device_scale_factor(), native_bounds);
   display.UpdateWorkAreaFromInsets(insets);
   displays_.push_back(display);
 }
 
 int64 DisplayManager::SetFirstDisplayAsInternalDisplayForTest() {
-  internal_display_id_ = displays_[0].id();
+  gfx::Display::set_internal_display_id(displays_[0].id());
   internal_display_.reset(new gfx::Display);
   *internal_display_ = displays_[0];
-  return internal_display_id_;
+  return gfx::Display::internal_display_id();
+}
+
+void DisplayManager::ResetInternalDisplayForTest() {
+  gfx::Display::set_internal_display_id(gfx::Display::kInvalidDisplayID);
 }
 
 void DisplayManager::EnsurePointerInDisplays() {
   // Don't try to move the pointer during the boot/startup.
   if (!DisplayController::HasPrimaryDisplay())
     return;
   gfx::Point location_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
   gfx::Point target_location;
   int64 closest_distance_squared = -1;
 
@@ skipping 71 matching lines @@
     (*iter_to_update).set_id((*iter).id());
   }
 }
 
 void DisplayManager::SetHasOverscanFlagForTest(int64 id, bool has_overscan) {
   display_info_[id].has_overscan = has_overscan;
 }
 
 }  // namespace internal
 }  // namespace ash