NTP4/Sync Promo:

- rename sync promo -> NTP sign-in promo
- re-arrange UMA to correctly report stuff given new code path
- re-fix pane switcher issue.

R=sail@chromium.org,estade@chromium.org
TBR=mirandac@chromium.org
BUG=99540
TEST=Unit tests still pass, code still compiles, UMA gets reported, and pane switchers don't obscure.


Review URL: http://codereview.chromium.org/8363035

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@107517 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 135 insertions, 120 deletions

diff --git a/chrome/browser/resources/ntp4/new_tab.js b/chrome/browser/resources/ntp4/new_tab.js
index 32acde4..e85798c 100644
--- a/chrome/browser/resources/ntp4/new_tab.js
+++ b/chrome/browser/resources/ntp4/new_tab.js
@@ -928,8 +928,10 @@ cr.define('ntp4', function() {
       $('login-container').hidden = false;
       $('login-status-header').innerHTML = loginHeader;
       $('login-status-sub-header').innerHTML = loginSubHeader;
+      $('card-slider-frame').classList.add('showing-login-area');
     } else {
       $('login-container').hidden = true;
+      $('card-slider-frame').classList.remove('showing-login-area');
     }
   }
 
diff --git a/chrome/browser/resources/ntp4/new_tab_theme.css b/chrome/browser/resources/ntp4/new_tab_theme.css
index cedc6f6..06a8889 100644
--- a/chrome/browser/resources/ntp4/new_tab_theme.css
+++ b/chrome/browser/resources/ntp4/new_tab_theme.css
@@ -37,9 +37,9 @@ body {
 }
 
 /* Only change the background to a gradient when a promo is showing. */
-.showing-sync-promo #page-switcher-end:hover,
-.showing-sync-promo #page-switcher-end:focus,
-.showing-sync-promo #page-switcher-end.drag-target {
+.showing-login-area #page-switcher-end:hover,
+.showing-login-area #page-switcher-end:focus,
+.showing-login-area #page-switcher-end.drag-target {
   background:
       -webkit-linear-gradient(top, rgba($23, 0) 0,
                                    rgba($23, .01) 60px,
diff --git a/chrome/browser/ui/webui/ntp/ntp_login_handler.cc b/chrome/browser/ui/webui/ntp/ntp_login_handler.cc
index 2a46eb3..7d767c5 100644
--- a/chrome/browser/ui/webui/ntp/ntp_login_handler.cc
+++ b/chrome/browser/ui/webui/ntp/ntp_login_handler.cc
@@ -64,9 +64,6 @@ void NTPLoginHandler::Observe(int type,
 
 void NTPLoginHandler::HandleInitializeSyncLogin(const ListValue* args) {
   UpdateLogin();
-  UMA_HISTOGRAM_ENUMERATION("SyncPromo.NTPPromo",
-                            SYNC_PROMO_NTP_PROMO_VIEWED,
-                            SYNC_PROMO_NTP_PROMO_BUCKET_BOUNDARY);
 }
 
 void NTPLoginHandler::HandleShowSyncLoginUI(const ListValue* args) {
@@ -77,12 +74,10 @@ void NTPLoginHandler::HandleShowSyncLoginUI(const ListValue* args) {
   if (username.empty()) {
     // The user isn't signed in, show the sync promo.
     if (SyncPromoUI::ShouldShowSyncPromo(profile)) {
-      UMA_HISTOGRAM_ENUMERATION("SyncPromo.NTPPromo",
-                                SYNC_PROMO_NTP_PROMO_CLICKED,
-                                SYNC_PROMO_NTP_PROMO_BUCKET_BOUNDARY);
       web_ui_->tab_contents()->OpenURL(GURL(chrome::kChromeUISyncPromoURL),
                                        GURL(), CURRENT_TAB,
                                        content::PAGE_TRANSITION_LINK);
+      RecordInHistogram(NTP_SIGN_IN_PROMO_CLICKED);
     }
   } else if (args->GetSize() == 4) {
     // The user is signed in, show the profiles menu.
@@ -107,6 +102,17 @@ void NTPLoginHandler::HandleShowSyncLoginUI(const ListValue* args) {
   }
 }
 
+void NTPLoginHandler::RecordInHistogram(int type) {
+  // Invalid type to record.
+  if (type < NTP_SIGN_IN_PROMO_VIEWED ||
+      type > NTP_SIGN_IN_PROMO_CLICKED) {
+    NOTREACHED();
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("SyncPromo.NTPPromo", type,
+                              NTP_SIGN_IN_PROMO_BUCKET_BOUNDARY);
+  }
+}
+
 void NTPLoginHandler::UpdateLogin() {
   Profile* profile = Profile::FromWebUI(web_ui_);
   std::string username = profile->GetPrefs()->GetString(
@@ -116,7 +122,7 @@ void NTPLoginHandler::UpdateLogin() {
     header = UTF8ToUTF16(username);
   } else if (SyncPromoUI::ShouldShowSyncPromo(profile) &&
              (SyncPromoUI::UserHasSeenSyncPromoAtStartup(profile) ||
-              PromoResourceService::CanShowSyncPromo(profile))) {
+              PromoResourceService::CanShowNTPSignInPromo(profile))) {
     string16 signed_in_link = l10n_util::GetStringUTF16(
         IDS_SYNC_PROMO_NOT_SIGNED_IN_STATUS_LINK);
     signed_in_link = ASCIIToUTF16("<span class='link-span'>") + signed_in_link +
@@ -126,6 +132,8 @@ void NTPLoginHandler::UpdateLogin() {
         l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME));
     sub_header = l10n_util::GetStringFUTF16(
         IDS_SYNC_PROMO_NOT_SIGNED_IN_STATUS_SUB_HEADER, signed_in_link);
+    // Record that the user was shown the promo.
+    RecordInHistogram(NTP_SIGN_IN_PROMO_VIEWED);
   }
 
   StringValue header_value(header);
@@ -134,6 +142,7 @@ void NTPLoginHandler::UpdateLogin() {
       "updateLogin", header_value, sub_header_value);
 }
 
+// static
 bool NTPLoginHandler::ShouldShow(Profile* profile) {
 #if defined(OS_CHROMEOS)
   // For now we don't care about showing sync status on Chrome OS. The promo
diff --git a/chrome/browser/ui/webui/ntp/ntp_login_handler.h b/chrome/browser/ui/webui/ntp/ntp_login_handler.h
index 3169ba0..890a34c 100644
--- a/chrome/browser/ui/webui/ntp/ntp_login_handler.h
+++ b/chrome/browser/ui/webui/ntp/ntp_login_handler.h
@@ -38,10 +38,10 @@ class NTPLoginHandler : public WebUIMessageHandler,
 
  private:
   // User actions while on the NTP when clicking on or viewing the sync promo.
-  enum SyncPromoNTPPromoBuckets {
-    SYNC_PROMO_NTP_PROMO_VIEWED,
-    SYNC_PROMO_NTP_PROMO_CLICKED,
-    SYNC_PROMO_NTP_PROMO_BUCKET_BOUNDARY,
+  enum NTPSignInPromoBuckets {
+    NTP_SIGN_IN_PROMO_VIEWED,
+    NTP_SIGN_IN_PROMO_CLICKED,
+    NTP_SIGN_IN_PROMO_BUCKET_BOUNDARY,
   };
 
   // Called from JS when the NTP is loaded. |args| is the list of arguments
@@ -53,6 +53,9 @@ class NTPLoginHandler : public WebUIMessageHandler,
   // arguments passed from JS and should be an empty list.
   void HandleShowSyncLoginUI(const ListValue* args);
 
+  // Records actions in SyncPromo.NTPPromo histogram.
+  void RecordInHistogram(int type);
+
   // Internal helper method
   void UpdateLogin();
 
diff --git a/chrome/browser/ui/webui/sync_promo_ui.cc b/chrome/browser/ui/webui/sync_promo_ui.cc
index fe58dea..17d980e 100644
--- a/chrome/browser/ui/webui/sync_promo_ui.cc
+++ b/chrome/browser/ui/webui/sync_promo_ui.cc
@@ -36,7 +36,7 @@ const char kSyncPromoQueryKeyShowTitle[]  = "show_title";
 const char kSyncPromoQueryKeyNextPage[]  = "next_page";
 
 // The maximum number of times we want to show the sync promo at startup.
-const int kSyncPromoShowAtStartupMaxiumum = 10;
+const int kSyncPromoShowAtStartupMaximum = 10;
 
 // Checks we want to show the sync promo for the given brand.
 bool AllowPromoAtStartupForCurrentBrand() {
@@ -120,6 +120,7 @@ SyncPromoUI::SyncPromoUI(TabContents* contents) : ChromeWebUI(contents) {
   profile->GetChromeURLDataManager()->AddDataSource(html_source);
 }
 
+// static
 bool SyncPromoUI::ShouldShowSyncPromo(Profile* profile) {
 #if defined(OS_CHROMEOS)
   // There's no need to show the sync promo on cros since cros users are logged
@@ -176,7 +177,7 @@ bool SyncPromoUI::ShouldShowSyncPromoAtStartup(Profile* profile,
     return false;
 
   int show_count = prefs->GetInteger(prefs::kSyncPromoStartupCount);
-  if (show_count >= kSyncPromoShowAtStartupMaxiumum)
+  if (show_count >= kSyncPromoShowAtStartupMaximum)
     return false;
 
   // This pref can be set in the master preferences file to allow or disallow
diff --git a/chrome/browser/web_resource/promo_resource_service.cc b/chrome/browser/web_resource/promo_resource_service.cc
index 16e92fe..bc9f75b 100644
--- a/chrome/browser/web_resource/promo_resource_service.cc
+++ b/chrome/browser/web_resource/promo_resource_service.cc
@@ -37,9 +37,9 @@ static const int kTestCacheUpdateDelay = 3 * 60 * 1000;
 // to versions with different types of promos).
 static const int kPromoServiceVersion = 2;
 
-// The number of groups sync promo users will be divided into (which gives us a
-// 1/N granularity when targeting more groups).
-static const int kSyncPromoNumberOfGroups = 100;
+// The number of groups sign-in promo users will be divided into (which gives us
+// a 1/N granularity when targeting more groups).
+static const int kNTPSignInPromoNumberOfGroups = 100;
 
 // Properties used by the server.
 static const char kAnswerIdProperty[] = "answer_id";
@@ -84,10 +84,10 @@ void PromoResourceService::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDoublePref(prefs::kNTPCustomLogoEnd,
                             0,
                             PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterIntegerPref(prefs::kNTPSyncPromoGroup,
+  prefs->RegisterIntegerPref(prefs::kNTPSignInPromoGroup,
                              0,
                              PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterIntegerPref(prefs::kNTPSyncPromoGroupMax,
+  prefs->RegisterIntegerPref(prefs::kNTPSignInPromoGroupMax,
                              0,
                              PrefService::UNSYNCABLE_PREF);
   NotificationPromo::RegisterUserPrefs(prefs);
@@ -154,7 +154,7 @@ void PromoResourceService::Unpack(const DictionaryValue& parsed_json) {
   UnpackLogoSignal(parsed_json);
   UnpackNotificationSignal(parsed_json);
   UnpackWebStoreSignal(parsed_json);
-  UnpackSyncPromoSignal(parsed_json);
+  UnpackNTPSignInPromoSignal(parsed_json);
 }
 
 void PromoResourceService::OnNewNotification(double start, double end) {
@@ -376,7 +376,7 @@ void PromoResourceService::UnpackLogoSignal(
   }
 }
 
-void PromoResourceService::UnpackSyncPromoSignal(
+void PromoResourceService::UnpackNTPSignInPromoSignal(
     const DictionaryValue& parsed_json) {
 #if defined(OS_CHROMEOS)
   // Don't bother with this signal on ChromeOS. Users are already synced.
@@ -398,7 +398,7 @@ void PromoResourceService::UnpackSyncPromoSignal(
       continue;
     DictionaryValue* a_dic = static_cast<DictionaryValue*>(*answer_iter);
     std::string name;
-    if (a_dic->GetString("name", &name) && name == "sync_promo") {
+    if (a_dic->GetString("name", &name) && name == "sign_in_promo") {
       a_dic->GetString("question", &question);
       break;
     }
@@ -413,12 +413,12 @@ void PromoResourceService::UnpackSyncPromoSignal(
       !base::StringToInt(question.substr(build_index + 1), &new_group_max)) {
     // If anything about the response was invalid or this build is no longer
     // targeted and there are existing prefs, clear them and notify.
-    if (prefs_->HasPrefPath(prefs::kNTPSyncPromoGroup) ||
-        prefs_->HasPrefPath(prefs::kNTPSyncPromoGroupMax)) {
+    if (prefs_->HasPrefPath(prefs::kNTPSignInPromoGroup) ||
+        prefs_->HasPrefPath(prefs::kNTPSignInPromoGroupMax)) {
       // Make sure we clear first, as the following notification may possibly
-      // depend on calling CanShowSyncPromo synchronously.
-      prefs_->ClearPref(prefs::kNTPSyncPromoGroup);
-      prefs_->ClearPref(prefs::kNTPSyncPromoGroupMax);
+      // depend on calling CanShowNTPSignInPromo synchronously.
+      prefs_->ClearPref(prefs::kNTPSignInPromoGroup);
+      prefs_->ClearPref(prefs::kNTPSignInPromoGroupMax);
       // Notify the NTP resource cache if the promo has been disabled.
       content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_PROMO_RESOURCE_STATE_CHANGED,
@@ -432,26 +432,26 @@ void PromoResourceService::UnpackSyncPromoSignal(
 
   // If we successfully parsed a response and it differs from our user prefs,
   // set pref for next time to compare.
-  if (new_group_max != prefs_->GetInteger(prefs::kNTPSyncPromoGroupMax))
-    prefs_->SetInteger(prefs::kNTPSyncPromoGroupMax, new_group_max);
+  if (new_group_max != prefs_->GetInteger(prefs::kNTPSignInPromoGroupMax))
+    prefs_->SetInteger(prefs::kNTPSignInPromoGroupMax, new_group_max);
 }
 
 // static
-bool PromoResourceService::CanShowSyncPromo(Profile* profile) {
+bool PromoResourceService::CanShowNTPSignInPromo(Profile* profile) {
   DCHECK(profile);
   PrefService* prefs = profile->GetPrefs();
 
-  if (!prefs->HasPrefPath(prefs::kNTPSyncPromoGroupMax))
+  if (!prefs->HasPrefPath(prefs::kNTPSignInPromoGroupMax))
     return false;
 
   // If there's a max group set and the user hasn't been bucketed yet, do it.
-  if (!prefs->HasPrefPath(prefs::kNTPSyncPromoGroup)) {
-    prefs->SetInteger(prefs::kNTPSyncPromoGroup,
-                      base::RandInt(1, kSyncPromoNumberOfGroups));
+  if (!prefs->HasPrefPath(prefs::kNTPSignInPromoGroup)) {
+    prefs->SetInteger(prefs::kNTPSignInPromoGroup,
+                      base::RandInt(1, kNTPSignInPromoNumberOfGroups));
   }
 
   // A response is not kept if the build wasn't targeted, so the only thing
   // required to check is the group this client has been tagged in.
-  return prefs->GetInteger(prefs::kNTPSyncPromoGroupMax) >=
-         prefs->GetInteger(prefs::kNTPSyncPromoGroup);
+  return prefs->GetInteger(prefs::kNTPSignInPromoGroupMax) >=
+         prefs->GetInteger(prefs::kNTPSignInPromoGroup);
 }
diff --git a/chrome/browser/web_resource/promo_resource_service.h b/chrome/browser/web_resource/promo_resource_service.h
index fd97425..c9b2b7b 100644
--- a/chrome/browser/web_resource/promo_resource_service.h
+++ b/chrome/browser/web_resource/promo_resource_service.h
@@ -44,8 +44,8 @@ class PromoResourceService
   // Checks for conditions to show promo: start/end times, channel, etc.
   static bool CanShowNotificationPromo(Profile* profile);
 
-  // Checks if this user is in a group for sync promo roll-out.
-  static bool CanShowSyncPromo(Profile* profile);
+  // Checks if this user is in a group for sign-in promo roll-out.
+  static bool CanShowNTPSignInPromo(Profile* profile);
 
   static void RegisterPrefs(PrefService* local_state);
 
@@ -60,7 +60,7 @@ class PromoResourceService
   static const char* kDefaultPromoResourceServer;
 
  private:
-  friend class SyncPromoTest;
+  friend class NTPSignInPromoTest;
   FRIEND_TEST_ALL_PREFIXES(PromoResourceServiceTest, IsBuildTargetedTest);
   FRIEND_TEST_ALL_PREFIXES(PromoResourceServiceTest, UnpackLogoSignal);
   FRIEND_TEST_ALL_PREFIXES(PromoResourceServiceTest, UnpackWebStoreSignal);
@@ -209,22 +209,21 @@ class PromoResourceService
   //   answer_id: the promo's id
   void UnpackWebStoreSignal(const base::DictionaryValue& parsed_json);
 
-  // Unpack the sync promo. Expects JSON delivery in the following format:
+  // Unpack the NTP sign in promo. Expects JSON in the following format:
   // {
   //   "topic": {
   //     "answers": [
   //       ...
   //       {
   //         "answer_id": "XXXXXXX",
-  //         "name": "sync_promo",
+  //         "name": "sign_in_promo",
   //         "question": "1:5"
   //       }
   //     ]
   //   }
   // }
-  //
   // The question is in the form of "<build>:<group_max>".
-  void UnpackSyncPromoSignal(const base::DictionaryValue& parsed_json);
+  void UnpackNTPSignInPromoSignal(const base::DictionaryValue& parsed_json);
 
   // NotificationPromo::Delegate override.
   virtual void OnNewNotification(double start, double end) OVERRIDE;
diff --git a/chrome/browser/web_resource/promo_resource_service_unittest.cc b/chrome/browser/web_resource/promo_resource_service_unittest.cc
index f633859..5b7f4c0 100644
--- a/chrome/browser/web_resource/promo_resource_service_unittest.cc
+++ b/chrome/browser/web_resource/promo_resource_service_unittest.cc
@@ -36,10 +36,11 @@ class PromoResourceServiceTest : public testing::Test {
   MessageLoop loop_;
 };
 
-class SyncPromoTest : public PromoResourceServiceTest,
+class NTPSignInPromoTest : public PromoResourceServiceTest,
                       public content::NotificationObserver {
  public:
-  SyncPromoTest() : PromoResourceServiceTest(), notifications_received_(0) {
+  NTPSignInPromoTest() : PromoResourceServiceTest(),
+                         notifications_received_(0) {
     web_resource_service_->set_channel(chrome::VersionInfo::CHANNEL_DEV);
     registrar_.Add(this,
                    chrome::NOTIFICATION_PROMO_RESOURCE_STATE_CHANGED,
@@ -63,37 +64,37 @@ class SyncPromoTest : public PromoResourceServiceTest,
   }
 
  protected:
-  void ClearSyncPromoPrefs() {
+  void ClearNTPSignInPromoPrefs() {
     PrefService* prefs = profile_.GetPrefs();
-    prefs->ClearPref(prefs::kNTPSyncPromoGroup);
-    prefs->ClearPref(prefs::kNTPSyncPromoGroupMax);
-    ASSERT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroup));
-    ASSERT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroupMax));
+    prefs->ClearPref(prefs::kNTPSignInPromoGroup);
+    prefs->ClearPref(prefs::kNTPSignInPromoGroupMax);
+    ASSERT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroup));
+    ASSERT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroupMax));
   }
 
   void InvalidTestCase(const std::string& question) {
     PrefService* prefs = profile_.GetPrefs();
     ASSERT_TRUE(prefs != NULL);
-    prefs->SetInteger(prefs::kNTPSyncPromoGroup, 50);
-    prefs->SetInteger(prefs::kNTPSyncPromoGroupMax, 75);
-    UnpackSyncPromo(question);
-    EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroup));
-    EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroupMax));
+    prefs->SetInteger(prefs::kNTPSignInPromoGroup, 50);
+    prefs->SetInteger(prefs::kNTPSignInPromoGroupMax, 75);
+    UnpackNTPSignInPromo(question);
+    EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroup));
+    EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroupMax));
   }
 
-  void SetupSyncPromoCase(int build, int max_group) {
+  void SetupNTPSignInPromoCase(int build, int max_group) {
     std::string question = base::IntToString(build) + ":" +
                            base::IntToString(max_group);
-    UnpackSyncPromo(question);
+    UnpackNTPSignInPromo(question);
   }
 
-  void UnpackSyncPromo(const std::string& question) {
+  void UnpackNTPSignInPromo(const std::string& question) {
     std::string json_header =
       "{ "
       "  \"topic\": {"
       "    \"answers\": ["
       "       {"
-      "        \"name\": \"sync_promo\","
+      "        \"name\": \"sign_in_promo\","
       "        \"question\": \"";
 
     std::string json_footer = "\""
@@ -104,7 +105,7 @@ class SyncPromoTest : public PromoResourceServiceTest,
 
    scoped_ptr<DictionaryValue> test_json(static_cast<DictionaryValue*>(
         base::JSONReader::Read(json_header + question + json_footer, false)));
-   web_resource_service_->UnpackSyncPromoSignal(*(test_json.get()));
+   web_resource_service_->UnpackNTPSignInPromoSignal(*(test_json.get()));
   }
 
   private:
@@ -749,81 +750,81 @@ TEST_F(PromoResourceServiceTest, UnpackWebStoreSignalHttpLogo) {
 }
 
 // Don't run sync promo unpacking tests on ChromeOS as on that plaform
-// PromoResourceService::UnpackSyncPromoSignal() basically just no-ops.
+// PromoResourceService::UnpackNTPSignInPromoSignal() basically just no-ops.
 #if !defined(OS_CHROMEOS)
-TEST_F(SyncPromoTest, UnpackSyncPromoSignal) {
+TEST_F(NTPSignInPromoTest, UnpackNTPSignInPromoSignal) {
   PrefService* prefs = profile_.GetPrefs();
   ASSERT_TRUE(prefs != NULL);
 
   // Test on by default (currently should be false).
-  EXPECT_FALSE(PromoResourceService::CanShowSyncPromo(&profile_));
-  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroup));
-  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroupMax));
+  EXPECT_FALSE(PromoResourceService::CanShowNTPSignInPromo(&profile_));
+  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroup));
+  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroupMax));
 
   // Non-targeted build.
-  ClearSyncPromoPrefs();
-  SetupSyncPromoCase(2, 50);
-  EXPECT_FALSE(PromoResourceService::CanShowSyncPromo(&profile_));
-  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroup));
-  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroupMax));
+  ClearNTPSignInPromoPrefs();
+  SetupNTPSignInPromoCase(2, 50);
+  EXPECT_FALSE(PromoResourceService::CanShowNTPSignInPromo(&profile_));
+  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroup));
+  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroupMax));
 
   // Targeted build, doesn't create bucket and doesn't show promo because
   // groupMax < group.
-  ClearSyncPromoPrefs();
-  SetupSyncPromoCase(1, 0);
-  EXPECT_FALSE(PromoResourceService::CanShowSyncPromo(&profile_));
-  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSyncPromoGroupMax), 0);
-  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroup));
+  ClearNTPSignInPromoPrefs();
+  SetupNTPSignInPromoCase(1, 0);
+  EXPECT_FALSE(PromoResourceService::CanShowNTPSignInPromo(&profile_));
+  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSignInPromoGroupMax), 0);
+  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroup));
 
   // Targeted build, max_group = 50, ensure group pref created and within the
   // group bounds.
-  ClearSyncPromoPrefs();
-  SetupSyncPromoCase(1, 50);
-  PromoResourceService::CanShowSyncPromo(&profile_);
-  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSyncPromoGroupMax), 50);
-  EXPECT_TRUE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroup));
-  EXPECT_GT(prefs->GetInteger(prefs::kNTPSyncPromoGroup), 0);
-  EXPECT_LE(prefs->GetInteger(prefs::kNTPSyncPromoGroup), 100);
+  ClearNTPSignInPromoPrefs();
+  SetupNTPSignInPromoCase(1, 50);
+  PromoResourceService::CanShowNTPSignInPromo(&profile_);
+  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSignInPromoGroupMax), 50);
+  EXPECT_TRUE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroup));
+  EXPECT_GT(prefs->GetInteger(prefs::kNTPSignInPromoGroup), 0);
+  EXPECT_LE(prefs->GetInteger(prefs::kNTPSignInPromoGroup), 100);
 
   // Set user group = 50, now shows promo.
-  prefs->SetInteger(prefs::kNTPSyncPromoGroup, 50);
-  EXPECT_TRUE(PromoResourceService::CanShowSyncPromo(&profile_));
-  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSyncPromoGroup), 50);
-  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSyncPromoGroupMax), 50);
+  prefs->SetInteger(prefs::kNTPSignInPromoGroup, 50);
+  EXPECT_TRUE(PromoResourceService::CanShowNTPSignInPromo(&profile_));
+  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSignInPromoGroup), 50);
+  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSignInPromoGroupMax), 50);
 
   // Bump user group, ensure that we should not show promo.
-  prefs->SetInteger(prefs::kNTPSyncPromoGroup, 51);
-  EXPECT_FALSE(PromoResourceService::CanShowSyncPromo(&profile_));
-  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSyncPromoGroup), 51);
-  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSyncPromoGroupMax), 50);
+  prefs->SetInteger(prefs::kNTPSignInPromoGroup, 51);
+  EXPECT_FALSE(PromoResourceService::CanShowNTPSignInPromo(&profile_));
+  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSignInPromoGroup), 51);
+  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSignInPromoGroupMax), 50);
 
   // If the max group gets bumped to the user's group (or above), it should
   // show.
-  prefs->SetInteger(prefs::kNTPSyncPromoGroupMax, 51);
-  EXPECT_TRUE(PromoResourceService::CanShowSyncPromo(&profile_));
-  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSyncPromoGroup), 51);
-  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSyncPromoGroupMax), 51);
+  prefs->SetInteger(prefs::kNTPSignInPromoGroupMax, 51);
+  EXPECT_TRUE(PromoResourceService::CanShowNTPSignInPromo(&profile_));
+  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSignInPromoGroup), 51);
+  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSignInPromoGroupMax), 51);
 
   // Reduce max group.
-  prefs->SetInteger(prefs::kNTPSyncPromoGroupMax, 49);
-  EXPECT_FALSE(PromoResourceService::CanShowSyncPromo(&profile_));
-  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSyncPromoGroup), 51);
-  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSyncPromoGroupMax), 49);
+  prefs->SetInteger(prefs::kNTPSignInPromoGroupMax, 49);
+  EXPECT_FALSE(PromoResourceService::CanShowNTPSignInPromo(&profile_));
+  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSignInPromoGroup), 51);
+  EXPECT_EQ(prefs->GetInteger(prefs::kNTPSignInPromoGroupMax), 49);
 
   // Ignore non-targeted builds.
-  prefs->SetInteger(prefs::kNTPSyncPromoGroup, 50);
-  prefs->SetInteger(prefs::kNTPSyncPromoGroupMax, 75);
-  EXPECT_TRUE(PromoResourceService::CanShowSyncPromo(&profile_));
-  SetupSyncPromoCase(2, 25);
+  prefs->SetInteger(prefs::kNTPSignInPromoGroup, 50);
+  prefs->SetInteger(prefs::kNTPSignInPromoGroupMax, 75);
+  EXPECT_TRUE(PromoResourceService::CanShowNTPSignInPromo(&profile_));
+  SetupNTPSignInPromoCase(2, 25);
   // Make sure the prefs are deleted.
-  EXPECT_FALSE(PromoResourceService::CanShowSyncPromo(&profile_));
-  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroup));
-  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSyncPromoGroupMax));
+  EXPECT_FALSE(PromoResourceService::CanShowNTPSignInPromo(&profile_));
+  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroup));
+  EXPECT_FALSE(prefs->HasPrefPath(prefs::kNTPSignInPromoGroupMax));
 }
 
-// Throw random stuff at UnpackSyncPromoSignal and make sure no segfaults or
-// other issues and that the prefs were cleared.
-TEST_F(SyncPromoTest, UnpackSyncPromoSignalInvalid) {
+// Throw random stuff at UnpackNTPSignInPromoSignal and make sure no segfaults
+// or other issues and that the prefs were cleared.
+TEST_F(NTPSignInPromoTest, UnpackNTPSignInPromoSignalInvalid) {
   // Empty.
   InvalidTestCase("");
 
@@ -843,28 +844,28 @@ TEST_F(SyncPromoTest, UnpackSyncPromoSignalInvalid) {
   InvalidTestCase("だからって馬鹿に:してるの？怒る友人");
 }
 
-TEST_F(SyncPromoTest, UnpackSyncPromoSignalNotify) {
+TEST_F(NTPSignInPromoTest, UnpackNTPSignInPromoSignalNotify) {
   // Clear prefs and ensure we're not triggering notifications every time we
   // receive not-targeted or valid data (only when we need to turn off the
   // promo).
-  ClearSyncPromoPrefs();
+  ClearNTPSignInPromoPrefs();
   reset_notification_count();
 
   // Non-targeted build.
-  SetupSyncPromoCase(2, 50);
+  SetupNTPSignInPromoCase(2, 50);
 
   // Targeted, but under any possible max group.
-  SetupSyncPromoCase(1, 0);
+  SetupNTPSignInPromoCase(1, 0);
 
   // Targeted for sure, but shouldn't send notification.
-  SetupSyncPromoCase(1, 100);
+  SetupNTPSignInPromoCase(1, 100);
 
   // Expect this didn't trigger any notifications.
   EXPECT_EQ(notifications_received(), 0);
 
   // Expect notifications when the promo is disabled, as this is expected
   // behavior.
-  SetupSyncPromoCase(2, 0);
+  SetupNTPSignInPromoCase(2, 0);
   EXPECT_EQ(notifications_received(), 1);
 }
 #endif  // !defined(OS_CHROMEOS)
diff --git a/chrome/common/pref_names.cc b/chrome/common/pref_names.cc
index 5e48bcc..e65225a 100644
--- a/chrome/common/pref_names.cc
+++ b/chrome/common/pref_names.cc
@@ -1310,10 +1310,10 @@ const char kNTPPromoEnd[] = "ntp.promo_end";
 
 // A randomly generated group created to control the number of users we show the
 // sync promo to on the NTP.
-const char kNTPSyncPromoGroup[] = "ntp.sync_promo.group";
+const char kNTPSignInPromoGroup[] = "ntp.sign_in_promo.group";
 
 // The maximum allowable group that can be shown the sync promotion on the NTP.
-const char kNTPSyncPromoGroupMax[] = "ntp.sync_promo.group_max";
+const char kNTPSignInPromoGroupMax[] = "ntp.sign_in_promo.group_max";
 
 // Boolean indicating whether the web store is active for the current locale.
 const char kNTPWebStoreEnabled[] = "ntp.webstore_enabled";
diff --git a/chrome/common/pref_names.h b/chrome/common/pref_names.h
index 81e69d7..fcf7399 100644
--- a/chrome/common/pref_names.h
+++ b/chrome/common/pref_names.h
@@ -465,8 +465,8 @@ extern const char kNTPPromoGroupMax[];
 extern const char kNTPPromoViews[];
 extern const char kNTPPromoViewsMax[];
 extern const char kNTPPromoBuild[];
-extern const char kNTPSyncPromoGroup[];
-extern const char kNTPSyncPromoGroupMax[];
+extern const char kNTPSignInPromoGroup[];
+extern const char kNTPSignInPromoGroupMax[];
 extern const char kNTPWebStoreEnabled[];
 extern const char kNTPWebStorePromoLastId[];
 extern const char kNTPWebStorePromoId[];