Export a private webstore API to call into the new inline sign-in flow.

chrome/browser/signin/signin_promo.cc

 // Copyright 2013 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/signin/signin_promo.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 22 matching lines @@
 #include "google_apis/gaia/gaia_urls.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/escape.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/url_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::WebContents;
+using net::GetValueForKeyInQuery;
 
 namespace {
 
 const char kSignInPromoQueryKeyAutoClose[] = "auto_close";
 const char kSignInPromoQueryKeyContinue[] = "continue";
+const char kSignInPromoQueryKeyContinueUrl[] = "continue_url";
 const char kSignInPromoQueryKeySource[] = "source";
 const char kSignInPromoQueryKeyConstrained[] = "constrained";
 
 // Gaia cannot support about:blank as a continue URL, so using a hosted blank
 // page instead.
 const char kSignInLandingUrlPrefix[] =
     "https://www.google.com/intl/%s/chrome/blank.html";
 
 // The maximum number of times we want to show the sign in promo at startup.
 const int kSignInPromoShowAtStartupMaximum = 10;
@@ skipping 113 matching lines @@
   std::string url = base::StringPrintf(kSignInLandingUrlPrefix, locale.c_str());
   base::StringAppendF(&url, "?%s=%d", option, value);
   return GURL(url);
 }
 
 GURL GetPromoURL(Source source, bool auto_close) {
   return GetPromoURL(source, auto_close, false /* is_constrained */);
 }
 
 GURL GetPromoURL(Source source, bool auto_close, bool is_constrained) {
+  return GetPromoURLWithContinueURL(source, auto_close, is_constrained, GURL());
+}
+
+GURL GetPromoURLWithContinueURL(Source source,
+                                bool auto_close,
+                                bool is_constrained,
+                                GURL continue_url) {
   DCHECK_NE(SOURCE_UNKNOWN, source);
 
   if (!switches::IsEnableWebBasedSignin()) {
     std::string url(chrome::kChromeUIChromeSigninURL);
     base::StringAppendF(&url, "?%s=%d", kSignInPromoQueryKeySource, source);
     if (auto_close)
       base::StringAppendF(&url, "&%s=1", kSignInPromoQueryKeyAutoClose);
     if (is_constrained)
       base::StringAppendF(&url, "&%s=1", kSignInPromoQueryKeyConstrained);
+    if (!continue_url.is_empty()) {
+      DCHECK(continue_url.is_valid());
+      std::string escaped_continue_url =
+          net::EscapeQueryParamValue(continue_url.spec(), false);
+      base::StringAppendF(&url,
+                          "&%s=%s",
+                          kSignInPromoQueryKeyContinueUrl,
+                          escaped_continue_url.c_str());
+    }
     return GURL(url);
   }
 
   // Build a Gaia-based URL that can be used to sign the user into chrome.
   // There are required request parameters:
   //
   //  - tell Gaia which service the user is signing into.  In this case,
   //    a chrome sign in uses the service "chromiumsync"
   //  - provide a continue URL.  This is the URL that Gaia will redirect to
   //    once the sign is complete.
   //
   // The continue URL includes a source parameter that can be extracted using
   // the function GetSourceForSignInPromoURL() below.  This is used to know
   // which of the chrome sign in access points was used to sign the user in.
   // It is also parsed for the |auto_close| flag, which indicates that the tab
   // must be closed after sync setup is successful.
   // See OneClickSigninHelper for details.
   std::string query_string = "?service=chromiumsync&sarp=1";
 
-  std::string continue_url = GetLandingURL(kSignInPromoQueryKeySource,
-                                           static_cast<int>(source)).spec();
-  if (auto_close)
-    base::StringAppendF(&continue_url, "&%s=1", kSignInPromoQueryKeyAutoClose);
+  DCHECK(continue_url.is_empty());
+  std::string continue_url_str = GetLandingURL(kSignInPromoQueryKeySource,
+                                               static_cast<int>(source)).spec();
+  if (auto_close) {
+    base::StringAppendF(
+        &continue_url_str, "&%s=1", kSignInPromoQueryKeyAutoClose);
+  }
 
-  base::StringAppendF(&query_string, "&%s=%s", kSignInPromoQueryKeyContinue,
-                      net::EscapeQueryParamValue(
-                          continue_url, false).c_str());
+  base::StringAppendF(
+      &query_string,
+      "&%s=%s",
+      kSignInPromoQueryKeyContinue,
+      net::EscapeQueryParamValue(continue_url_str, false).c_str());
 
   return GaiaUrls::GetInstance()->service_login_url().Resolve(query_string);
 }
 
 GURL GetReauthURL(Profile* profile, const std::string& account_id) {
   if (switches::IsEnableWebBasedSignin()) {
     return net::AppendQueryParameter(
         signin::GetPromoURL(signin::SOURCE_SETTINGS, true),
         "Email",
         account_id);
   }
 
   const std::string primary_account_id =
     SigninManagerFactory::GetForProfile(profile)->
         GetAuthenticatedAccountId();
   signin::Source source = account_id == primary_account_id ?
       signin::SOURCE_SETTINGS : signin::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT;
 
   GURL url = signin::GetPromoURL(source, true);
   url = net::AppendQueryParameter(url, "email", account_id);
   url = net::AppendQueryParameter(url, "validateEmail", "1");
   return net::AppendQueryParameter(url, "readOnlyEmail", "1");
 }
 
 GURL GetNextPageURLForPromoURL(const GURL& url) {
   std::string value;
-  if (net::GetValueForKeyInQuery(url, kSignInPromoQueryKeyContinue, &value))
+  if (GetValueForKeyInQuery(url, kSignInPromoQueryKeyContinue, &value))
     return GURL(value);
 
+  value = std::string();
+  if (GetValueForKeyInQuery(url, kSignInPromoQueryKeyContinueUrl, &value)) {
+    GURL continue_url = GURL(value);
+    if (continue_url.is_valid())
+      return continue_url;
+  }
+
   return GURL();
 }
 
 Source GetSourceForPromoURL(const GURL& url) {
   std::string value;
-  if (net::GetValueForKeyInQuery(url, kSignInPromoQueryKeySource, &value)) {
+  if (GetValueForKeyInQuery(url, kSignInPromoQueryKeySource, &value)) {
     int source = 0;
     if (base::StringToInt(value, &source) && source >= SOURCE_START_PAGE &&
         source < SOURCE_UNKNOWN) {
       return static_cast<Source>(source);
     }
   }
   return SOURCE_UNKNOWN;
 }
 
 bool IsAutoCloseEnabledInURL(const GURL& url) {
   std::string value;
-  if (net::GetValueForKeyInQuery(url, kSignInPromoQueryKeyAutoClose, &value)) {
+  if (GetValueForKeyInQuery(url, kSignInPromoQueryKeyAutoClose, &value)) {
     int enabled = 0;
     if (base::StringToInt(value, &enabled) && enabled == 1)
       return true;
   }
   return false;
 }
 
 bool IsContinueUrlForWebBasedSigninFlow(const GURL& url) {
   GURL::Replacements replacements;
   replacements.ClearQuery();
@@ skipping 27 matching lines @@
       prefs::kSignInPromoShowOnFirstRunAllowed,
       true,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterBooleanPref(
       prefs::kSignInPromoShowNTPBubble,
       false,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 }  // namespace signin