Fix copying of SAML IdP cookies on subsequent logins

chrome/browser/chromeos/login/profile_auth_data_unittest.cc

 // Copyright 2014 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/chromeos/login/profile_auth_data.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 29 matching lines @@
 const char kProxyAuthRealm[] = "realm";
 const char kProxyAuthChallenge[] = "challenge";
 const char kProxyAuthPassword1[] = "password 1";
 const char kProxyAuthPassword2[] = "password 2";
 
 const char kGAIACookieURL[] = "http://google.com/";
 const char kSAMLIdPCookieURL[] = "http://example.com/";
 const char kCookieName[] = "cookie";
 const char kCookieValue1[] = "value 1";
 const char kCookieValue2[] = "value 2";
-const char kGAIACookieDomain[] = ".google.com";
-const char kSAMLIdPCookieDomain[] = ".example.com";
+const char kGAIACookieDomain[] = "google.com";
+const char kSAMLIdPCookieDomain[] = "example.com";
 
 const char kChannelIDServerIdentifier[] = "server";
 const char kChannelIDPrivateKey1[] = "private key 1";
 const char kChannelIDPrivateKey2[] = "private key 2";
 const char kChannelIDCert1[] = "cert 1";
 const char kChannelIDCert2[] = "cert 2";
 
 }  // namespace
 
 class ProfileAuthDataTest : public testing::Test {
@@ skipping 22 matching lines @@
                               const std::string& cookie_value,
                               const std::string& channel_id_private_key,
                               const std::string& channel_id_cert);
 
   net::URLRequestContext* GetRequestContext(
       content::BrowserContext* browser_context);
   net::HttpAuthCache* GetProxyAuth(content::BrowserContext* browser_context);
   net::CookieMonster* GetCookies(content::BrowserContext* browser_context);
   net::ChannelIDStore* GetChannelIDs(content::BrowserContext* browser_context);
 
-  void QuitLoop(bool ignored);
+  void QuitLoop(const net::CookieList& ignored);
   void StoreCookieListAndQuitLoop(const net::CookieList& cookie_list);
   void StoreChannelIDListAndQuitLoop(
       const net::ChannelIDStore::ChannelIDList& channel_id_list);
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   TestingProfile login_browser_context_;
   TestingProfile user_browser_context_;
 
   net::CookieList user_cookie_list_;
@@ skipping 66 matching lines @@
   EXPECT_EQ(base::ASCIIToUTF16(kProxyAuthPassword1),
             entry->credentials().password());
 }
 
 void ProfileAuthDataTest::VerifyUserCookies(
     const std::string& expected_gaia_cookie_value,
     const std::string& expected_saml_idp_cookie_value) {
   net::CookieList user_cookies = GetUserCookies();
   ASSERT_EQ(2u, user_cookies.size());
   net::CanonicalCookie* cookie = &user_cookies[0];
+  EXPECT_EQ(kSAMLIdPCookieURL, cookie->Source());
+  EXPECT_EQ(kCookieName, cookie->Name());
+  EXPECT_EQ(expected_saml_idp_cookie_value, cookie->Value());
+  EXPECT_EQ(kSAMLIdPCookieDomain, cookie->Domain());
+  cookie = &user_cookies[1];
   EXPECT_EQ(kGAIACookieURL, cookie->Source());
   EXPECT_EQ(kCookieName, cookie->Name());
   EXPECT_EQ(expected_gaia_cookie_value, cookie->Value());
-  cookie = &user_cookies[1];
-  EXPECT_EQ(kSAMLIdPCookieURL, cookie->Source());
-  EXPECT_EQ(kCookieName, cookie->Name());
-  EXPECT_EQ(expected_saml_idp_cookie_value, cookie->Value());
+  EXPECT_EQ(kGAIACookieDomain, cookie->Domain());
 }
 
 void ProfileAuthDataTest::VerifyUserChannelID(
     const std::string& expected_private_key,
     const std::string& expected_cert) {
   net::ChannelIDStore::ChannelIDList user_channel_ids = GetUserChannelIDs();
   ASSERT_EQ(1u, user_channel_ids.size());
   net::ChannelIDStore::ChannelID* channel_id = &user_channel_ids.front();
   EXPECT_EQ(kChannelIDServerIdentifier, channel_id->server_identifier());
   EXPECT_EQ(expected_private_key, channel_id->private_key());
   EXPECT_EQ(expected_cert, channel_id->cert());
 }
 
 void ProfileAuthDataTest::PopulateBrowserContext(
     content::BrowserContext* browser_context,
     const std::string& proxy_auth_password,
     const std::string& cookie_value,
     const std::string& channel_id_private_key,
     const std::string& channel_id_cert) {
   GetProxyAuth(browser_context)->Add(
       GURL(kProxyAuthURL),
       kProxyAuthRealm,
       net::HttpAuth::AUTH_SCHEME_BASIC,
       kProxyAuthChallenge,
       net::AuthCredentials(base::string16(),
                            base::ASCIIToUTF16(proxy_auth_password)),
       std::string());
 
   net::CookieMonster* cookies = GetCookies(browser_context);
+  // Ensure |cookies| is fully initialized.
   run_loop_.reset(new base::RunLoop);
-  cookies->SetCookieWithDetailsAsync(
-      GURL(kGAIACookieURL),
-      kCookieName,
-      cookie_value,
-      kGAIACookieDomain,
-      std::string(),
-      base::Time(),
-      true,
-      false,
-      net::COOKIE_PRIORITY_DEFAULT,
-      base::Bind(&ProfileAuthDataTest::QuitLoop, base::Unretained(this)));
+  cookies->GetAllCookiesAsync(base::Bind(&ProfileAuthDataTest::QuitLoop,
+                                         base::Unretained(this)));
   run_loop_->Run();
-  run_loop_.reset(new base::RunLoop);
-  cookies->SetCookieWithDetailsAsync(
-      GURL(kSAMLIdPCookieURL),
-      kCookieName,
-      cookie_value,
-      kSAMLIdPCookieDomain,
-      std::string(),
-      base::Time(),
-      true,
-      false,
-      net::COOKIE_PRIORITY_DEFAULT,
-      base::Bind(&ProfileAuthDataTest::QuitLoop, base::Unretained(this)));
-  run_loop_->Run();
+
+  net::CookieList cookie_list;
+  cookie_list.push_back(net::CanonicalCookie(GURL(kGAIACookieURL),
+                                             kCookieName,
+                                             cookie_value,
+                                             kGAIACookieDomain,
+                                             std::string(),
+                                             base::Time(),
+                                             base::Time(),
+                                             base::Time(),
+                                             true,
+                                             false,
+                                             net::COOKIE_PRIORITY_DEFAULT));
+  cookie_list.push_back(net::CanonicalCookie(GURL(kSAMLIdPCookieURL),
+                                             kCookieName,
+                                             cookie_value,
+                                             kSAMLIdPCookieDomain,
+                                             std::string(),
+                                             base::Time(),
+                                             base::Time(),
+                                             base::Time(),
+                                             true,
+                                             false,
+                                             net::COOKIE_PRIORITY_DEFAULT));
+  cookies->ImportCookies(cookie_list);
 
   GetChannelIDs(browser_context)->SetChannelID(kChannelIDServerIdentifier,
                                                base::Time(),
                                                base::Time(),
                                                channel_id_private_key,
                                                channel_id_cert);
 }
 
 net::URLRequestContext* ProfileAuthDataTest::GetRequestContext(
     content::BrowserContext* browser_context) {
@@ skipping 10 matching lines @@
     content::BrowserContext* browser_context) {
   return GetRequestContext(browser_context)->cookie_store()->GetCookieMonster();
 }
 
 net::ChannelIDStore* ProfileAuthDataTest::GetChannelIDs(
     content::BrowserContext* browser_context) {
   return GetRequestContext(browser_context)->channel_id_service()->
       GetChannelIDStore();
 }
 
-void ProfileAuthDataTest::QuitLoop(bool ignored) {
+void ProfileAuthDataTest::QuitLoop(const net::CookieList& ignored) {
   run_loop_->Quit();
 }
 
 void ProfileAuthDataTest::StoreCookieListAndQuitLoop(
     const net::CookieList& cookie_list) {
   user_cookie_list_ = cookie_list;
   run_loop_->Quit();
 }
 
 void ProfileAuthDataTest::StoreChannelIDListAndQuitLoop(
@@ skipping 43 matching lines @@
   PopulateUserBrowserContext();
 
   Transfer(false, true);
 
   VerifyTransferredUserProxyAuthEntry();
   VerifyUserCookies(kCookieValue2, kCookieValue1);
   VerifyUserChannelID(kChannelIDPrivateKey2, kChannelIDCert2);
 }
 
 }  // namespace chromeos