Eliminate ash::internal namespace

ash/display/display_controller.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_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 
@@ skipping 54 matching lines @@
 // Specifies how long the display change should have been disabled
 // after each display change operations.
 // |kCycleDisplayThrottleTimeoutMs| is set to be longer to avoid
 // changing the settings while the system is still configurating
 // displays. It will be overriden by |kAfterDisplayChangeThrottleTimeoutMs|
 // when the display change happens, so the actual timeout is much shorter.
 const int64 kAfterDisplayChangeThrottleTimeoutMs = 500;
 const int64 kCycleDisplayThrottleTimeoutMs = 4000;
 const int64 kSwapDisplayThrottleTimeoutMs = 500;
 
-internal::DisplayManager* GetDisplayManager() {
+DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
 void SetDisplayPropertiesOnHost(aura::WindowTreeHost* host,
                                 const gfx::Display& display) {
-  internal::DisplayInfo info =
-      GetDisplayManager()->GetDisplayInfo(display.id());
+  DisplayInfo info = GetDisplayManager()->GetDisplayInfo(display.id());
 #if defined(OS_CHROMEOS) && defined(USE_X11)
   // Native window property (Atom in X11) that specifies the display's
   // rotation, scale factor and if it's internal display.  They are
   // read and used by touchpad/mouse driver directly on X (contact
   // adlr@ for more details on touchpad/mouse driver side). The value
   // of the rotation is one of 0 (normal), 1 (90 degrees clockwise), 2
   // (180 degree) or 3 (270 degrees clockwise).  The value of the
   // scale factor is in percent (100, 140, 200 etc).
   const char kRotationProp[] = "_CHROME_DISPLAY_ROTATION";
   const char kScaleFactorProp[] = "_CHROME_DISPLAY_SCALE_FACTOR";
@@ skipping 18 matching lines @@
   int internal = display.IsInternal() ? 1 : 0;
   gfx::AcceleratedWidget xwindow = host->GetAcceleratedWidget();
   ui::SetIntProperty(xwindow, kInternalProp, kCARDINAL, internal);
   ui::SetIntProperty(xwindow, kRotationProp, kCARDINAL, xrandr_rotation);
   ui::SetIntProperty(xwindow,
                      kScaleFactorProp,
                      kCARDINAL,
                      100 * display.device_scale_factor());
 #endif
   scoped_ptr<aura::RootWindowTransformer> transformer(
-      internal::CreateRootWindowTransformerForDisplay(host->window(),
-                                                      display));
+      CreateRootWindowTransformerForDisplay(host->window(), display));
   host->SetRootWindowTransformer(transformer.Pass());
 
-  internal::DisplayMode mode;
+  DisplayMode mode;
   if (GetDisplayManager()->GetSelectedModeForDisplayId(display.id(), &mode) &&
       mode.refresh_rate > 0.0f) {
     host->compositor()->vsync_manager()->SetAuthoritativeVSyncInterval(
         base::TimeDelta::FromMicroseconds(
             base::Time::kMicrosecondsPerSecond / mode.refresh_rate));
   }
 }
 
 }  // namespace
 
-namespace internal {
-
 // A utility class to store/restore focused/active window
 // when the display configuration has changed.
 class FocusActivationStore {
  public:
   FocusActivationStore()
       : activation_client_(NULL),
         capture_client_(NULL),
         focus_client_(NULL),
         focused_(NULL),
         active_(NULL) {
@@ skipping 46 matching lines @@
   aura::client::ActivationClient* activation_client_;
   aura::client::CaptureClient* capture_client_;
   aura::client::FocusClient* focus_client_;
   aura::WindowTracker tracker_;
   aura::Window* focused_;
   aura::Window* active_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusActivationStore);
 };
 
-}  // namespace internal
-
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayChangeLimiter
 
 DisplayController::DisplayChangeLimiter::DisplayChangeLimiter()
     : throttle_timeout_(base::Time::Now()) {
 }
 
 void DisplayController::DisplayChangeLimiter::SetThrottleTimeout(
     int64 throttle_ms) {
   throttle_timeout_ =
       base::Time::Now() + base::TimeDelta::FromMilliseconds(throttle_ms);
 }
 
 bool DisplayController::DisplayChangeLimiter::IsThrottled() const {
   return base::Time::Now() < throttle_timeout_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayController
 
 DisplayController::DisplayController()
     : primary_root_window_for_replace_(NULL),
-      focus_activation_store_(new internal::FocusActivationStore()),
-      cursor_window_controller_(new internal::CursorWindowController()),
-      mirror_window_controller_(new internal::MirrorWindowController()) {
+      focus_activation_store_(new FocusActivationStore()),
+      cursor_window_controller_(new CursorWindowController()),
+      mirror_window_controller_(new MirrorWindowController()) {
 #if defined(OS_CHROMEOS)
   if (base::SysInfo::IsRunningOnChromeOS())
     limiter_.reset(new DisplayChangeLimiter);
 #endif
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
   primary_display_id = gfx::Display::kInvalidDisplayID;
 }
 
 DisplayController::~DisplayController() {
 }
 
 void DisplayController::Start() {
   // Created here so that Shell has finished being created. Adds itself
   // as a ShellObserver.
   virtual_keyboard_window_controller_.reset(
-      new internal::VirtualKeyboardWindowController);
+      new VirtualKeyboardWindowController);
   Shell::GetScreen()->AddObserver(this);
   Shell::GetInstance()->display_manager()->set_delegate(this);
 
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplaysInitialized());
 }
 
 void DisplayController::Shutdown() {
   // Unset the display manager's delegate here because
   // DisplayManager outlives DisplayController.
   Shell::GetInstance()->display_manager()->set_delegate(NULL);
 
   cursor_window_controller_.reset();
   mirror_window_controller_.reset();
   virtual_keyboard_window_controller_.reset();
 
   Shell::GetScreen()->RemoveObserver(this);
   // Delete all root window controllers, which deletes root window
   // from the last so that the primary root window gets deleted last.
   for (std::map<int64, aura::Window*>::const_reverse_iterator it =
            root_windows_.rbegin(); it != root_windows_.rend(); ++it) {
-    internal::RootWindowController* controller =
-        internal::GetRootWindowController(it->second);
+    RootWindowController* controller = GetRootWindowController(it->second);
     DCHECK(controller);
     delete controller;
   }
 }
 
 void DisplayController::InitPrimaryDisplay() {
   const gfx::Display& primary_candidate =
       GetDisplayManager()->GetPrimaryDisplayCandidate();
   primary_display_id = primary_candidate.id();
   AddWindowTreeHostForDisplay(primary_candidate);
 }
 
 void DisplayController::InitSecondaryDisplays() {
-  internal::DisplayManager* display_manager = GetDisplayManager();
+  DisplayManager* display_manager = GetDisplayManager();
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const gfx::Display& display = display_manager->GetDisplayAt(i);
     if (primary_display_id != display.id()) {
       aura::WindowTreeHost* host = AddWindowTreeHostForDisplay(display);
-      internal::RootWindowController::CreateForSecondaryDisplay(host);
+      RootWindowController::CreateForSecondaryDisplay(host);
     }
   }
   UpdateHostWindowNames();
 }
 
 void DisplayController::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DisplayController::RemoveObserver(Observer* observer) {
@@ skipping 11 matching lines @@
 }
 
 aura::Window* DisplayController::GetRootWindowForDisplayId(int64 id) {
   return root_windows_[id];
 }
 
 void DisplayController::CloseChildWindows() {
   for (std::map<int64, aura::Window*>::const_iterator it =
            root_windows_.begin(); it != root_windows_.end(); ++it) {
     aura::Window* root_window = it->second;
-    internal::RootWindowController* controller =
-        internal::GetRootWindowController(root_window);
+    RootWindowController* controller = GetRootWindowController(root_window);
     if (controller) {
       controller->CloseChildWindows();
     } else {
       while (!root_window->children().empty()) {
         aura::Window* child = root_window->children()[0];
         delete child;
       }
     }
   }
 }
 
 aura::Window::Windows DisplayController::GetAllRootWindows() {
   aura::Window::Windows windows;
   for (std::map<int64, aura::Window*>::const_iterator it =
            root_windows_.begin(); it != root_windows_.end(); ++it) {
     DCHECK(it->second);
-    if (internal::GetRootWindowController(it->second))
+    if (GetRootWindowController(it->second))
       windows.push_back(it->second);
   }
   return windows;
 }
 
 gfx::Insets DisplayController::GetOverscanInsets(int64 display_id) const {
   return GetDisplayManager()->GetOverscanInsets(display_id);
 }
 
 void DisplayController::SetOverscanInsets(int64 display_id,
                                           const gfx::Insets& insets_in_dip) {
   GetDisplayManager()->SetOverscanInsets(display_id, insets_in_dip);
 }
 
-std::vector<internal::RootWindowController*>
+std::vector<RootWindowController*>
 DisplayController::GetAllRootWindowControllers() {
-  std::vector<internal::RootWindowController*> controllers;
+  std::vector<RootWindowController*> controllers;
   for (std::map<int64, aura::Window*>::const_iterator it =
            root_windows_.begin(); it != root_windows_.end(); ++it) {
-    internal::RootWindowController* controller =
-        internal::GetRootWindowController(it->second);
+    RootWindowController* controller = GetRootWindowController(it->second);
     if (controller)
       controllers.push_back(controller);
   }
   return controllers;
 }
 
 void DisplayController::ToggleMirrorMode() {
-  internal::DisplayManager* display_manager = GetDisplayManager();
+  DisplayManager* display_manager = GetDisplayManager();
   if (display_manager->num_connected_displays() <= 1)
     return;
 
   if (limiter_) {
     if  (limiter_->IsThrottled())
       return;
     limiter_->SetThrottleTimeout(kCycleDisplayThrottleTimeoutMs);
   }
 #if defined(OS_CHROMEOS)
   Shell* shell = Shell::GetInstance();
-  internal::OutputConfiguratorAnimation* animation =
+  OutputConfiguratorAnimation* animation =
       shell->output_configurator_animation();
-  animation->StartFadeOutAnimation(base::Bind(
-      base::IgnoreResult(&internal::DisplayManager::SetMirrorMode),
-      base::Unretained(display_manager),
-      !display_manager->IsMirrored()));
+  animation->StartFadeOutAnimation(
+      base::Bind(base::IgnoreResult(&DisplayManager::SetMirrorMode),
+                 base::Unretained(display_manager),
+                 !display_manager->IsMirrored()));
 #endif
 }
 
 void DisplayController::SwapPrimaryDisplay() {
   if (limiter_) {
     if  (limiter_->IsThrottled())
       return;
     limiter_->SetThrottleTimeout(kSwapDisplayThrottleTimeoutMs);
   }
 
   if (Shell::GetScreen()->GetNumDisplays() > 1) {
 #if defined(OS_CHROMEOS)
-    internal::OutputConfiguratorAnimation* animation =
+    OutputConfiguratorAnimation* animation =
         Shell::GetInstance()->output_configurator_animation();
     if (animation) {
       animation->StartFadeOutAnimation(base::Bind(
           &DisplayController::OnFadeOutForSwapDisplayFinished,
           base::Unretained(this)));
     } else {
       SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
     }
 #else
     SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
 #endif
   }
 }
 
 void DisplayController::SetPrimaryDisplayId(int64 id) {
   DCHECK_NE(gfx::Display::kInvalidDisplayID, id);
   if (id == gfx::Display::kInvalidDisplayID || primary_display_id == id)
     return;
 
   const gfx::Display& display = GetDisplayManager()->GetDisplayForId(id);
   if (display.is_valid())
     SetPrimaryDisplay(display);
 }
 
 void DisplayController::SetPrimaryDisplay(
     const gfx::Display& new_primary_display) {
-  internal::DisplayManager* display_manager = GetDisplayManager();
+  DisplayManager* display_manager = GetDisplayManager();
   DCHECK(new_primary_display.is_valid());
   DCHECK(display_manager->IsActiveDisplay(new_primary_display));
 
   if (!new_primary_display.is_valid() ||
       !display_manager->IsActiveDisplay(new_primary_display)) {
     LOG(ERROR) << "Invalid or non-existent display is requested:"
                << new_primary_display.ToString();
     return;
   }
 
@@ skipping 10 matching lines @@
     return;
 
   gfx::Display old_primary_display = Shell::GetScreen()->GetPrimaryDisplay();
 
   // Swap root windows between current and new primary display.
   aura::Window* primary_root = root_windows_[primary_display_id];
   DCHECK(primary_root);
   DCHECK_NE(primary_root, non_primary_root);
 
   root_windows_[new_primary_display.id()] = primary_root;
-  internal::GetRootWindowSettings(primary_root)->display_id =
-      new_primary_display.id();
+  GetRootWindowSettings(primary_root)->display_id = new_primary_display.id();
 
   root_windows_[old_primary_display.id()] = non_primary_root;
-  internal::GetRootWindowSettings(non_primary_root)->display_id =
+  GetRootWindowSettings(non_primary_root)->display_id =
       old_primary_display.id();
 
   primary_display_id = new_primary_display.id();
   GetDisplayManager()->layout_store()->UpdatePrimaryDisplayId(
       display_manager->GetCurrentDisplayIdPair(), primary_display_id);
 
   UpdateWorkAreaOfDisplayNearestWindow(
       primary_root, old_primary_display.GetWorkAreaInsets());
   UpdateWorkAreaOfDisplayNearestWindow(
       non_primary_root, new_primary_display.GetWorkAreaInsets());
 
   // Update the dispay manager with new display info.
-  std::vector<internal::DisplayInfo> display_info_list;
+  std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(display_manager->GetDisplayInfo(
       primary_display_id));
   display_info_list.push_back(display_manager->GetDisplayInfo(
       ScreenUtil::GetSecondaryDisplay().id()));
   GetDisplayManager()->set_force_bounds_changed(true);
   GetDisplayManager()->UpdateDisplays(display_info_list);
   GetDisplayManager()->set_force_bounds_changed(false);
 }
 
 void DisplayController::EnsurePointerInDisplays() {
   // If the mouse is currently on a display in native location,
   // use the same native location. Otherwise find the display closest
   // to the current cursor location in screen coordinates.
 
   gfx::Point point_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
   gfx::Point target_location_in_native;
   int64 closest_distance_squared = -1;
-  internal::DisplayManager* display_manager = GetDisplayManager();
+  DisplayManager* display_manager = GetDisplayManager();
 
   aura::Window* dst_root_window = NULL;
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const gfx::Display& display = display_manager->GetDisplayAt(i);
-    const internal::DisplayInfo display_info =
+    const DisplayInfo display_info =
         display_manager->GetDisplayInfo(display.id());
     aura::Window* root_window = GetRootWindowForDisplayId(display.id());
     if (display_info.bounds_in_native().Contains(
             cursor_location_in_native_coords_for_restore_)) {
       dst_root_window = root_window;
       target_location_in_native = cursor_location_in_native_coords_for_restore_;
       break;
     }
     gfx::Point center = display.bounds().CenterPoint();
     // Use the distance squared from the center of the dislay. This is not
@@ skipping 17 matching lines @@
   }
   dst_root_window->GetHost()->ConvertPointFromNativeScreen(
       &target_location_in_native);
   dst_root_window->MoveCursorTo(target_location_in_native);
 }
 
 bool DisplayController::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const aura::Window* root_window = window->GetRootWindow();
-  int64 id = internal::GetRootWindowSettings(root_window)->display_id;
+  int64 id = GetRootWindowSettings(root_window)->display_id;
   // if id is |kInvaildDisplayID|, it's being deleted.
   DCHECK(id != gfx::Display::kInvalidDisplayID);
   return GetDisplayManager()->UpdateWorkAreaOfDisplay(id, insets);
 }
 
 void DisplayController::OnDisplayBoundsChanged(const gfx::Display& display) {
-  const internal::DisplayInfo& display_info =
+  const DisplayInfo& display_info =
       GetDisplayManager()->GetDisplayInfo(display.id());
   DCHECK(!display_info.bounds_in_native().IsEmpty());
   aura::WindowTreeHost* host = root_windows_[display.id()]->GetHost();
   host->SetBounds(display_info.bounds_in_native());
   SetDisplayPropertiesOnHost(host, display);
 }
 
 void DisplayController::OnDisplayAdded(const gfx::Display& display) {
   if (primary_root_window_for_replace_) {
     DCHECK(root_windows_.empty());
     primary_display_id = display.id();
     root_windows_[display.id()] = primary_root_window_for_replace_;
-    internal::GetRootWindowSettings(primary_root_window_for_replace_)->
-        display_id = display.id();
+    GetRootWindowSettings(primary_root_window_for_replace_)->display_id =
+        display.id();
     primary_root_window_for_replace_ = NULL;
-    const internal::DisplayInfo& display_info =
+    const DisplayInfo& display_info =
         GetDisplayManager()->GetDisplayInfo(display.id());
     aura::WindowTreeHost* host = root_windows_[display.id()]->GetHost();
     host->SetBounds(display_info.bounds_in_native());
     SetDisplayPropertiesOnHost(host, display);
   } else {
     if (primary_display_id == gfx::Display::kInvalidDisplayID)
       primary_display_id = display.id();
     DCHECK(!root_windows_.empty());
     aura::WindowTreeHost* host = AddWindowTreeHostForDisplay(display);
-    internal::RootWindowController::CreateForSecondaryDisplay(host);
+    RootWindowController::CreateForSecondaryDisplay(host);
   }
 }
 
 void DisplayController::OnDisplayRemoved(const gfx::Display& display) {
   aura::Window* root_to_delete = root_windows_[display.id()];
   DCHECK(root_to_delete) << display.ToString();
 
   // Display for root window will be deleted when the Primary RootWindow
   // is deleted by the Shell.
   root_windows_.erase(display.id());
 
   // 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 (root_windows_.size() == 0) {
       primary_display_id = gfx::Display::kInvalidDisplayID;
       primary_root_window_for_replace_ = root_to_delete;
       return;
     }
     DCHECK_EQ(1U, root_windows_.size());
     primary_display_id = ScreenUtil::GetSecondaryDisplay().id();
     aura::Window* primary_root = root_to_delete;
 
     // Delete the other root instead.
     root_to_delete = root_windows_[primary_display_id];
-    internal::GetRootWindowSettings(root_to_delete)->display_id = display.id();
+    GetRootWindowSettings(root_to_delete)->display_id = display.id();
 
     // Setup primary root.
     root_windows_[primary_display_id] = primary_root;
-    internal::GetRootWindowSettings(primary_root)->display_id =
-        primary_display_id;
+    GetRootWindowSettings(primary_root)->display_id = primary_display_id;
 
     OnDisplayBoundsChanged(
         GetDisplayManager()->GetDisplayForId(primary_display_id));
   }
-  internal::RootWindowController* controller =
-      internal::GetRootWindowController(root_to_delete);
+  RootWindowController* controller = GetRootWindowController(root_to_delete);
   DCHECK(controller);
   controller->MoveWindowsTo(GetPrimaryRootWindow());
   // Delete most of root window related objects, but don't delete
   // root window itself yet because the stack may be using it.
   controller->Shutdown();
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
 }
 
 void DisplayController::OnHostResized(const aura::WindowTreeHost* host) {
   gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
       const_cast<aura::Window*>(host->window()));
 
-  internal::DisplayManager* display_manager = GetDisplayManager();
+  DisplayManager* display_manager = GetDisplayManager();
   if (display_manager->UpdateDisplayBounds(display.id(), host->GetBounds())) {
     mirror_window_controller_->UpdateWindow();
     cursor_window_controller_->UpdateContainer();
   }
 }
 
 void DisplayController::CreateOrUpdateNonDesktopDisplay(
-    const internal::DisplayInfo& info) {
+    const DisplayInfo& info) {
   switch (GetDisplayManager()->second_display_mode()) {
-    case internal::DisplayManager::MIRRORING:
+    case DisplayManager::MIRRORING:
       mirror_window_controller_->UpdateWindow(info);
       cursor_window_controller_->UpdateContainer();
       virtual_keyboard_window_controller_->Close();
       break;
-    case internal::DisplayManager::VIRTUAL_KEYBOARD:
+    case DisplayManager::VIRTUAL_KEYBOARD:
       mirror_window_controller_->Close();
       cursor_window_controller_->UpdateContainer();
       virtual_keyboard_window_controller_->UpdateWindow(info);
       break;
-    case internal::DisplayManager::EXTENDED:
+    case DisplayManager::EXTENDED:
       NOTREACHED();
   }
 }
 
 void DisplayController::CloseNonDesktopDisplay() {
   mirror_window_controller_->Close();
   cursor_window_controller_->UpdateContainer();
   virtual_keyboard_window_controller_->Close();
 }
 
@@ skipping 11 matching lines @@
   root_window->GetHost()->ConvertPointToNativeScreen(&point_in_screen);
   cursor_location_in_native_coords_for_restore_ = point_in_screen;
 }
 
 void DisplayController::PostDisplayConfigurationChange() {
   if (limiter_)
     limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
 
   focus_activation_store_->Restore();
 
-  internal::DisplayManager* display_manager = GetDisplayManager();
-  internal::DisplayLayoutStore* layout_store = display_manager->layout_store();
+  DisplayManager* display_manager = GetDisplayManager();
+  DisplayLayoutStore* layout_store = display_manager->layout_store();
   if (display_manager->num_connected_displays() > 1) {
     DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
     layout_store->UpdateMirrorStatus(pair, display_manager->IsMirrored());
     DisplayLayout layout = layout_store->GetRegisteredDisplayLayout(pair);
 
     if (Shell::GetScreen()->GetNumDisplays() > 1 ) {
       int64 primary_id = layout.primary_id;
       SetPrimaryDisplayId(
           primary_id == gfx::Display::kInvalidDisplayID ?
           pair.first : primary_id);
       // Update the primary_id in case the above call is
       // ignored. Happens when a) default layout's primary id
       // doesn't exist, or b) the primary_id has already been
       // set to the same and didn't update it.
       layout_store->UpdatePrimaryDisplayId(
           pair, Shell::GetScreen()->GetPrimaryDisplay().id());
     }
   }
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanged());
   UpdateHostWindowNames();
   EnsurePointerInDisplays();
 }
 
 aura::WindowTreeHost* DisplayController::AddWindowTreeHostForDisplay(
     const gfx::Display& display) {
   static int host_count = 0;
-  const internal::DisplayInfo& display_info =
+  const DisplayInfo& display_info =
       GetDisplayManager()->GetDisplayInfo(display.id());
   const gfx::Rect& bounds_in_native = display_info.bounds_in_native();
   aura::WindowTreeHost* host =
       Shell::GetInstance()->window_tree_host_factory()->CreateWindowTreeHost(
           bounds_in_native);
   host->window()->SetName(base::StringPrintf("RootWindow-%d", host_count++));
   host->compositor()->SetBackgroundColor(SK_ColorBLACK);
   // No need to remove our observer observer because the DisplayController
   // outlives the host.
   host->AddObserver(this);
-  internal::InitRootWindowSettings(host->window())->display_id = display.id();
+  InitRootWindowSettings(host->window())->display_id = display.id();
   host->InitHost();
 
   root_windows_[display.id()] = host->window();
   SetDisplayPropertiesOnHost(host, display);
 
 #if defined(OS_CHROMEOS)
   static bool force_constrain_pointer_to_root =
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshConstrainPointerToRoot);
   if (base::SysInfo::IsRunningOnChromeOS() || force_constrain_pointer_to_root)
@@ skipping 20 matching lines @@
     std::string name =
         root_windows[i] == primary ? "aura_root_0" : "aura_root_x";
     gfx::AcceleratedWidget xwindow =
         root_windows[i]->GetHost()->GetAcceleratedWidget();
     XStoreName(gfx::GetXDisplay(), xwindow, name.c_str());
   }
 #endif
 }
 
 }  // namespace ash