Move GetRootWindowController() to root_window_controller.h

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>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/root_window_transformers.h"
 #include "ash/host/root_window_host_factory.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
-#include "ash/wm/property_util.h"
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "third_party/skia/include/utils/SkMatrix44.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_transformer.h"
@@ skipping 220 matching lines @@
   primary_display_for_shutdown = new gfx::Display(
       GetDisplayManager()->GetDisplayForId(primary_display_id));
   num_displays_for_shutdown = GetDisplayManager()->GetNumDisplays();
 
   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::RootWindow*>::const_reverse_iterator it =
            root_windows_.rbegin(); it != root_windows_.rend(); ++it) {
     internal::RootWindowController* controller =
-        GetRootWindowController(it->second);
+        internal::GetRootWindowController(it->second);
     DCHECK(controller);
     delete controller;
   }
 }
 
 // static
 const gfx::Display& DisplayController::GetPrimaryDisplay() {
   DCHECK_NE(primary_display_id, gfx::Display::kInvalidDisplayID);
   if (primary_display_for_shutdown)
     return *primary_display_for_shutdown;
@@ skipping 41 matching lines @@
 
 aura::RootWindow* DisplayController::GetRootWindowForDisplayId(int64 id) {
   return root_windows_[id];
 }
 
 void DisplayController::CloseChildWindows() {
   for (std::map<int64, aura::RootWindow*>::const_iterator it =
            root_windows_.begin(); it != root_windows_.end(); ++it) {
     aura::RootWindow* root_window = it->second;
     internal::RootWindowController* controller =
-        GetRootWindowController(root_window);
+        internal::GetRootWindowController(root_window);
     if (controller) {
       controller->CloseChildWindows();
     } else {
       while (!root_window->children().empty()) {
         aura::Window* child = root_window->children()[0];
         delete child;
       }
     }
   }
 }
 
 std::vector<aura::RootWindow*> DisplayController::GetAllRootWindows() {
   std::vector<aura::RootWindow*> windows;
   for (std::map<int64, aura::RootWindow*>::const_iterator it =
            root_windows_.begin(); it != root_windows_.end(); ++it) {
     DCHECK(it->second);
-    if (GetRootWindowController(it->second))
+    if (internal::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*>
 DisplayController::GetAllRootWindowControllers() {
   std::vector<internal::RootWindowController*> controllers;
   for (std::map<int64, aura::RootWindow*>::const_iterator it =
            root_windows_.begin(); it != root_windows_.end(); ++it) {
     internal::RootWindowController* controller =
-        GetRootWindowController(it->second);
+        internal::GetRootWindowController(it->second);
     if (controller)
       controllers.push_back(controller);
   }
   return controllers;
 }
 
 void DisplayController::SetLayoutForCurrentDisplays(
     const DisplayLayout& layout_relative_to_primary) {
   DCHECK_EQ(2U, GetDisplayManager()->GetNumDisplays());
   if (GetDisplayManager()->GetNumDisplays() < 2)
@@ skipping 303 matching lines @@
 
     // Setup primary root.
     root_windows_[primary_display_id] = primary_root;
     internal::GetRootWindowSettings(primary_root)->display_id =
         primary_display_id;
 
     OnDisplayBoundsChanged(
         GetDisplayManager()->GetDisplayForId(primary_display_id));
   }
   internal::RootWindowController* controller =
-      GetRootWindowController(root_to_delete);
+      internal::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::OnRootWindowHostResized(const aura::RootWindow* root) {
   internal::DisplayManager* display_manager = GetDisplayManager();
@@ skipping 123 matching lines @@
   for (size_t i = 0; i < root_windows.size(); ++i) {
     std::string name =
         root_windows[i] == primary ? "aura_root_0" : "aura_root_x";
     gfx::AcceleratedWidget xwindow = root_windows[i]->GetAcceleratedWidget();
     XStoreName(ui::GetXDisplay(), xwindow, name.c_str());
   }
 #endif
 }
 
 }  // namespace ash