src/chrome/browser/signin/signin_promo.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/signin/signin_promo.h"
   6
   7 #include "base/prefs/pref_service.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/browser_process.h"
  13 #include "chrome/browser/first_run/first_run.h"
  14 #include "chrome/browser/google/google_util.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/browser/profiles/profile_info_cache.h"
  17 #include "chrome/browser/profiles/profile_manager.h"
  18 #include "chrome/browser/signin/signin_manager.h"
  19 #include "chrome/browser/signin/signin_manager_factory.h"
  20 #include "chrome/browser/sync/profile_sync_service.h"
  21 #include "chrome/browser/sync/profile_sync_service_factory.h"
  22 #include "chrome/browser/ui/webui/options/core_options_handler.h"
  23 #include "chrome/browser/ui/webui/theme_source.h"
  24 #include "chrome/common/net/url_util.h"
  25 #include "chrome/common/pref_names.h"
  26 #include "chrome/common/profile_management_switches.h"
  27 #include "chrome/common/url_constants.h"
  28 #include "components/user_prefs/pref_registry_syncable.h"
  29 #include "content/public/browser/url_data_source.h"
  30 #include "content/public/browser/web_contents.h"
  31 #include "content/public/browser/web_ui.h"
  32 #include "content/public/browser/web_ui_data_source.h"
  33 #include "google_apis/gaia/gaia_urls.h"
  34 #include "grit/browser_resources.h"
  35 #include "grit/generated_resources.h"
  36 #include "grit/theme_resources.h"
  37 #include "net/base/escape.h"
  38 #include "net/base/network_change_notifier.h"
  39 #include "net/base/url_util.h"
  40 #include "ui/base/l10n/l10n_util.h"
  41
  42 using content::WebContents;
  43
  44 namespace {
  45
  46 const char kSignInPromoQueryKeyAutoClose[] = "auto_close";
  47 const char kSignInPromoQueryKeyContinue[] = "continue";
  48 const char kSignInPromoQueryKeySource[] = "source";
  49 const char kSignInPromoQueryKeyConstrained[] = "constrained";
  50
  51 // Gaia cannot support about:blank as a continue URL, so using a hosted blank
  52 // page instead.
  53 const char kSignInLandingUrlPrefix[] =
  54     "https://www.google.com/intl/%s/chrome/blank.html";
  55
  56 // The maximum number of times we want to show the sign in promo at startup.
  57 const int kSignInPromoShowAtStartupMaximum = 10;
  58
  59 // Forces the web based signin flow when set.
  60 bool g_force_web_based_signin_flow = false;
  61
  62 // Checks we want to show the sign in promo for the given brand.
  63 bool AllowPromoAtStartupForCurrentBrand() {
  64   std::string brand;
  65   google_util::GetBrand(&brand);
  66
  67   if (brand.empty())
  68     return true;
  69
  70   if (google_util::IsInternetCafeBrandCode(brand))
  71     return false;
  72
  73   // Enable for both organic and distribution.
  74   return true;
  75 }
  76
  77 // Returns true if a user has seen the sign in promo at startup previously.
  78 bool HasShownPromoAtStartup(Profile* profile) {
  79   return profile->GetPrefs()->HasPrefPath(prefs::kSignInPromoStartupCount);
  80 }
  81
  82 // Returns true if the user has previously skipped the sign in promo.
  83 bool HasUserSkippedPromo(Profile* profile) {
  84   return profile->GetPrefs()->GetBoolean(prefs::kSignInPromoUserSkipped);
  85 }
  86
  87 }  // namespace
  88
  89 namespace signin {
  90
  91 bool ShouldShowPromo(Profile* profile) {
  92 #if defined(OS_CHROMEOS)
  93   // There's no need to show the sign in promo on cros since cros users are
  94   // already logged in.
  95   return false;
  96 #else
  97
  98   // Don't bother if we don't have any kind of network connection.
  99   if (net::NetworkChangeNotifier::IsOffline())
 100     return false;
 101
 102   // Don't show for managed profiles.
 103   if (profile->IsManaged())
 104     return false;
 105
 106   // Display the signin promo if the user is not signed in.
 107   SigninManager* signin = SigninManagerFactory::GetForProfile(
 108       profile->GetOriginalProfile());
 109   return !signin->AuthInProgress() && signin->IsSigninAllowed() &&
 110       signin->GetAuthenticatedUsername().empty();
 111 #endif
 112 }
 113
 114 bool ShouldShowPromoAtStartup(Profile* profile, bool is_new_profile) {
 115   DCHECK(profile);
 116
 117   // Don't show if the profile is an incognito.
 118   if (profile->IsOffTheRecord())
 119     return false;
 120
 121   if (!ShouldShowPromo(profile))
 122     return false;
 123
 124   if (!is_new_profile) {
 125     if (!HasShownPromoAtStartup(profile))
 126       return false;
 127   }
 128
 129   if (HasUserSkippedPromo(profile))
 130     return false;
 131
 132   // For Chinese users skip the sign in promo.
 133   if (g_browser_process->GetApplicationLocale() == "zh-CN")
 134     return false;
 135
 136   PrefService* prefs = profile->GetPrefs();
 137   int show_count = prefs->GetInteger(prefs::kSignInPromoStartupCount);
 138   if (show_count >= kSignInPromoShowAtStartupMaximum)
 139     return false;
 140
 141   // This pref can be set in the master preferences file to allow or disallow
 142   // showing the sign in promo at startup.
 143   if (prefs->HasPrefPath(prefs::kSignInPromoShowOnFirstRunAllowed))
 144     return prefs->GetBoolean(prefs::kSignInPromoShowOnFirstRunAllowed);
 145
 146   // For now don't show the promo for some brands.
 147   if (!AllowPromoAtStartupForCurrentBrand())
 148     return false;
 149
 150   // Default to show the promo for Google Chrome builds.
 151 #if defined(GOOGLE_CHROME_BUILD)
 152   return true;
 153 #else
 154   return false;
 155 #endif
 156 }
 157
 158 void DidShowPromoAtStartup(Profile* profile) {
 159   int show_count = profile->GetPrefs()->GetInteger(
 160       prefs::kSignInPromoStartupCount);
 161   show_count++;
 162   profile->GetPrefs()->SetInteger(prefs::kSignInPromoStartupCount, show_count);
 163 }
 164
 165 void SetUserSkippedPromo(Profile* profile) {
 166   profile->GetPrefs()->SetBoolean(prefs::kSignInPromoUserSkipped, true);
 167 }
 168
 169 GURL GetLandingURL(const char* option, int value) {
 170   const std::string& locale = g_browser_process->GetApplicationLocale();
 171   std::string url = base::StringPrintf(kSignInLandingUrlPrefix, locale.c_str());
 172   base::StringAppendF(&url, "?%s=%d", option, value);
 173   return GURL(url);
 174 }
 175
 176 GURL GetPromoURL(Source source, bool auto_close) {
 177   return GetPromoURL(source, auto_close, false /* is_constrained */);
 178 }
 179
 180 GURL GetPromoURL(Source source, bool auto_close, bool is_constrained) {
 181   DCHECK_NE(SOURCE_UNKNOWN, source);
 182
 183   if (!switches::IsEnableWebBasedSignin()) {
 184     std::string url(chrome::kChromeUIChromeSigninURL);
 185     base::StringAppendF(&url, "?%s=%d", kSignInPromoQueryKeySource, source);
 186     if (auto_close)
 187       base::StringAppendF(&url, "&%s=1", kSignInPromoQueryKeyAutoClose);
 188     if (is_constrained)
 189       base::StringAppendF(&url, "&%s=1", kSignInPromoQueryKeyConstrained);
 190     return GURL(url);
 191   }
 192
 193   // Build a Gaia-based URL that can be used to sign the user into chrome.
 194   // There are required request parameters:
 195   //
 196   //  - tell Gaia which service the user is signing into.  In this case,
 197   //    a chrome sign in uses the service "chromiumsync"
 198   //  - provide a continue URL.  This is the URL that Gaia will redirect to
 199   //    once the sign is complete.
 200   //
 201   // The continue URL includes a source parameter that can be extracted using
 202   // the function GetSourceForSignInPromoURL() below.  This is used to know
 203   // which of the chrome sign in access points was used to sign the user in.
 204   // It is also parsed for the |auto_close| flag, which indicates that the tab
 205   // must be closed after sync setup is successful.
 206   // See OneClickSigninHelper for details.
 207   std::string query_string = "?service=chromiumsync&sarp=1";
 208
 209   std::string continue_url = GetLandingURL(kSignInPromoQueryKeySource,
 210                                            static_cast<int>(source)).spec();
 211   if (auto_close)
 212     base::StringAppendF(&continue_url, "&%s=1", kSignInPromoQueryKeyAutoClose);
 213
 214   base::StringAppendF(&query_string, "&%s=%s", kSignInPromoQueryKeyContinue,
 215                       net::EscapeQueryParamValue(
 216                           continue_url, false).c_str());
 217
 218   return GaiaUrls::GetInstance()->service_login_url().Resolve(query_string);
 219 }
 220
 221 GURL GetReauthURL(Profile* profile, const std::string& account_id) {
 222   if (switches::IsEnableWebBasedSignin()) {
 223     return net::AppendQueryParameter(
 224         signin::GetPromoURL(signin::SOURCE_SETTINGS, true),
 225         "Email",
 226         account_id);
 227   }
 228
 229   const std::string primary_account_id =
 230     SigninManagerFactory::GetForProfile(profile)->
 231         GetAuthenticatedAccountId();
 232   signin::Source source = account_id == primary_account_id ?
 233       signin::SOURCE_SETTINGS : signin::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT;
 234
 235   GURL url = signin::GetPromoURL(source, true);
 236   url = net::AppendQueryParameter(url, "email", account_id);
 237   url = net::AppendQueryParameter(url, "validateEmail", "1");
 238   return net::AppendQueryParameter(url, "readOnlyEmail", "1");
 239 }
 240
 241 GURL GetNextPageURLForPromoURL(const GURL& url) {
 242   std::string value;
 243   if (net::GetValueForKeyInQuery(url, kSignInPromoQueryKeyContinue, &value))
 244     return GURL(value);
 245
 246   return GURL();
 247 }
 248
 249 Source GetSourceForPromoURL(const GURL& url) {
 250   std::string value;
 251   if (net::GetValueForKeyInQuery(url, kSignInPromoQueryKeySource, &value)) {
 252     int source = 0;
 253     if (base::StringToInt(value, &source) && source >= SOURCE_START_PAGE &&
 254         source < SOURCE_UNKNOWN) {
 255       return static_cast<Source>(source);
 256     }
 257   }
 258   return SOURCE_UNKNOWN;
 259 }
 260
 261 bool IsAutoCloseEnabledInURL(const GURL& url) {
 262   std::string value;
 263   if (net::GetValueForKeyInQuery(url, kSignInPromoQueryKeyAutoClose, &value)) {
 264     int enabled = 0;
 265     if (base::StringToInt(value, &enabled) && enabled == 1)
 266       return true;
 267   }
 268   return false;
 269 }
 270
 271 bool IsContinueUrlForWebBasedSigninFlow(const GURL& url) {
 272   GURL::Replacements replacements;
 273   replacements.ClearQuery();
 274   const std::string& locale = g_browser_process->GetApplicationLocale();
 275   GURL continue_url =
 276       GURL(base::StringPrintf(kSignInLandingUrlPrefix, locale.c_str()));
 277   return (
 278       google_util::IsGoogleDomainUrl(
 279           url,
 280           google_util::ALLOW_SUBDOMAIN,
 281           google_util::DISALLOW_NON_STANDARD_PORTS) &&
 282       url.ReplaceComponents(replacements).path() ==
 283         continue_url.ReplaceComponents(replacements).path());
 284 }
 285
 286 void ForceWebBasedSigninFlowForTesting(bool force) {
 287   g_force_web_based_signin_flow = force;
 288 }
 289
 290 void RegisterProfilePrefs(
 291     user_prefs::PrefRegistrySyncable* registry) {
 292   registry->RegisterIntegerPref(
 293       prefs::kSignInPromoStartupCount,
 294       0,
 295       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 296   registry->RegisterBooleanPref(
 297       prefs::kSignInPromoUserSkipped,
 298       false,
 299       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 300   registry->RegisterBooleanPref(
 301       prefs::kSignInPromoShowOnFirstRunAllowed,
 302       true,
 303       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 304   registry->RegisterBooleanPref(
 305       prefs::kSignInPromoShowNTPBubble,
 306       false,
 307       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 308 }
 309
 310 }  // namespace signin