Make GetRootWindow() return a Window instead of a RootWindow.

ash/wm/header_painter.cc

 // Copyright 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 "ash/wm/header_painter.h"
 
 #include <vector>
 
 #include "ash/ash_constants.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/caption_buttons/frame_caption_button_container_view.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/logging.h"  // DCHECK
 #include "grit/ash_resources.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
-#include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/screen.h"
@@ skipping 129 matching lines @@
   return window &&
       window->type() == aura::client::WINDOW_TYPE_NORMAL &&
       window->layer() &&
       window->layer()->type() != ui::LAYER_NOT_DRAWN &&
       window->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_NONE &&
       !window->GetProperty(ash::kConstrainedWindowKey);
 }
 
 // Returns a list of windows in |root_window|| that potentially could have
 // a transparent solo-window header.
-std::vector<Window*> GetWindowsForSoloHeaderUpdate(RootWindow* root_window) {
+std::vector<Window*> GetWindowsForSoloHeaderUpdate(Window* root_window) {
   std::vector<Window*> windows;
   // Avoid memory allocations for typical window counts.
   windows.reserve(16);
   // Collect windows from the desktop.
   Window* desktop = ash::Shell::GetContainer(
       root_window, ash::internal::kShellWindowId_DefaultContainer);
   windows.insert(windows.end(),
                  desktop->children().begin(),
                  desktop->children().end());
   // Collect "always on top" windows.
@@ skipping 81 matching lines @@
   // Solo-window header updates are handled by the WorkspaceLayoutManager when
   // this window is added to the desktop.
 }
 
 // static
 void HeaderPainter::SetSoloWindowHeadersEnabled(bool enabled) {
   solo_window_header_enabled = enabled;
 }
 
 // static
-void HeaderPainter::UpdateSoloWindowHeader(RootWindow* root_window) {
+void HeaderPainter::UpdateSoloWindowHeader(Window* root_window) {
   // Use a separate function here so callers outside of HeaderPainter don't need
   // to know about "ignorable_window".
   UpdateSoloWindowInRoot(root_window, NULL /* ignorable_window */);
 }
 
 // static
 gfx::Rect HeaderPainter::GetBoundsForClientView(
     int header_height,
     const gfx::Rect& window_bounds) {
   gfx::Rect client_bounds(window_bounds);
@@ skipping 395 matching lines @@
     return kActiveWindowOpacity;
   return kInactiveWindowOpacity;
 }
 
 bool HeaderPainter::UseSoloWindowHeader() const {
   if (!solo_window_header_enabled)
     return false;
   // Don't use transparent headers for panels, pop-ups, etc.
   if (!IsSoloWindowHeaderCandidate(window_))
     return false;
-  aura::RootWindow* root = window_->GetRootWindow();
+  aura::Window* root = window_->GetRootWindow();
   // Don't recompute every time, as it would require many window property
   // lookups.
   return internal::GetRootWindowSettings(root)->solo_window_header;
 }
 
 // static
-bool HeaderPainter::UseSoloWindowHeaderInRoot(RootWindow* root_window,
-                                             Window* ignore_window) {
+bool HeaderPainter::UseSoloWindowHeaderInRoot(Window* root_window,
+                                              Window* ignore_window) {
   int visible_window_count = 0;
   std::vector<Window*> windows = GetWindowsForSoloHeaderUpdate(root_window);
   for (std::vector<Window*>::const_iterator it = windows.begin();
        it != windows.end();
        ++it) {
     Window* window = *it;
     // Various sorts of windows "don't count" for this computation.
     if (ignore_window == window ||
         !IsSoloWindowHeaderCandidate(window) ||
         !IsVisibleToRoot(window))
       continue;
     if (wm::GetWindowState(window)->IsMaximized())
       return false;
     ++visible_window_count;
     if (visible_window_count > 1)
       return false;
   }
   // Count must be tested because all windows might be "don't count" windows
   // in the loop above.
   return visible_window_count == 1;
 }
 
 // static
-void HeaderPainter::UpdateSoloWindowInRoot(RootWindow* root,
-                                          Window* ignore_window) {
+void HeaderPainter::UpdateSoloWindowInRoot(Window* root,
+                                           Window* ignore_window) {
 #if defined(OS_WIN)
   // Non-Ash Windows doesn't do solo-window counting for transparency effects,
   // as the desktop background and window frames are managed by the OS.
   if (!ash::Shell::HasInstance())
     return;
 #endif
   if (!root)
     return;
   internal::RootWindowSettings* root_window_settings =
       internal::GetRootWindowSettings(root);
@@ skipping 30 matching lines @@
   // icon. Don't use |window_icon_| for this computation as it may be NULL.
   int title_y = GetCaptionButtonContainerCenterY() - title_font.GetHeight() / 2;
   return gfx::Rect(
       title_x,
       std::max(0, title_y),
       std::max(0, caption_button_container_->x() - kTitleLogoSpacing - title_x),
       title_font.GetHeight());
 }
 
 }  // namespace ash