[Sync Promo UI] Changing sync promo to honor brand codes.

chrome/browser/ui/webui/sync_promo_trial.cc

 // Copyright (c) 2011 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/webui/sync_promo_trial.h"
 
 #include "base/metrics/field_trial.h"
+#include "base/string_util.h"
+#include "chrome/browser/google/google_util.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "grit/generated_resources.h"
 
 namespace sync_promo_trial {
 
 // Field trial IDs of the control and experiment groups. Though they are not
 // literally "const", they are set only once, in Activate() below. See the .h
 // file for what these groups represent.
 int g_sync_promo_experiment_a = 0;
 int g_sync_promo_experiment_b = 0;
 int g_sync_promo_experiment_c = 0;
 int g_sync_promo_experiment_d = 0;
 
+const char kSyncPromoEnabledTrialName[] = "SyncPromoEnabled";
 const char kSyncPromoMsgTrialName[] = "SyncPromoMsg";
 
+const char kSyncPromoEnabledWithApps[] = "EnabledWithDefaultApps";
+const char kSyncPromoEnabledWithoutApps[] = "EnabledWithoutDefaultApps";
+const char kSyncPromoDisabledWithApps[] = "DisabledWithDefaultApps";
+const char kSyncPromoDisabledWithoutApps[] = "DisabledWithoutDefaultApps";
+
 void Activate() {
   // The end date (February 21, 2012) is approximately 2 weeks into M17 stable.
   scoped_refptr<base::FieldTrial> trial(
       new base::FieldTrial(kSyncPromoMsgTrialName, 1000, "MsgA", 2012, 2, 21));
   g_sync_promo_experiment_a = base::FieldTrial::kDefaultGroupNumber;
 
   // Try to give the user a consistent experience, if possible.
   if (base::FieldTrialList::IsOneTimeRandomizationEnabled())
     trial->UseOneTimeRandomization();
 
   // Each group has probability 0.5%, leaving the control with 98.5%.
   g_sync_promo_experiment_b = trial->AppendGroup("MsgB", 50);
   g_sync_promo_experiment_c = trial->AppendGroup("MsgC", 50);
   g_sync_promo_experiment_d = trial->AppendGroup("MsgD", 50);
+
+  // Determine whether we should show the sync promo via brand code.
+  std::string brand;
+  google_util::GetBrand(&brand);
+
+  // Create a field trial based on the brand code.
+  if (LowerCaseEqualsASCII(brand, "ecba")) {
+    base::FieldTrialList::CreateFieldTrial(kSyncPromoEnabledTrialName,
+                                           kSyncPromoEnabledWithApps);
+  } else if (LowerCaseEqualsASCII(brand, "ecsa")) {
+    base::FieldTrialList::CreateFieldTrial(kSyncPromoEnabledTrialName,
+                                           kSyncPromoEnabledWithoutApps);
+  } else if (LowerCaseEqualsASCII(brand, "ecsb")) {
+    base::FieldTrialList::CreateFieldTrial(kSyncPromoEnabledTrialName,
+                                           kSyncPromoDisabledWithApps);
+  } else if (LowerCaseEqualsASCII(brand, "ecbb")) {
+    base::FieldTrialList::CreateFieldTrial(kSyncPromoEnabledTrialName,
+                                           kSyncPromoDisabledWithoutApps);
+  }

[Dan Beam, 2011/12/14 01:22:12]

By the way, the reason I'm not interlacing these with the default apps
conditionals is that I wanted them to be separate in the case that one
experiment goes longer than the other (so if this experiment happens to continue
into M17 for some reason or after the potential M16 refresh) the code is
decoupled so that this still acts normally if this method gets deleted -
http://codesearch.google.com/codesearch#OAMlx_jo-ck/src/chrome/browser/chrome...

 }
 
 bool IsExperimentActive() {
   return base::FieldTrialList::FindValue(kSyncPromoMsgTrialName) !=
       base::FieldTrial::kNotFinalized;
 }
 
+bool IsPartOfBrandTrialToEnable() {
+  return base::FieldTrialList::TrialExists(kSyncPromoEnabledTrialName);
+}
+
 Group GetGroup() {
   // Promo message A is also the default value, so display it if there is no
   // active experiment.
   if (!IsExperimentActive())
     return PROMO_MSG_A;
 
   const int group = base::FieldTrialList::FindValue(kSyncPromoMsgTrialName);
   if (group == g_sync_promo_experiment_a)
     return PROMO_MSG_A;
   else if (group == g_sync_promo_experiment_b)
     return PROMO_MSG_B;
   else if (group == g_sync_promo_experiment_c)
     return PROMO_MSG_C;
   else if (group == g_sync_promo_experiment_d)
     return PROMO_MSG_D;
 
   NOTREACHED();
   return PROMO_MSG_A;
 }
 
+int GetSyncPromoAndDefaultAppsCombination() {
+  // This should never happen, but it doesn't hurt to CHECK().
+  DCHECK(IsPartOfBrandTrialToEnable());
+
+  std::string group =
+      base::FieldTrialList::Find(kSyncPromoEnabledTrialName)->group_name();
+
+  if (group == kSyncPromoEnabledWithApps)
+    return WITH_SYNC_PROMO_WITH_DEFAULT_APPS;
+  else if (group == kSyncPromoEnabledWithoutApps)
+    return WITH_SYNC_PROMO_WITHOUT_DEFAULT_APPS;
+  else if (group == kSyncPromoDisabledWithApps)
+    return WITHOUT_SYNC_PROMO_WITH_DEFAULT_APPS;
+  else if (group == kSyncPromoDisabledWithoutApps)
+    return WITH_SYNC_PROMO_WITH_DEFAULT_APPS;
+
+  NOTREACHED();
+  return SYNC_PROMO_AND_DEFAULT_APPS_BOUNDARY + 1;
+}
+
 int GetMessageBodyResID() {
   // Note that GetGroup and the switch will take care of the !IsExperimentActive
   // case for us.
   Group group = GetGroup();
   switch (group) {
     case PROMO_MSG_A:
       return IDS_SYNC_PROMO_MESSAGE_BODY_A;
     case PROMO_MSG_B:
       return IDS_SYNC_PROMO_MESSAGE_BODY_B;
     case PROMO_MSG_C:
       return IDS_SYNC_PROMO_MESSAGE_BODY_C;
     case PROMO_MSG_D:
       return IDS_SYNC_PROMO_MESSAGE_BODY_D;
     case PROMO_MSG_MAX:
       break;
   }
 
   NOTREACHED();
   return IDS_SYNC_PROMO_MESSAGE_BODY_A;
 }
 
 void RecordUserSawMessage() {
   DCHECK(IsExperimentActive());
   UMA_HISTOGRAM_ENUMERATION("SyncPromo.MessageDisplayed",
                             GetGroup(),
                             PROMO_MSG_MAX);
 }
 
+void RecordUserShownPromoWithTrialBrand() {
+  DCHECK(IsPartOfBrandTrialToEnable());
+  UMA_HISTOGRAM_ENUMERATION("SyncPromo.ShownPromoWithBrand",
+                            GetSyncPromoAndDefaultAppsCombination(),
+                            SYNC_PROMO_AND_DEFAULT_APPS_BOUNDARY);
+}
+
 void RecordUserSignedIn() {
   DCHECK(IsExperimentActive());
   UMA_HISTOGRAM_ENUMERATION("SyncPromo.MessageOnSignIn",
                             GetGroup(),
                             PROMO_MSG_MAX);
 }
 
+void RecordUserSignedInWithTrialBrand() {
+  DCHECK(IsPartOfBrandTrialToEnable());
+  UMA_HISTOGRAM_ENUMERATION("SyncPromo.SignedInWithBrand",
+                            GetSyncPromoAndDefaultAppsCombination(),
+                            SYNC_PROMO_AND_DEFAULT_APPS_BOUNDARY);
+}
+
+bool ShouldShowAtStartupBasedOnBrand() {
+  DCHECK(IsPartOfBrandTrialToEnable());
+  std::string name =
+      base::FieldTrialList::Find(kSyncPromoEnabledTrialName)->group_name();
+  return name == kSyncPromoEnabledWithApps ||
+         name == kSyncPromoEnabledWithoutApps;
+}
+
 }  // namespace sync_promo_trial