Purge legacy notification promo code.

chrome/browser/web_resource/promo_resource_service.cc

 // Copyright (c) 2012 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 26 matching lines @@
 // to versions with different types of promos).
 static const int kPromoServiceVersion = 7;
 
 // 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";
 
-GURL GetPromoResourceURL(bool legacy) {
+GURL GetPromoResourceURL() {
   const std::string promo_server_url = CommandLine::ForCurrentProcess()->
       GetSwitchValueASCII(switches::kPromoServerURL);
-  if (!promo_server_url.empty())
-    return GURL(promo_server_url);
-  return legacy ? GURL(PromoResourceService::kDefaultPromoResourceServer) :
-                  NotificationPromo::PromoServerURL();
+  return promo_server_url.empty() ?
+      NotificationPromo::PromoServerURL() : GURL(promo_server_url);
 }
 
 bool IsTest() {
   return CommandLine::ForCurrentProcess()->HasSwitch(switches::kPromoServerURL);
 }
 
 int GetCacheUpdateDelay() {
   return IsTest() ? kTestCacheUpdateDelay : kCacheUpdateDelay;
 }
 
 }  // namespace
 
-// Server for dynamically loaded NTP HTML elements.
-const char* PromoResourceService::kDefaultPromoResourceServer =
-    "https://www.google.com/support/chrome/bin/topic/1142433/inproduct?hl=";
-
-
-
 // static
 void PromoResourceService::RegisterPrefs(PrefService* local_state) {
   local_state->RegisterIntegerPref(prefs::kNtpPromoVersion, 0);
   local_state->RegisterStringPref(prefs::kNtpPromoLocale, std::string());
 }
 
 // static
 void PromoResourceService::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kNtpPromoResourceCacheUpdate,
                             "0",
@@ skipping 33 matching lines @@
       return (STABLE_BUILD & builds_allowed) != 0;
     default:
       // Show promos for local builds when using a custom promo URL.
       return CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kPromoServerURL);
   }
 }
 
 PromoResourceService::PromoResourceService(Profile* profile)
     : WebResourceService(profile->GetPrefs(),
-                         GetPromoResourceURL(false),
+                         GetPromoResourceURL(),
                          true,  // append locale to URL
                          prefs::kNtpPromoResourceCacheUpdate,
                          kStartResourceFetchDelay,
                          GetCacheUpdateDelay()),
                          profile_(profile),
       channel_(chrome::VersionInfo::CHANNEL_UNKNOWN),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       web_resource_update_scheduled_(false) {
   ScheduleNotificationOnInit();
 }
 
 PromoResourceService::~PromoResourceService() { }
 
 bool PromoResourceService::IsBuildTargeted(int builds_targeted) {
   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);
 }
 
-void PromoResourceService::OnNotificationParsed(double start, double end,
-                                                bool new_notification) {
-  if (new_notification) {
-    ScheduleNotification(start, end);
-  }
-}
-
 void PromoResourceService::ScheduleNotification(double promo_start,
                                                 double promo_end) {
   if (promo_start > 0 && promo_end > 0) {
     int64 ms_until_start =
         static_cast<int64>((base::Time::FromDoubleT(
             promo_start) - base::Time::Now()).InMilliseconds());
     int64 ms_until_end =
         static_cast<int64>((base::Time::FromDoubleT(
             promo_end) - base::Time::Now()).InMilliseconds());
     if (ms_until_start > 0)
       PostNotification(ms_until_start);
     if (ms_until_end > 0) {
       PostNotification(ms_until_end);
       if (ms_until_start <= 0) {
         // Notify immediately if time is between start and end.
         PostNotification(0);
       }
     }
   }
 }
 
 void PromoResourceService::ScheduleNotificationOnInit() {
   std::string locale = g_browser_process->GetApplicationLocale();
-  if ((GetPromoServiceVersion() != kPromoServiceVersion) ||
-      (GetPromoLocale() != locale)) {
+  if (GetPromoServiceVersion() != kPromoServiceVersion ||
+      GetPromoLocale() != locale) {
     // If the promo service has been upgraded or Chrome switched locales,
     // refresh the promos.
+    // TODO(achuith): Mixing local_state and prefs does not work for
+    // multi-profile case. We should probably store version/locale in prefs_
+    // as well.
     PrefService* local_state = g_browser_process->local_state();
     local_state->SetInteger(prefs::kNtpPromoVersion, kPromoServiceVersion);
     local_state->SetString(prefs::kNtpPromoLocale, locale);
     prefs_->ClearPref(prefs::kNtpPromoResourceCacheUpdate);
     AppsPromo::ClearPromo();
     PostNotification(0);
   } else {
     // 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_->GetDouble(prefs::kNtpPromoStart);
     double promo_end = prefs_->GetDouble(prefs::kNtpPromoEnd);
     ScheduleNotification(promo_start, promo_end);
   }
 }
 
 void PromoResourceService::PostNotification(int64 delay_ms) {
   if (web_resource_update_scheduled_)
     return;
+  // TODO(achuith): This crashes if we post delay_ms = 0 to the message loop.
+  // during startup.
   if (delay_ms > 0) {
     web_resource_update_scheduled_ = true;
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PromoResourceService::PromoResourceStateChange,
                    weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(delay_ms));
   } else if (delay_ms == 0) {
     PromoResourceStateChange();
   }
@@ skipping 13 matching lines @@
   return local_state->GetInteger(prefs::kNtpPromoVersion);
 }
 
 std::string PromoResourceService::GetPromoLocale() {
   PrefService* local_state = g_browser_process->local_state();
   return local_state->GetString(prefs::kNtpPromoLocale);
 }
 
 void PromoResourceService::UnpackNotificationSignal(
     const DictionaryValue& parsed_json) {
-  scoped_refptr<NotificationPromo> notification_promo =
-      NotificationPromo::Create(profile_, this);
-  notification_promo->InitFromJson(parsed_json);
+  NotificationPromo notification_promo(profile_);
+  notification_promo.InitFromJson(parsed_json);
+
+  if (notification_promo.new_notification()) {
+    ScheduleNotification(notification_promo.StartTimeForGroup(),
+                         notification_promo.EndTime());
+  }
 }
 
 bool PromoResourceService::CanShowNotificationPromo(Profile* profile) {
-  scoped_refptr<NotificationPromo> notification_promo =
-      NotificationPromo::Create(profile, NULL);
-  notification_promo->InitFromPrefs();
-  return notification_promo->CanShow();
+  NotificationPromo notification_promo(profile);
+  notification_promo.InitFromPrefs();
+  return notification_promo.CanShow();
 }
 
 void PromoResourceService::UnpackWebStoreSignal(
     const DictionaryValue& parsed_json) {
   DictionaryValue* topic_dict;
   ListValue* answer_list;
 
   bool is_webstore_active = false;
   bool signal_found = false;
   AppsPromo::PromoData promo_data;
@@ skipping 132 matching lines @@
       !(old_logo_end == logo_end)) {
     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());
   }
 }