Add policy for ash launcher auto-hide behavior

chrome/browser/ui/ash/launcher/chrome_launcher_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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <vector>
 
 #include "ash/launcher/launcher_model.h"
 #include "ash/shell.h"
@@ skipping 108 matching lines @@
 
 // If the value of the pref at |local_path is not empty, it is returned
 // otherwise the value of the pref at |synced_path| is returned.
 std::string GetLocalOrRemotePref(PrefService* pref_service,
                                  const char* local_path,
                                  const char* synced_path) {
   const std::string value(pref_service->GetString(local_path));
   return value.empty() ? pref_service->GetString(synced_path) : value;
 }
 
-// If prefs have synced and the pref value at |local_path| is empty the value
+// If prefs have synced and no user-set value exists at |local_path|, the value
 // from |synced_path| is copied to |local_path|.
 void MaybePropagatePrefToLocal(PrefService* pref_service,
                                const char* local_path,
                                const char* synced_path) {
-  if (pref_service->GetString(local_path).empty() &&
+  if (!pref_service->FindPreference(local_path)->HasUserSetting() &&

[sky, 2012/11/29 23:46:06]

I'm not familiar with HasUserSetting. How does this differ than the old code?

[bartfab (slow), 2012/11/30 11:55:47]

A quick bit of context: There are multiple sources of pref settings with
precedence increasing as: default, recommended, user, mandatory. Before policies
were added to the game here, the pref at |local_path| could either have a
default value (which is empty) or be user-set to some other value (which is
non-empty). So the current code worked as expected.

Now that policy can be used to control |local_path|, a non-empty pref value no
means that the user set a value. It could be coming from one of the other
sources, e.g. recommended or mandatory policy. The HasUserSetting() call does
what it says on the tin, it checks whether there actually is a user-set value or
not.

And a final bit of context: If there is no user-set value, line 138 will copy a
value from |synced_path| to |local_path|. If mandatory policy is in effect, it
will still continue to take precedence and the value just copied will be ignored
for now. But if policies goes away at any time (and it can, the admin can change
policy), the value will come into effect. So it is important to copy the value,
even if it should be currently overridden by policy.

       pref_service->IsSyncing()) {
     // First time the user is using this machine, propagate from remote to
     // local.
     pref_service->SetString(local_path, pref_service->GetString(synced_path));
   }
 }
 
 }  // namespace
 
 // ChromeLauncherController ----------------------------------------------------
@@ skipping 24 matching lines @@
   app_icon_loader_.reset(new LauncherAppIconLoader(profile_, this));
 
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_EXTENSION_LOADED,
                               content::Source<Profile>(profile_));
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_EXTENSION_UNLOADED,
                               content::Source<Profile>(profile_));
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(prefs::kPinnedLauncherApps, this);
+  pref_change_registrar_.Add(prefs::kShelfAlignmentLocal, this);
+  pref_change_registrar_.Add(prefs::kShelfAutoHideBehaviorLocal, this);
 }
 
 ChromeLauncherController::~ChromeLauncherController() {
   // Reset the shell window controller here since it has a weak pointer to this.
   shell_window_controller_.reset();
 
   model_->RemoveObserver(this);
   for (IDToItemControllerMap::iterator i = id_to_item_controller_map_.begin();
        i != id_to_item_controller_map_.end(); ++i) {
     i->second->OnRemoved();
@@ skipping 35 matching lines @@
     updater.Get()->Clear();
   }
 
   UpdateAppLaunchersFromPref();
 
   // TODO(sky): update unit test so that this test isn't necessary.
   if (ash::Shell::HasInstance()) {
     SetShelfAutoHideBehaviorFromPrefs();
     SetShelfAlignmentFromPrefs();
     PrefService* prefs = profile_->GetPrefs();
     if (prefs->GetString(prefs::kShelfAlignmentLocal).empty() ||

[sky, 2012/11/29 23:46:06]

Does this need to be updated? Seems like at a minimum you can remove the
AddObserver because of 179/180 new.

[bartfab (slow), 2012/11/30 11:55:47]

Actually, prefs->AddObserver(this) is very misleading. The observer this adds
does not listen for pref changes but for sync status changes. And this is still
needed. What I should have updated is to switch from empty() to HasUserSetting()
- done now.

         prefs->GetString(prefs::kShelfAutoHideBehaviorLocal).empty()) {
       prefs->AddObserver(this);
     }
     ash::Shell::GetInstance()->AddShellObserver(this);
   }
 }
 
 ash::LauncherID ChromeLauncherController::CreateTabbedLauncherItem(
     LauncherItemController* controller,
     IncognitoState is_incognito,
@@ skipping 305 matching lines @@
 void ChromeLauncherController::CreateNewIncognitoWindow() {
   chrome::NewEmptyWindow(GetProfileForNewWindows()->GetOffTheRecordProfile());
 }
 
 bool ChromeLauncherController::CanPin() const {
   const PrefService::Preference* pref =
       profile_->GetPrefs()->FindPreference(prefs::kPinnedLauncherApps);
   return pref && pref->IsUserModifiable();
 }
 
-void ChromeLauncherController::SetAutoHideBehavior(
-    ash::ShelfAutoHideBehavior behavior,
+ash::ShelfAutoHideBehavior ChromeLauncherController::GetShelfAutoHideBehavior(
+    aura::RootWindow* root_window) const {
+  // TODO(oshima): Support multiple launchers.
+
+  // See comment in |kShelfAlignment| as to why we consider two prefs.
+  const std::string behavior_value(
+      GetLocalOrRemotePref(profile_->GetPrefs(),
+                           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 {
+  // TODO(oshima): Support multiple launchers.
+  return profile_->GetPrefs()->
+      FindPreference(prefs::kShelfAutoHideBehaviorLocal)->IsUserModifiable();
+}
+
+void ChromeLauncherController::ToggleShelfAutoHideBehavior(
     aura::RootWindow* root_window) {
-  ash::Shell::GetInstance()->SetShelfAutoHideBehavior(
-      behavior,
-      root_window);
-  // TODO(oshima): Support multiple launcher.
-  if (root_window != ash::Shell::GetPrimaryRootWindow())
-    return;
-
-  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;
-  }
-  // See comment in |kShelfAlignment| about why we have two prefs here.
-  profile_->GetPrefs()->SetString(prefs::kShelfAutoHideBehaviorLocal, value);
-  profile_->GetPrefs()->SetString(prefs::kShelfAutoHideBehavior, value);
+  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);
 }
 
 void ChromeLauncherController::RemoveTabFromRunningApp(
     TabContents* tab,
     const std::string& app_id) {
   tab_contents_to_app_id_.erase(tab);
   AppIDToTabContentsListMap::iterator i_app_id =
       app_id_to_tab_contents_list_.find(app_id);
   if (i_app_id != app_id_to_tab_contents_list_.end()) {
     TabContentsList* tab_list = &i_app_id->second;
@@ skipping 380 matching lines @@
       LauncherItemClosed(item.id);
     else
       ++index;
   }
 
   // Append unprocessed items from the pref to the end of the model.
   for (; pref_app_id != pinned_apps.end(); ++pref_app_id)
     DoPinAppWithID(*pref_app_id);
 }
 
+void ChromeLauncherController::SetShelfAutoHideBehaviorPrefs(
+    ash::ShelfAutoHideBehavior behavior,
+    aura::RootWindow* root_window) {
+  // TODO(oshima): Support multiple launchers.
+  if (root_window != ash::Shell::GetPrimaryRootWindow())
+    return;
+
+  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;
+  }
+  // See comment in |kShelfAlignment| about why we have two prefs here.
+  profile_->GetPrefs()->SetString(prefs::kShelfAutoHideBehaviorLocal, value);
+  profile_->GetPrefs()->SetString(prefs::kShelfAutoHideBehavior, value);
+}
+
 void ChromeLauncherController::SetShelfAutoHideBehaviorFromPrefs() {
-  // See comment in |kShelfAlignment| as to why we consider two prefs.
-  const std::string behavior_value(
-      GetLocalOrRemotePref(profile_->GetPrefs(),
-                           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://code.google.com/p/chromium/issues/detail?id=146773)
-  ash::ShelfAutoHideBehavior behavior =
-      ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER;
-  if (behavior_value == ash::kShelfAutoHideBehaviorAlways)
-    behavior = ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
   // TODO(oshima): Support multiple displays.
+  aura::RootWindow* root_window = ash::Shell::GetPrimaryRootWindow();
   ash::Shell::GetInstance()->SetShelfAutoHideBehavior(
-      behavior, ash::Shell::GetPrimaryRootWindow());
+      GetShelfAutoHideBehavior(root_window), root_window);
 }
 
 void ChromeLauncherController::SetShelfAlignmentFromPrefs() {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kShowLauncherAlignmentMenu))
     return;
 
   // See comment in |kShelfAlignment| as to why we consider two prefs.
   const std::string alignment_value(
       GetLocalOrRemotePref(profile_->GetPrefs(),
@@ skipping 62 matching lines @@
       new AppShortcutLauncherItemController(app_id, this);
   ash::LauncherID launcher_id = InsertAppLauncherItem(
       controller, app_id, ash::STATUS_CLOSED, index);
   return launcher_id;
 }
 
 bool ChromeLauncherController::HasItemController(ash::LauncherID id) const {
   return id_to_item_controller_map_.find(id) !=
          id_to_item_controller_map_.end();
 }