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 68 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 220 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 378 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 262 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 420 matching lines @@
   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();
   for (size_t i = 0; i < num_experiments; ++i) {
     if (experiments[i].supported_platforms & current_platform)
       AddInternalName(experiments[i], &platform_experiments);
+#if defined(OS_CHROMEOS)
+    if (experiments[i].supported_platforms & kOsCrOSOwnerOnly)
+      AddInternalName(experiments[i], &platform_experiments);
+#endif
   }
 
   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()));
 
   result->swap(new_enabled_experiments);
 }
@@ skipping 40 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, FlagAccess access) {
   std::set<std::string> enabled_experiments;
   GetSanitizedEnabledFlags(prefs, &enabled_experiments);
 
   int current_platform = GetCurrentPlatform();
 
   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() ==
             chrome::VersionInfo::CHANNEL_STABLE)
       continue;
 #endif
 
     DictionaryValue* data = new DictionaryValue();
     data->SetString("internal_name", experiment.internal_name);
     data->SetString("name",
                     l10n_util::GetStringUTF16(experiment.visible_name_id));
     data->SetString("description",
                     l10n_util::GetStringUTF16(
                         experiment.visible_description_id));
-    bool supported = !!(experiment.supported_platforms & current_platform);
+    bool supported = (experiment.supported_platforms & current_platform) != 0;
+#if defined(OS_CHROMEOS)
+    if (access == kOwnerAccessToFlags &&
+        (experiment.supported_platforms & kOsCrOSOwnerOnly) != 0)
+      supported = true;
+#endif
     data->SetBoolean("supported", supported);
 
     ListValue* supported_platforms = new ListValue();
     AddOsStrings(experiment.supported_platforms, supported_platforms);
     data->Set("supported_platforms", supported_platforms);
 
     switch (experiment.type) {
       case Experiment::SINGLE_VALUE:
         data->SetBoolean(
             "enabled",
@@ skipping 246 matching lines @@
 }
 
 const Experiment* GetExperiments(size_t* count) {
   *count = num_experiments;
   return experiments;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags