Add test for showing confirmation dialog for unsecure signin

google_apis/gaia/fake_gaia.cc

 // Copyright (c) 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 "google_apis/gaia/fake_gaia.h"
 
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 23 matching lines @@
         url.path(), base::Bind(&FakeGaia::method, base::Unretained(this))))
 
 #define REGISTER_PATH_RESPONSE_HANDLER(path, method) \
   request_handlers_.insert(std::make_pair( \
         path, base::Bind(&FakeGaia::method, base::Unretained(this))))
 
 using namespace net::test_server;
 
 namespace {
 
+const char kTestAuthCode[] = "fake-auth-code";
+const char kTestGaiaUberToken[] = "fake-uber-token";
+const char kTestAuthLoginAccessToken[] = "fake-access-token";
+const char kTestRefreshToken[] = "fake-refresh-token";
+const char kTestSessionSIDCookie[] = "fake-session-SID-cookie";
+const char kTestSessionLSIDCookie[] = "fake-session-LSID-cookie";
+const char kTestOAuthLoginSID[] = "fake-oauth-SID-cookie";
+const char kTestOAuthLoginLSID[] = "fake-oauth-LSID-cookie";
+const char kTestOAuthLoginAuthCode[] = "fake-oauth-auth-code";
+
 const base::FilePath::CharType kServiceLogin[] =
     FILE_PATH_LITERAL("google_apis/test/service_login.html");
 
 // OAuth2 Authentication header value prefix.
 const char kAuthHeaderBearer[] = "Bearer ";
 const char kAuthHeaderOAuth[] = "OAuth ";
 
 const char kListAccountsResponseFormat[] =
     "[\"gaia.l.a.r\",[[\"gaia.l.a\",1,\"\",\"%s\",\"\",1,1,0]]]";
 
@@ skipping 70 matching lines @@
 FakeGaia::FakeGaia() {
   base::FilePath source_root_dir;
   PathService::Get(base::DIR_SOURCE_ROOT, &source_root_dir);
   CHECK(base::ReadFileToString(
       source_root_dir.Append(base::FilePath(kServiceLogin)),
       &service_login_response_));
 }
 
 FakeGaia::~FakeGaia() {}
 
+void FakeGaia::SetFakeMergeSessionParams(
+    const std::string& email,
+    const std::string& auth_sid_cookie,
+    const std::string& auth_lsid_cookie) {
+  FakeGaia::MergeSessionParams params;
+  params.auth_sid_cookie = auth_sid_cookie;
+  params.auth_lsid_cookie = auth_lsid_cookie;
+  params.auth_code = kTestAuthCode;
+  params.refresh_token = kTestRefreshToken;
+  params.access_token = kTestAuthLoginAccessToken;
+  params.gaia_uber_token = kTestGaiaUberToken;
+  params.session_sid_cookie = kTestSessionSIDCookie;
+  params.session_lsid_cookie = kTestSessionLSIDCookie;
+  params.email = email;
+  SetMergeSessionParams(params);
+}
+
 void FakeGaia::SetMergeSessionParams(
     const MergeSessionParams& params) {
   merge_session_params_ = params;
 }
 
 void FakeGaia::Initialize() {
   GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
   // Handles /MergeSession GAIA call.
   REGISTER_RESPONSE_HANDLER(
       gaia_urls->merge_session_url(), HandleMergeSession);
@@ skipping 25 matching lines @@
   REGISTER_RESPONSE_HANDLER(
       gaia_urls->oauth2_token_info_url(), HandleTokenInfo);
 
   // Handles /oauth2/v2/IssueToken GAIA call.
   REGISTER_RESPONSE_HANDLER(
       gaia_urls->oauth2_issue_token_url(), HandleIssueToken);
 
   // Handles /ListAccounts GAIA call.
   REGISTER_RESPONSE_HANDLER(
       gaia_urls->list_accounts_url(), HandleListAccounts);
+
+  // Handles /GetUserInfo GAIA call.
+  REGISTER_RESPONSE_HANDLER(
+      gaia_urls->get_user_info_url(), HandleGetUserInfo);
 }
 
 scoped_ptr<HttpResponse> FakeGaia::HandleRequest(const HttpRequest& request) {
   // The scheme and host of the URL is actually not important but required to
   // get a valid GURL in order to parse |request.relative_url|.
   GURL request_url = GURL("http://localhost").Resolve(request.relative_url);
   std::string request_path = request_url.path();
   scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
   RequestHandlerMap::iterator iter = request_handlers_.find(request_path);
   if (iter != request_handlers_.end()) {
@@ skipping 149 matching lines @@
 
 void FakeGaia::HandleOAuthLogin(const HttpRequest& request,
                                 BasicHttpResponse* http_response) {
   http_response->set_code(net::HTTP_UNAUTHORIZED);
   if (merge_session_params_.gaia_uber_token.empty()) {
     http_response->set_code(net::HTTP_FORBIDDEN);
     return;
   }
 
   std::string access_token;
-  if (!GetAccessToken(request, kAuthHeaderOAuth, &access_token)) {
+  if (!GetAccessToken(request, kAuthHeaderBearer, &access_token) &&
+      !GetAccessToken(request, kAuthHeaderOAuth, &access_token)) {
     LOG(ERROR) << "/OAuthLogin missing access token in the header";
     return;
   }
 
   GURL request_url = GURL("http://localhost").Resolve(request.relative_url);
   std::string request_query = request_url.query();
 
   std::string source;
-  if (!GetQueryParameter(request_query, "source", &source)) {
+  if (!GetQueryParameter(request_query, "source", &source) &&
+      !GetQueryParameter(request.content, "source", &source)) {
     LOG(ERROR) << "Missing 'source' param in /OAuthLogin call";
     return;
   }
 
   std::string issue_uberauth;
   if (GetQueryParameter(request_query, "issueuberauth", &issue_uberauth) &&
       issue_uberauth == "1") {
     http_response->set_content(merge_session_params_.gaia_uber_token);
     http_response->set_code(net::HTTP_OK);
     // Issue GAIA uber token.
   } else {
-    LOG(FATAL) << "/OAuthLogin for SID/LSID is not supported";
+    http_response->set_content(base::StringPrintf(
+        "SID=%s\nLSID=%s\nAuth=%s",
+        kTestOAuthLoginSID, kTestOAuthLoginLSID, kTestOAuthLoginAuthCode));
+    http_response->set_code(net::HTTP_OK);
   }
 }
 
 void FakeGaia::HandleServiceLoginAuth(const HttpRequest& request,
                                       BasicHttpResponse* http_response) {
   std::string continue_url =
       GaiaUrls::GetInstance()->service_login_url().spec();
   GetQueryParameter(request.content, "continue", &continue_url);
 
   std::string redirect_url = continue_url;
 
   std::string email;
   if (GetQueryParameter(request.content, "Email", &email) &&
       saml_account_idp_map_.find(email) != saml_account_idp_map_.end()) {
     GURL url(saml_account_idp_map_[email]);
     url = net::AppendQueryParameter(url, "SAMLRequest", "fake_request");
     url = net::AppendQueryParameter(url, "RelayState", continue_url);
     redirect_url = url.spec();
     http_response->AddCustomHeader("Google-Accounts-SAML", "Start");
   } else if (!merge_session_params_.auth_sid_cookie.empty() &&
              !merge_session_params_.auth_lsid_cookie.empty()) {
     SetCookies(http_response,
                merge_session_params_.auth_sid_cookie,
                merge_session_params_.auth_lsid_cookie);
   }
 
   http_response->set_code(net::HTTP_TEMPORARY_REDIRECT);
   http_response->AddCustomHeader("Location", redirect_url);
+  http_response->AddCustomHeader("google-accounts-signin",
+      base::StringPrintf("email=\"%s\", sessionindex=0", email.c_str()));
 }
 
 void FakeGaia::HandleSSO(const HttpRequest& request,
                          BasicHttpResponse* http_response) {
   if (!merge_session_params_.auth_sid_cookie.empty() &&
       !merge_session_params_.auth_lsid_cookie.empty()) {
     SetCookies(http_response,
                merge_session_params_.auth_sid_cookie,
                merge_session_params_.auth_lsid_cookie);
   }
@@ skipping 113 matching lines @@
                               base::IntToString(token_info->expires_in));
       response_dict.SetString("token", token_info->token);
       FormatJSONResponse(response_dict, http_response);
       return;
     }
   }
   http_response->set_code(net::HTTP_BAD_REQUEST);
 }
 
 void FakeGaia::HandleListAccounts(const HttpRequest& request,
-                                 BasicHttpResponse* http_response) {
+                                  BasicHttpResponse* http_response) {
   http_response->set_content(base::StringPrintf(
       kListAccountsResponseFormat, merge_session_params_.email.c_str()));
   http_response->set_code(net::HTTP_OK);
 }
+
+void FakeGaia::HandleGetUserInfo(const HttpRequest& request,
+                                 BasicHttpResponse* http_response) {
+  http_response->set_content(base::StringPrintf(
+      "email=%s\ndisplayEmail=%s",
+      merge_session_params_.email.c_str(),
+      merge_session_params_.email.c_str()));
+  http_response->set_code(net::HTTP_OK);
+}