NTP4/Sync Promo:

chrome/browser/web_resource/promo_resource_service.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/web_resource/promo_resource_service.h"
 
 #include "base/command_line.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 19 matching lines @@
 static const int kStartResourceFetchDelay = 5000;
 
 // Delay between calls to update the cache (48 hours), and 3 min in debug mode.
 static const int kCacheUpdateDelay = 48 * 60 * 60 * 1000;
 static const int kTestCacheUpdateDelay = 3 * 60 * 1000;
 
 // The version of the service (used to expire the cache when upgrading Chrome
 // 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";
 static const char kWebStoreHeaderProperty[] = "question";
 static const char kWebStoreButtonProperty[] = "inproduct_target";
 static const char kWebStoreLinkProperty[] = "inproduct";
 static const char kWebStoreExpireProperty[] = "tooltip";
 
 const char* GetPromoResourceURL() {
   std::string promo_server_url = CommandLine::ForCurrentProcess()->
@@ skipping 24 matching lines @@
 }
 
 // static
 void PromoResourceService::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDoublePref(prefs::kNTPCustomLogoStart,
                             0,
                             PrefService::UNSYNCABLE_PREF);
   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);
 }
 
 // static
 chrome::VersionInfo::Channel PromoResourceService::GetChannel() {
   // GetChannel hits the registry on Windows. See http://crbug.com/70898.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   return chrome::VersionInfo::GetChannel();
@@ skipping 46 matching lines @@
   if (channel_ == chrome::VersionInfo::CHANNEL_UNKNOWN)
     channel_ = GetChannel();
 
   return IsBuildTargeted(channel_, builds_targeted);
 }
 
 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) {
   ScheduleNotification(start, end);
 }
 
 void PromoResourceService::ScheduleNotification(double promo_start,
                                                 double promo_end) {
   if (promo_start > 0 && promo_end > 0) {
     int64 ms_until_start =
@@ skipping 201 matching lines @@
     prefs_->SetDouble(prefs::kNTPCustomLogoStart, logo_start);
     prefs_->SetDouble(prefs::kNTPCustomLogoEnd, logo_end);
     content::NotificationService* service =
         content::NotificationService::current();
     service->Notify(chrome::NOTIFICATION_PROMO_RESOURCE_STATE_CHANGED,
                     content::Source<WebResourceService>(this),
                     content::NotificationService::NoDetails());
   }
 }
 
-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.
   return;
 #endif
 
   DictionaryValue* topic_dict;
   if (!parsed_json.GetDictionary("topic", &topic_dict))
     return;
 
   ListValue* answer_list;
   if (!topic_dict->GetList("answers", &answer_list))
     return;
 
   std::string question;
   for (ListValue::const_iterator answer_iter = answer_list->begin();
        answer_iter != answer_list->end(); ++answer_iter) {
     if (!(*answer_iter)->IsType(Value::TYPE_DICTIONARY))
       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;
     }
   }
 
   int new_build;
   int new_group_max;
   size_t build_index = question.find(":");
   if (std::string::npos == build_index ||
       !base::StringToInt(question.substr(0, build_index), &new_build) ||
       !IsBuildTargeted(new_build) ||
       !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,
           content::Source<WebResourceService>(this),
           content::NotificationService::NoDetails());
     }
     return;
   }
 
   // TODO(dbeam): Add automagic hour group bumper to parsing?
 
   // 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);
 }