Add possibility to divide chrome users into groups of equal size, and change ...

chrome/browser/web_resource/web_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/web_resource_service.h"
 
+#include <string>
+
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/string_util.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/sync_ui_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/net/url_fetcher.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_status.h"
 
 namespace {
 
 // Delay on first fetch so we don't interfere with startup.
 static const int kStartResourceFetchDelay = 5000;
 
 // Delay between calls to update the cache (48 hours).
 static const int kCacheUpdateDelay = 48 * 60 * 60 * 1000;
 
+// Users are randomly assigned to one of kNTPPromoGroupSize buckets, in order
+// to be able to roll out promos slowly, or display different promos to
+// different groups.
+static const int kNTPPromoGroupSize = 16;
+
+// Maximum number of hours for each time slice (4 weeks).
+static const int kMaxTimeSliceHours = 24 * 7 * 4;
+
+// Used to determine which build type should be shown a given promo.
+enum BuildType {
+  DEV_BUILD = 1,
+  BETA_BUILD = 1 << 1,
+  STABLE_BUILD = 1 << 2,
+};
+
 }  // namespace
 
 const char* WebResourceService::kCurrentTipPrefName = "current_tip";
 const char* WebResourceService::kTipCachePrefName = "tips";
 
 class WebResourceService::WebResourceFetcher
     : public URLFetcher::Delegate {
  public:
   explicit WebResourceFetcher(WebResourceService* web_resource_service) :
       ALLOW_THIS_IN_INITIALIZER_LIST(fetcher_factory_(this)),
@@ skipping 149 matching lines @@
   const std::string& json_data_;
 
   // True if we got a response from the utility process and have cleaned up
   // already.
   bool got_response_;
 };
 
 // Server for dynamically loaded NTP HTML elements. TODO(mirandac): append
 // locale for future usage, when we're serving localizable strings.
 const char* WebResourceService::kDefaultWebResourceServer =
-    "https://www.google.com/support/chrome/bin/topic/30248/inproduct";
+//    "https://www.google.com/support/chrome/bin/topic/30248/inproduct";
+  "http://www.corp.google.com/~mirandac/testprefs.json";
 
 WebResourceService::WebResourceService(Profile* profile)
     : prefs_(profile->GetPrefs()),
       profile_(profile),
       ALLOW_THIS_IN_INITIALIZER_LIST(service_factory_(this)),
       in_fetch_(false),
       web_resource_update_scheduled_(false) {
   Init();
 }
 
 WebResourceService::~WebResourceService() { }
 
 void WebResourceService::Init() {
   cache_update_delay_ = kCacheUpdateDelay;
   resource_dispatcher_host_ = g_browser_process->resource_dispatcher_host();
   web_resource_fetcher_.reset(new WebResourceFetcher(this));
   prefs_->RegisterStringPref(prefs::kNTPWebResourceCacheUpdate, "0");
   prefs_->RegisterRealPref(prefs::kNTPCustomLogoStart, 0);
   prefs_->RegisterRealPref(prefs::kNTPCustomLogoEnd, 0);
   prefs_->RegisterRealPref(prefs::kNTPPromoStart, 0);
   prefs_->RegisterRealPref(prefs::kNTPPromoEnd, 0);
   prefs_->RegisterStringPref(prefs::kNTPPromoLine, std::string());
   prefs_->RegisterBooleanPref(prefs::kNTPPromoClosed, false);
+  prefs_->RegisterIntegerPref(prefs::kNTPPromoGroup, -1);
+  prefs_->RegisterIntegerPref(prefs::kNTPPromoBuild,
+                              DEV_BUILD | BETA_BUILD | STABLE_BUILD);
+  prefs_->RegisterIntegerPref(prefs::kNTPPromoGroupTimeSlice, 0);
 
   // If the promo start is in the future, set a notification task to invalidate
   // the NTP cache at the time of the promo start.
   double promo_start = prefs_->GetReal(prefs::kNTPPromoStart);
   double promo_end = prefs_->GetReal(prefs::kNTPPromoEnd);
   ScheduleNotification(promo_start, promo_end);
 }
 
 void WebResourceService::EndFetch() {
   in_fetch_ = false;
 }
 
 void WebResourceService::OnWebResourceUnpacked(
   const DictionaryValue& parsed_json) {
   UnpackLogoSignal(parsed_json);
-  if (WebResourceServiceUtil::CanShowPromo(profile_))
-    UnpackPromoSignal(parsed_json);
+  UnpackPromoSignal(parsed_json);
   EndFetch();
 }
 
 void WebResourceService::WebResourceStateChange() {
   web_resource_update_scheduled_ = false;
   NotificationService* service = NotificationService::current();
   service->Notify(NotificationType::WEB_RESOURCE_STATE_CHANGED,
                   Source<WebResourceService>(this),
                   NotificationService::NoDetails());
 }
@@ skipping 113 matching lines @@
     old_promo_start = prefs_->GetReal(prefs::kNTPPromoStart);
     old_promo_end = prefs_->GetReal(prefs::kNTPPromoEnd);
   }
 
   // Check for newly received start and end values.
   if (parsed_json.GetDictionary("topic", &topic_dict)) {
     if (topic_dict->GetList("answers", &answer_list)) {
       std::string promo_start_string = "";
       std::string promo_end_string = "";
       std::string promo_string = "";
+      std::string promo_build = "";
+      int promo_build_type;
+      int time_slice_hrs;
       for (ListValue::const_iterator tip_iter = answer_list->begin();
            tip_iter != answer_list->end(); ++tip_iter) {
         if (!(*tip_iter)->IsType(Value::TYPE_DICTIONARY))
           continue;
         DictionaryValue* a_dic =
             static_cast<DictionaryValue*>(*tip_iter);
         std::string promo_signal;
         if (a_dic->GetString("name", &promo_signal)) {
           if (promo_signal == "promo_start") {
+            a_dic->GetString("question", &promo_build);
+            size_t split = promo_build.find(":");
+            if (split != std::string::npos &&
+                base::StringToInt(promo_build.substr(0, split),
+                                  &promo_build_type) &&
+                base::StringToInt(promo_build.substr(split+1),
+                                  &time_slice_hrs) &&
+                promo_build_type >= 0 &&
+                promo_build_type <= (DEV_BUILD | BETA_BUILD | STABLE_BUILD) &&
+                time_slice_hrs >= 0 &&
+                time_slice_hrs <= kMaxTimeSliceHours) {
+              prefs_->SetInteger(prefs::kNTPPromoBuild, promo_build_type);
+              prefs_->SetInteger(prefs::kNTPPromoGroupTimeSlice,
+                                 time_slice_hrs);
+            } else {
+              // If no time data or bad time data are set, show promo on all
+              // builds with no time slicing.
+              prefs_->SetInteger(prefs::kNTPPromoBuild,
+                                 DEV_BUILD | BETA_BUILD | STABLE_BUILD);
+              prefs_->SetInteger(prefs::kNTPPromoGroupTimeSlice, 0);
+            }
             a_dic->GetString("inproduct", &promo_start_string);
             a_dic->GetString("tooltip", &promo_string);
             prefs_->SetString(prefs::kNTPPromoLine, promo_string);
+            srand(static_cast<uint32>(time(NULL)));
+            prefs_->SetInteger(prefs::kNTPPromoGroup,
+                               rand() % kNTPPromoGroupSize);
           } else if (promo_signal == "promo_end") {
             a_dic->GetString("inproduct", &promo_end_string);
           }
         }
       }
       if (!promo_start_string.empty() &&
           promo_start_string.length() > 0 &&
           !promo_end_string.empty() &&
           promo_end_string.length() > 0) {
         base::Time start_time;
         base::Time end_time;
         if (base::Time::FromString(
                 ASCIIToWide(promo_start_string).c_str(), &start_time) &&
             base::Time::FromString(
                 ASCIIToWide(promo_end_string).c_str(), &end_time)) {
-          promo_start = start_time.ToDoubleT();
+          // Add group time slice, adjusted from hours to seconds.
+          promo_start = start_time.ToDoubleT() +
+              (prefs_->FindPreference(prefs::kNTPPromoGroup) ?
+                  prefs_->GetInteger(prefs::kNTPPromoGroup) *
+                      time_slice_hrs * 60 * 60 : 0);
           promo_end = end_time.ToDoubleT();
         }
       }
     }
   }
 
   // If start or end times have changed, trigger a new web resource
   // notification, so that the logo on the NTP is updated. This check is
   // outside the reading of the web resource data, because the absence of
   // dates counts as a triggering change if there were dates before.
+  // Also reset the promo closed preference, to signal a new promo.
   if (!(old_promo_start == promo_start) ||
       !(old_promo_end == promo_end)) {
     prefs_->SetReal(prefs::kNTPPromoStart, promo_start);
     prefs_->SetReal(prefs::kNTPPromoEnd, promo_end);
+    prefs_->SetBoolean(prefs::kNTPPromoClosed, false);
     ScheduleNotification(promo_start, promo_end);
   }
 }
 
 void WebResourceService::UnpackLogoSignal(const DictionaryValue& parsed_json) {
   DictionaryValue* topic_dict;
   ListValue* answer_list;
   double old_logo_start = 0;
   double old_logo_end = 0;
   double logo_start = 0;
@@ skipping 59 matching lines @@
 }
 
 namespace WebResourceServiceUtil {
 
 bool CanShowPromo(Profile* profile) {
   bool promo_closed = false;
   PrefService* prefs = profile->GetPrefs();
   if (prefs->HasPrefPath(prefs::kNTPPromoClosed))
     promo_closed = prefs->GetBoolean(prefs::kNTPPromoClosed);
 
-  bool has_extensions = false;
-  ExtensionService* extensions_service = profile->GetExtensionService();
-  if (extensions_service) {
-    const ExtensionList* extensions = extensions_service->extensions();
-    for (ExtensionList::const_iterator iter = extensions->begin();
-         iter != extensions->end();
-         ++iter) {
-      if ((*iter)->location() == Extension::INTERNAL) {
-        has_extensions = true;
-        break;
-      }
+  // Only show if not synced.
+  bool is_synced =
+      (profile->HasProfileSyncService() &&
+          sync_ui_util::GetStatus(
+              profile->GetProfileSyncService()) == sync_ui_util::SYNCED);
+
+  const std::string channel = platform_util::GetVersionStringModifier();
+  bool is_promo_build = false;
+  if (prefs->HasPrefPath(prefs::kNTPPromoBuild)) {
+    int builds_allowed = prefs->GetInteger(prefs::kNTPPromoBuild);
+    if (channel == "dev") {
+      is_promo_build = (DEV_BUILD & builds_allowed) != 0;
+    } else if (channel == "beta") {
+      is_promo_build = (BETA_BUILD & builds_allowed) != 0;
+    } else if (channel == "stable") {
+      is_promo_build = (STABLE_BUILD & builds_allowed) != 0;
+    } else {
+      is_promo_build = true;
     }
   }
 
-  // Note that HasProfileSyncService() will be false for ChromeOS, so
-  // promo_options will only be true if the user has an extension installed.
-  // See http://crosbug/10209
-  bool promo_options =
-      (profile->HasProfileSyncService() &&
-          sync_ui_util::GetStatus(
-              profile->GetProfileSyncService()) == sync_ui_util::SYNCED) ||
-      has_extensions;
-
-  return !promo_closed &&
-         promo_options &&
-         g_browser_process->GetApplicationLocale() == "en-US";
+  return !promo_closed && !is_synced && is_promo_build;
 }
 
 }  // namespace WebResourceService