Pass shelf instances, not root windows, for ash context menus.

chrome/browser/ui/ash/launcher/launcher_context_menu.cc

 // Copyright 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 "chrome/browser/ui/ash/launcher/launcher_context_menu.h"
 
 #include <string>
 
 #include "ash/desktop_background/user_wallpaper_delegate.h"
 #include "ash/metrics/user_metrics_recorder.h"
-#include "ash/root_window_controller.h"
 #include "ash/session/session_state_delegate.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_item_delegate.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/context_menu_matcher.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/fullscreen.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/ash/chrome_shell_delegate.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 #include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/common/context_menu_params.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 bool MenuItemHasLauncherContext(const extensions::MenuItem* item) {
   return item->contexts().Contains(extensions::MenuItem::LAUNCHER);
 }
 
+// Returns true if the user can modify the |shelf|'s auto-hide behavior.
+bool CanUserModifyShelfAutoHideBehavior(const Profile* profile) {
+  const std::string& pref = prefs::kShelfAutoHideBehaviorLocal;
+  return profile->GetPrefs()->FindPreference(pref)->IsUserModifiable();
+}
+
 }  // namespace
 
 LauncherContextMenu::LauncherContextMenu(ChromeLauncherController* controller,
                                          const ash::ShelfItem* item,
-                                         aura::Window* root_window)
+                                         ash::Shelf* shelf)
     : ui::SimpleMenuModel(nullptr),
       controller_(controller),
       item_(item ? *item : ash::ShelfItem()),
-      shelf_alignment_menu_(root_window),
-      root_window_(root_window) {
-  DCHECK(root_window_);
+      shelf_alignment_menu_(shelf),
+      shelf_(shelf) {
+  DCHECK(shelf_);
   Init();
 }
 
 void LauncherContextMenu::Init() {
   set_delegate(this);
 
-  if (is_valid_item()) {
+  if (item_.id != 0) {
     extension_items_.reset(new extensions::ContextMenuMatcher(
         controller_->profile(), this, this,
         base::Bind(MenuItemHasLauncherContext)));
     if (item_.type == ash::TYPE_APP_SHORTCUT ||
         item_.type == ash::TYPE_WINDOWED_APP) {
       // V1 apps can be started from the menu - but V2 apps should not.
       if (!controller_->IsPlatformApp(item_.id)) {
         AddItem(MENU_OPEN_NEW, base::string16());
         AddSeparator(ui::NORMAL_SEPARATOR);
       }
@@ skipping 77 matching lines @@
                                                &index,
                                                false);  // is_action_menu
         AddSeparator(ui::NORMAL_SEPARATOR);
       }
     }
   }
   // In fullscreen, the launcher is either hidden or autohidden depending on the
   // type of fullscreen. Do not show the auto-hide menu item while in fullscreen
   // because it is confusing when the preference appears not to apply.
   if (!IsFullScreenMode() &&
-      controller_->CanUserModifyShelfAutoHideBehavior(root_window_)) {
+      CanUserModifyShelfAutoHideBehavior(controller_->profile())) {
     AddCheckItemWithStringId(MENU_AUTO_HIDE,
                              IDS_ASH_SHELF_CONTEXT_MENU_AUTO_HIDE);
   }
   if (ash::ShelfWidget::ShelfAlignmentAllowed() &&
       !ash::Shell::GetInstance()->session_state_delegate()->IsScreenLocked()) {
     AddSubMenuWithStringId(MENU_ALIGNMENT_MENU,
                            IDS_ASH_SHELF_CONTEXT_MENU_POSITION,
                            &shelf_alignment_menu_);
   }
   if (!controller_->IsLoggedInAsGuest()) {
@@ skipping 38 matching lines @@
     case LAUNCH_TYPE_REGULAR_TAB:
       return controller_->GetLaunchType(item_.id) ==
           extensions::LAUNCH_TYPE_REGULAR;
     case LAUNCH_TYPE_WINDOW:
       return controller_->GetLaunchType(item_.id) ==
           extensions::LAUNCH_TYPE_WINDOW;
     case LAUNCH_TYPE_FULLSCREEN:
       return controller_->GetLaunchType(item_.id) ==
           extensions::LAUNCH_TYPE_FULLSCREEN;
     case MENU_AUTO_HIDE:
-      return controller_->GetShelfAutoHideBehavior(root_window_) ==
-          ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
+      return shelf_->GetAutoHideBehavior() ==
+             ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
     default:
       if (command_id < MENU_ITEM_COUNT)
         return false;
       return (extension_items_ &&
               extension_items_->IsCommandIdChecked(command_id));
   }
 }
 
 bool LauncherContextMenu::IsCommandIdEnabled(int command_id) const {
   switch (command_id) {
     case MENU_PIN:
       return controller_->IsPinnable(item_.id);
     case MENU_CHANGE_WALLPAPER:
       return ash::Shell::GetInstance()->user_wallpaper_delegate()->
           CanOpenSetWallpaperPage();
     case MENU_NEW_WINDOW:
       // "Normal" windows are not allowed when incognito is enforced.
       return IncognitoModePrefs::GetAvailability(
           controller_->profile()->GetPrefs()) != IncognitoModePrefs::FORCED;
     case MENU_AUTO_HIDE:
-      return controller_->CanUserModifyShelfAutoHideBehavior(root_window_);
+      return CanUserModifyShelfAutoHideBehavior(controller_->profile());
     case MENU_NEW_INCOGNITO_WINDOW:
       // Incognito windows are not allowed when incognito is disabled.
       return IncognitoModePrefs::GetAvailability(
           controller_->profile()->GetPrefs()) != IncognitoModePrefs::DISABLED;
     default:
       if (command_id < MENU_ITEM_COUNT)
         return true;
       return (extension_items_ &&
               extension_items_->IsCommandIdEnabled(command_id));
   }
@@ skipping 44 matching lines @@
                           ? extensions::LAUNCH_TYPE_REGULAR
                           : extensions::LAUNCH_TYPE_WINDOW;
       }
       controller_->SetLaunchType(item_.id, launch_type);
       break;
     }
     case LAUNCH_TYPE_FULLSCREEN:
       controller_->SetLaunchType(item_.id, extensions::LAUNCH_TYPE_FULLSCREEN);
       break;
     case MENU_AUTO_HIDE:
-      controller_->ToggleShelfAutoHideBehavior(root_window_);
+      shelf_->SetAutoHideBehavior(shelf_->GetAutoHideBehavior() ==
+                                          ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS
+                                      ? ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER
+                                      : ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
       break;
     case MENU_NEW_WINDOW:
       controller_->CreateNewWindow();
       break;
     case MENU_NEW_INCOGNITO_WINDOW:
       controller_->CreateNewIncognitoWindow();
       break;
     case MENU_ALIGNMENT_MENU:
       break;
     case MENU_CHANGE_WALLPAPER:
       ash::Shell::GetInstance()->user_wallpaper_delegate()->
           OpenSetWallpaperPage();
       break;
     default:
       if (extension_items_) {
         extension_items_->ExecuteCommand(command_id, nullptr, nullptr,
                                          content::ContextMenuParams());
       }
   }
 }