Add differentiation between owner only and common flags on ChromeOS.

chrome/browser/about_flags.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/about_flags.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 67 matching lines @@
 void AddOsStrings(unsigned bitmask, ListValue* list) {
   struct {
     unsigned bit;
     const char* const name;
   } kBitsToOs[] = {
     {kOsMac, "Mac"},
     {kOsWin, "Windows"},
     {kOsLinux, "Linux"},
     {kOsCrOS, "Chrome OS"},
     {kOsAndroid, "Android"},
+    {kOsCrOSOwnerOnly, "Chrome OS (owner only)"},
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kBitsToOs); ++i)
     if (bitmask & kBitsToOs[i].bit)
       list->Append(new StringValue(kBitsToOs[i].name));
 }
 
 const Experiment::Choice kOmniboxHistoryQuickProviderNewScoringChoices[] = {
   { IDS_FLAGS_OMNIBOX_HISTORY_QUICK_PROVIDER_NEW_SCORING_AUTOMATIC, "", "" },
   { IDS_FLAGS_OMNIBOX_HISTORY_QUICK_PROVIDER_NEW_SCORING_ENABLED,
     switches::kOmniboxHistoryQuickProviderNewScoring,
@@ skipping 202 matching lines @@
     IDS_FLAGS_FORCE_COMPOSITING_MODE_NAME,
     IDS_FLAGS_FORCE_COMPOSITING_MODE_DESCRIPTION,
     kOsMac | kOsWin | kOsLinux,
     ENABLE_DISABLE_VALUE_TYPE(switches::kForceCompositingMode,
                               switches::kDisableForceCompositingMode)
   },
   {
     "threaded-compositing-mode",
     IDS_FLAGS_THREADED_COMPOSITING_MODE_NAME,
     IDS_FLAGS_THREADED_COMPOSITING_MODE_DESCRIPTION,
-    kOsDesktop & ~kOsCrOS,
+    kOsMac | kOsWin | kOsLinux,
     ENABLE_DISABLE_VALUE_TYPE(switches::kEnableThreadedCompositing,
                               switches::kDisableThreadedCompositing)
   },
   {
     "force-accelerated-composited-scrolling",
      IDS_FLAGS_FORCE_ACCELERATED_OVERFLOW_SCROLL_MODE_NAME,
      IDS_FLAGS_FORCE_ACCELERATED_OVERFLOW_SCROLL_MODE_DESCRIPTION,
      kOsAll,
      ENABLE_DISABLE_VALUE_TYPE(switches::kEnableAcceleratedOverflowScroll,
                                switches::kDisableAcceleratedOverflowScroll)
@@ skipping 354 matching lines @@
     "enable-vp9-playback",
     IDS_FLAGS_ENABLE_VP9_PLAYBACK_NAME,
     IDS_FLAGS_ENABLE_VP9_PLAYBACK_DESCRIPTION,
     kOsDesktop,
     SINGLE_VALUE_TYPE(switches::kEnableVp9Playback)
   },
   {
     "enable-managed-users",
     IDS_FLAGS_ENABLE_LOCALLY_MANAGED_USERS_NAME,
     IDS_FLAGS_ENABLE_LOCALLY_MANAGED_USERS_DESCRIPTION,
-    kOsAll,
+    kOsMac | kOsWin | kOsLinux | kOsAndroid | kOsCrOSOwnerOnly,
     SINGLE_VALUE_TYPE(switches::kEnableManagedUsers)
   },
 #if defined(USE_ASH)
   {
     "ash-disable-auto-window-placement",
     IDS_FLAGS_ASH_AUTO_WINDOW_PLACEMENT_NAME,
     IDS_FLAGS_ASH_AUTO_WINDOW_PLACEMENT_DESCRIPTION,
     kOsWin | kOsLinux | kOsCrOS,
     SINGLE_VALUE_TYPE(ash::switches::kAshDisableAutoWindowPlacement)
   },
@@ skipping 254 matching lines @@
     IDS_FLAGS_ENABLE_APP_LIST_SHOW_APPS_ONLY_DESCRIPTION,
     kOsAll,
     SINGLE_VALUE_TYPE(app_list::switches::kAppListShowAppsOnly),
   },
 #endif  // defined(USE_ASH)
 #if defined(OS_CHROMEOS)
   {
     "disable-boot-animation",
     IDS_FLAGS_DISABLE_BOOT_ANIMATION,
     IDS_FLAGS_DISABLE_BOOT_ANIMATION_DESCRIPTION,
-    kOsCrOS,
+    kOsCrOSOwnerOnly,
     SINGLE_VALUE_TYPE(switches::kDisableBootAnimation),
   },
   {
     "disable-boot-animation2",
     IDS_FLAGS_DISABLE_BOOT_ANIMATION2,
     IDS_FLAGS_DISABLE_BOOT_ANIMATION2_DESCRIPTION,
-    kOsCrOS,
+    kOsCrOSOwnerOnly,
     SINGLE_VALUE_TYPE(ash::switches::kAshDisableBootAnimation2),
   },
   {
     "boot-animation-fucntion",
     IDS_FLAGS_ASH_BOOT_ANIMATION_FUNCTION,
     IDS_FLAGS_ASH_BOOT_ANIMATION_FUNCTION_DESCRIPTION,
-    kOsCrOS,
+    kOsCrOSOwnerOnly,
     MULTI_VALUE_TYPE(kAshBootAnimationFunction),
   },
   {
     "captive-portal-detector",
     IDS_FLAGS_CAPTIVE_PORTAL_DETECTOR_NAME,
     IDS_FLAGS_CAPTIVE_PORTAL_DETECTOR_DESCRIPTION,
-    kOsCrOS,
+    kOsCrOSOwnerOnly,
     MULTI_VALUE_TYPE(kChromeCaptivePortalDetectionChoices),
   },
   {
     "disable-new-lock-animations",
     IDS_FLAGS_ASH_NEW_LOCK_ANIMATIONS,
     IDS_FLAGS_ASH_NEW_LOCK_ANIMATIONS_DESCRIPTION,
     kOsCrOS,
     SINGLE_VALUE_TYPE(ash::switches::kAshDisableNewLockAnimations),
   },
   {
     "file-manager-packaged",
     IDS_FLAGS_FILE_MANAGER_PACKAGED_NAME,
     IDS_FLAGS_FILE_MANAGER_PACKAGED_DESCRIPTION,
     kOsCrOS,
     SINGLE_VALUE_TYPE(switches::kFileManagerPackaged),
   },
   {
     "disable-launcher-per-display",
     IDS_FLAGS_DISABLE_LAUNCHER_PER_DISPLAY_NAME,
     IDS_FLAGS_DISABLE_LAUNCHER_PER_DISPLAY_DESCRIPTION,
     kOsCrOS,
     SINGLE_VALUE_TYPE(ash::switches::kAshDisableLauncherPerDisplay),
   },
   {
     "disable-app-mode",
     IDS_FLAGS_DISABLE_KIOSK_APPS_NAME,
     IDS_FLAGS_DISABLE_KIOSK_APPS_DESCRIPTION,
-    kOsCrOS,
+    kOsCrOSOwnerOnly,
     SINGLE_VALUE_TYPE(switches::kDisableAppMode),
   },
   {
     "disable-force-fullscreen-app",
     IDS_FLAGS_DISABLE_FULLSCREEN_APP_NAME,
     IDS_FLAGS_DISABLE_FULLSCREEN_APP_DESCRIPTION,
     kOsCrOS,
     SINGLE_VALUE_TYPE(switches::kDisableFullscreenApp),
   },
 #endif  // defined(OS_CHROMEOS)
@@ skipping 379 matching lines @@
 // Variant of GetSanitizedEnabledFlags that also removes any flags that aren't
 // enabled on the current platform.
 void GetSanitizedEnabledFlagsForCurrentPlatform(
     PrefService* prefs, std::set<std::string>* result) {
   GetSanitizedEnabledFlags(prefs, result);
 
   // Filter out any experiments that aren't enabled on the current platform.  We
   // don't remove these from prefs else syncing to a platform with a different
   // set of experiments would be lossy.
   std::set<std::string> platform_experiments;
-  int current_platform = GetCurrentPlatform();
+  int current_platform = GetCurrentPlatform(true);
   for (size_t i = 0; i < num_experiments; ++i) {
     if (experiments[i].supported_platforms & current_platform)
       AddInternalName(experiments[i], &platform_experiments);
   }
 
   std::set<std::string> new_enabled_experiments;
   std::set_intersection(
       platform_experiments.begin(), platform_experiments.end(),
       result->begin(), result->end(),
       std::inserter(new_enabled_experiments, new_enabled_experiments.begin()));
@@ skipping 43 matching lines @@
   } else {
     description_id = choices[index].description_id;
   }
   return l10n_util::GetStringUTF16(description_id);
 }
 
 void ConvertFlagsToSwitches(PrefService* prefs, CommandLine* command_line) {
   FlagsState::GetInstance()->ConvertFlagsToSwitches(prefs, command_line);
 }
 
-ListValue* GetFlagsExperimentsData(PrefService* prefs) {
+ListValue* GetFlagsExperimentsData(PrefService* prefs, bool owner) {
   std::set<std::string> enabled_experiments;
   GetSanitizedEnabledFlags(prefs, &enabled_experiments);
 
-  int current_platform = GetCurrentPlatform();
+  int current_platform = GetCurrentPlatform(owner);
 
   ListValue* experiments_data = new ListValue();
   for (size_t i = 0; i < num_experiments; ++i) {
     const Experiment& experiment = experiments[i];
 
 #if defined(OS_ANDROID)
     // Special case enable-spdy-proxy-auth, because it should only
     // be available on Dev and Beta channels.
     if (!strcmp("enable-spdy-proxy-auth", experiment.internal_name) &&
         chrome::VersionInfo::GetChannel() ==
@@ skipping 45 matching lines @@
 
 void RemoveFlagsSwitches(
     std::map<std::string, CommandLine::StringType>* switch_list) {
   FlagsState::GetInstance()->RemoveFlagsSwitches(switch_list);
 }
 
 void ResetAllFlags(PrefService* prefs) {
   FlagsState::GetInstance()->ResetAllFlags(prefs);
 }
 
-int GetCurrentPlatform() {
+int GetCurrentPlatform(bool owner) {
 #if defined(OS_MACOSX)
   return kOsMac;
 #elif defined(OS_WIN)
   return kOsWin;
 #elif defined(OS_CHROMEOS)  // Needs to be before the OS_LINUX check.
-  return kOsCrOS;
+  return kOsCrOS | (owner ? kOsCrOSOwnerOnly : 0);
 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
   return kOsLinux;
 #elif defined(OS_ANDROID)
   return kOsAndroid;
 #else
 #error Unknown platform
 #endif
 }
 
 void RecordUMAStatistics(const PrefService* prefs) {
@@ skipping 196 matching lines @@
 }
 
 const Experiment* GetExperiments(size_t* count) {
   *count = num_experiments;
   return experiments;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags