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

chrome/browser/ui/ash/launcher/chrome_launcher_controller.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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/desktop_background_controller.h"
@@ skipping 84 matching lines @@
 // static
 ChromeLauncherController* ChromeLauncherController::instance_ = NULL;
 
 namespace {
 
 // This will be used as placeholder in the list of the pinned applciatons.
 // Note that this is NOT a valid extension identifier so that pre M31 versions
 // will ignore it.
 const char kAppLauncherIdPlaceholder[] = "AppLauncherIDPlaceholder--------";
 
-std::string GetPrefKeyForRootWindow(aura::RootWindow* root_window) {
+std::string GetPrefKeyForRootWindow(aura::Window* root_window) {
   gfx::Display display = gfx::Screen::GetScreenFor(
       root_window)->GetDisplayNearestWindow(root_window);
   DCHECK(display.is_valid());
 
   return base::Int64ToString(display.id());
 }
 
 void UpdatePerDisplayPref(PrefService* pref_service,
-                          aura::RootWindow* root_window,
+                          aura::Window* root_window,
                           const char* pref_key,
                           const std::string& value) {
   std::string key = GetPrefKeyForRootWindow(root_window);
   if (key.empty())
     return;
 
   DictionaryPrefUpdate update(pref_service, prefs::kShelfPreferences);
   base::DictionaryValue* shelf_prefs = update.Get();
   base::DictionaryValue* prefs = NULL;
   if (!shelf_prefs->GetDictionary(key, &prefs)) {
@@ skipping 12 matching lines @@
 //  * A user-set value for the specified display.
 //  * A user-set value in |local_path| or |path|, if no per-display settings are
 //    ever specified (see http://crbug.com/173719 for why). |local_path| is
 //    preferred. See comment in |kShelfAlignment| as to why we consider two
 //    prefs and why |local_path| is preferred.
 //  * A value recommended by policy. This is a single value that applies to all
 //    root windows.
 //  * The default value for |local_path| if the value is not recommended by
 //    policy.
 std::string GetPrefForRootWindow(PrefService* pref_service,
-                                 aura::RootWindow* root_window,
+                                 aura::Window* root_window,
                                  const char* local_path,
                                  const char* path) {
   const PrefService::Preference* local_pref =
       pref_service->FindPreference(local_path);
   const std::string value(pref_service->GetString(local_path));
   if (local_pref->IsManaged())
     return value;
 
   std::string pref_key = GetPrefKeyForRootWindow(root_window);
   bool has_per_display_prefs = false;
@@ skipping 506 matching lines @@
     if (index == -1)
       continue;
     ash::LauncherItem item = model_->items()[index];
     item.image = image;
     model_->Set(index, item);
     // It's possible we're waiting on more than one item, so don't break.
   }
 }
 
 void ChromeLauncherController::OnAutoHideBehaviorChanged(
-    aura::RootWindow* root_window,
+    aura::Window* root_window,
     ash::ShelfAutoHideBehavior new_behavior) {
   SetShelfAutoHideBehaviorPrefs(new_behavior, root_window);
 }
 
 void ChromeLauncherController::SetLauncherItemImage(
     ash::LauncherID launcher_id,
     const gfx::ImageSkia& image) {
   int index = model_->ItemIndexByID(launcher_id);
   if (index == -1)
     return;
@@ skipping 110 matching lines @@
 
 ash::LauncherModel* ChromeLauncherController::model() {
   return model_;
 }
 
 Profile* ChromeLauncherController::profile() {
   return profile_;
 }
 
 ash::ShelfAutoHideBehavior ChromeLauncherController::GetShelfAutoHideBehavior(
-    aura::RootWindow* root_window) const {
+    aura::Window* root_window) const {
   // Don't show the shelf in app mode.
   if (chrome::IsRunningInAppMode())
     return ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN;
 
   // See comment in |kShelfAlignment| as to why we consider two prefs.
   const std::string behavior_value(
       GetPrefForRootWindow(profile_->GetPrefs(),
                            root_window,
                            prefs::kShelfAutoHideBehaviorLocal,
                            prefs::kShelfAutoHideBehavior));
 
   // Note: To maintain sync compatibility with old images of chrome/chromeos
   // the set of values that may be encountered includes the now-extinct
   // "Default" as well as "Never" and "Always", "Default" should now
   // be treated as "Never" (http://crbug.com/146773).
   if (behavior_value == ash::kShelfAutoHideBehaviorAlways)
     return ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
   return ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER;
 }
 
 bool ChromeLauncherController::CanUserModifyShelfAutoHideBehavior(
-    aura::RootWindow* root_window) const {
+    aura::Window* root_window) const {
   return profile_->GetPrefs()->
       FindPreference(prefs::kShelfAutoHideBehaviorLocal)->IsUserModifiable();
 }
 
 void ChromeLauncherController::ToggleShelfAutoHideBehavior(
-    aura::RootWindow* root_window) {
+    aura::Window* root_window) {
   ash::ShelfAutoHideBehavior behavior = GetShelfAutoHideBehavior(root_window) ==
       ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS ?
           ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER :
           ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
   SetShelfAutoHideBehaviorPrefs(behavior, root_window);
   return;
 }
 
 void ChromeLauncherController::RemoveTabFromRunningApp(
     WebContents* tab,
@@ skipping 233 matching lines @@
         }
       }
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification type=" << type;
   }
 }
 
 void ChromeLauncherController::OnShelfAlignmentChanged(
-    aura::RootWindow* root_window) {
+    aura::Window* root_window) {
   const char* pref_value = NULL;
   switch (ash::Shell::GetInstance()->GetShelfAlignment(root_window)) {
     case ash::SHELF_ALIGNMENT_BOTTOM:
       pref_value = ash::kShelfAlignmentBottom;
       break;
     case ash::SHELF_ALIGNMENT_LEFT:
       pref_value = ash::kShelfAlignmentLeft;
       break;
     case ash::SHELF_ALIGNMENT_RIGHT:
       pref_value = ash::kShelfAlignmentRight;
@@ skipping 414 matching lines @@
     } else {
       int target_index = FindInsertionPoint(is_app_list);
       MoveChromeOrApplistToFinalPosition(
           is_chrome, is_app_list, target_index, &chrome_index, &app_list_index);
     }
   }
 }
 
 void ChromeLauncherController::SetShelfAutoHideBehaviorPrefs(
     ash::ShelfAutoHideBehavior behavior,
-    aura::RootWindow* root_window) {
+    aura::Window* root_window) {
   const char* value = NULL;
   switch (behavior) {
     case ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS:
       value = ash::kShelfAutoHideBehaviorAlways;
       break;
     case ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER:
       value = ash::kShelfAutoHideBehaviorNever;
       break;
     case ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN:
       // This one should not be a valid preference option for now. We only want
@@ skipping 413 matching lines @@
         }
       }
     }
   }
 
   // Finally we update the browser state itself.
   browser_status_monitor_->UpdateBrowserItemState();
 #endif
 }