Add new flag for consistent identity.

components/signin/core/common/profile_management_switches.cc

 // Copyright 2014 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 "components/signin/core/common/profile_management_switches.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "components/signin/core/common/signin_switches.h"
 
 namespace {
 
 const char kNewProfileManagementFieldTrialName[] = "NewProfileManagement";
 
-bool CheckProfileManagementFlag(std::string command_switch, bool active_state) {
+// Different state of new profile management/identity consistency.  The code
+// below assumes the order of the values in this enum.  That is, new profile
+// management is included in consistent identity.
+enum State {
+  STATE_NONE,
+  STATE_NEW_PROFILE_MANAGEMENT,
+  STATE_CONSISTENT_IDENTITY
+};
+
+State GetProcessState() {
+  // Get the full name of the field trial so that the underlying mechanism
+  // is properly initialize.
+  std::string trial_type =
+      base::FieldTrialList::FindFullName(kNewProfileManagementFieldTrialName);
+
+  // Find the state of both command line args.
+  bool is_new_profile_management =
+      CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kNewProfileManagement);
+  bool is_consistent_identity =
+      CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kConsistentIdentity);
+
+  State state = STATE_NONE;
+
+  // If both command line args are set,  disable the field trial completely
+  // since the assigned group is undefined.  Otherwise use the state of the
+  // command line flag specified.  If neither command line arg is specified,
+  // see if the group was set from the server.
+  if (is_new_profile_management && is_consistent_identity) {
+    base::FieldTrial* field_trial =
+        base::FieldTrialList::Find(kNewProfileManagementFieldTrialName);
+    if (field_trial)
+      field_trial->Disable();
+  } else if (is_new_profile_management) {
+    return STATE_NEW_PROFILE_MANAGEMENT;
+  } else if (is_consistent_identity) {
+    return STATE_CONSISTENT_IDENTITY;
+  }
+
+  if (state == STATE_NONE && !trial_type.empty()) {
+    if (trial_type == "Enabled") {
+      state = STATE_NEW_PROFILE_MANAGEMENT;
+    } else if (trial_type == "ConsistentIdentity") {
+      state = STATE_CONSISTENT_IDENTITY;
+    }
+  }
+
+  return state;
+}
+
+bool CheckFlag(std::string command_switch, State max_state, bool active_state) {

[guohui, 2014/05/28 18:27:23]

as discussed offline, this should be the min_state instead, and at line 74 it
should check state >= min_state. Otherwise when consistent identity is on, all
new profile management features would be turned off.

[Roger Tawa OOO till Jul 10th, 2014/05/29 01:23:12]

Yeah, not sure how I reversed the condition.  At the same time I simplified this
function by removing active_state arg.  This was only needed to handle
IsEnableWebBasedSignin() which is a slightly special case. but instead handled
it there.

   // Individiual flag settings take precedence.
   if (CommandLine::ForCurrentProcess()->HasSwitch(command_switch)) {
     return true;
   }
 
-  // --new-profile-management flag always affects all switches.
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-        switches::kNewProfileManagement)) {
-    return active_state;
-  }
-
-  // NewProfileManagement experiment acts like above flag.
-  std::string trial_type =
-      base::FieldTrialList::FindFullName(kNewProfileManagementFieldTrialName);
-  if (!trial_type.empty()) {
-    if (trial_type == "Enabled")
-      return active_state;
-    if (trial_type == "Disabled")
-      return !active_state;
-  }
-
-  return false;
+  State state = GetProcessState();
+  return  state == STATE_NONE
+      ? false : (state <= max_state ? active_state : !active_state);
 }
 
 }  // namespace
 
 namespace switches {
 
+bool IsConsistentIdentity() {
+  return GetProcessState() >= STATE_CONSISTENT_IDENTITY;
+}
+
 bool IsEnableWebBasedSignin() {
-  return CheckProfileManagementFlag(switches::kEnableWebBasedSignin, false);
+  return CheckFlag(switches::kEnableWebBasedSignin,
+                   STATE_NEW_PROFILE_MANAGEMENT,
+                   false);
 }
 
 bool IsExtensionsMultiAccount() {
-  return CheckProfileManagementFlag(switches::kExtensionsMultiAccount, true);
+  return CheckFlag(switches::kExtensionsMultiAccount,
+                   STATE_NEW_PROFILE_MANAGEMENT,
+                   true);
 }
 
 bool IsFastUserSwitching() {
   bool use_mirror_promo_menu =
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kNewAvatarMenu) &&
       !IsNewProfileManagement();
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kFastUserSwitching) || use_mirror_promo_menu;
 }
 
 bool IsGoogleProfileInfo() {
-  return CheckProfileManagementFlag(switches::kGoogleProfileInfo, true);
+  return CheckFlag(switches::kGoogleProfileInfo,
+                   STATE_NEW_PROFILE_MANAGEMENT,
+                   true);
 }
 
 bool IsNewAvatarMenu() {
   bool is_new_avatar_menu =
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kNewAvatarMenu);
   return is_new_avatar_menu || IsNewProfileManagement();
 }
 
 bool IsNewProfileManagement() {
-  return CheckProfileManagementFlag(switches::kNewProfileManagement, true);
+  return GetProcessState() >= STATE_NEW_PROFILE_MANAGEMENT;
 }
 
 bool IsNewProfileManagementPreviewEnabled() {
   bool is_new_avatar_menu =
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kNewAvatarMenu);
   return is_new_avatar_menu && IsNewProfileManagement();
 }
 
 }  // namespace switches