Fix 6 failures in net unittests on Android

net/cookies/cookie_monster_unittest.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 "net/cookies/cookie_store_unittest.h"
 
 #include <time.h>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 966 matching lines @@
   options.set_include_httponly();
 
   EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
 
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "C=D; httponly", options));
   EXPECT_EQ("A=B; C=D", GetCookiesWithOptions(cm, url_google_, options));
 
   EXPECT_EQ(2, DeleteAll(cm));
   EXPECT_EQ("", GetCookiesWithOptions(cm, url_google_, options));
-
+#if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
+  // If a cookie is persistent then its commands will be recorded.
+  // Each above cookie has 2 commands: 1 for add and 1 for delete.
+  EXPECT_EQ(4u, store->commands().size());
+#else
   EXPECT_EQ(0u, store->commands().size());
+#endif
 
   // Create a persistent cookie.
   EXPECT_TRUE(SetCookie(cm, url_google_,
                         std::string(kValidCookieLine) +
                         "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+#if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
+  ASSERT_EQ(5u, store->commands().size());
+  EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
+#else
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
+#endif
 
   EXPECT_EQ(1, DeleteAll(cm));  // sync_to_store = true.
+#if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
+  ASSERT_EQ(6u, store->commands().size());
+  EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[5].type);
+#else
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
+#endif
 
   EXPECT_EQ("", GetCookiesWithOptions(cm, url_google_, options));
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   Time now = Time::Now();
 
   // Nothing has been added so nothing should be deleted.
   EXPECT_EQ(0, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(99),
@@ skipping 414 matching lines @@
   delegate->reset();
 
   EXPECT_FALSE(FindAndDeleteCookie(cm, "random.host", "E"));
   EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
   EXPECT_EQ(0u, delegate->changes().size());
 
   // Insert a cookie "a" for path "/path1"
   EXPECT_TRUE(
       SetCookie(cm, url_google_, "a=val1; path=/path1; "
                                 "expires=Mon, 18-Apr-22 22:50:13 GMT"));
+#if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
+  ASSERT_EQ(5u, store->commands().size());
+  EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
+#else
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
+#endif
   ASSERT_EQ(1u, delegate->changes().size());
   EXPECT_FALSE(delegate->changes()[0].second);
   EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
   EXPECT_EQ("a", delegate->changes()[0].first.Name());
   EXPECT_EQ("val1", delegate->changes()[0].first.Value());
   delegate->reset();
 
   // Insert a cookie "a" for path "/path1", that is httponly. This should
   // overwrite the non-http-only version.
   CookieOptions allow_httponly;
   allow_httponly.set_include_httponly();
   EXPECT_TRUE(
     SetCookieWithOptions(cm, url_google_,
                          "a=val2; path=/path1; httponly; "
                          "expires=Mon, 18-Apr-22 22:50:14 GMT",
                          allow_httponly));
+#if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
+  ASSERT_EQ(7u, store->commands().size());
+  EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[5].type);
+  EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[6].type);
+#else
   ASSERT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
+#endif
   ASSERT_EQ(2u, delegate->changes().size());
   EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
   EXPECT_TRUE(delegate->changes()[0].second);
   EXPECT_EQ("a", delegate->changes()[0].first.Name());
   EXPECT_EQ("val1", delegate->changes()[0].first.Value());
   EXPECT_EQ(url_google_.host(), delegate->changes()[1].first.Domain());
   EXPECT_FALSE(delegate->changes()[1].second);
   EXPECT_EQ("a", delegate->changes()[1].first.Name());
   EXPECT_EQ("val2", delegate->changes()[1].first.Value());
   delegate->reset();
@@ skipping 30 matching lines @@
       false, false));
 
   CookieList cookies = GetAllCookiesForURL(cm, url_google_foo_);
   CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("A", it->Name());
   EXPECT_EQ("B", it->Value());
   EXPECT_EQ("www.google.izzle", it->Domain());
   EXPECT_EQ("/foo", it->Path());
+#if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
+  EXPECT_TRUE(it->IsPersistent());
+#else
   EXPECT_FALSE(it->IsPersistent());
+#endif
   EXPECT_FALSE(it->IsSecure());
   EXPECT_FALSE(it->IsHttpOnly());
 
   ASSERT_TRUE(++it == cookies.end());
 
   cookies = GetAllCookiesForURL(cm, url_google_bar_);
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("C", it->Name());
@@ skipping 541 matching lines @@
       false, false));
 
   base::Histogram::SampleSet histogram_set_2;
   expired_histogram->SnapshotSample(&histogram_set_2);
   EXPECT_EQ(histogram_set_1.TotalCount() + 1,
             histogram_set_2.TotalCount());
 
   // kValidCookieLine creates a session cookie.
   ASSERT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
   expired_histogram->SnapshotSample(&histogram_set_1);
+#if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
+  EXPECT_EQ(histogram_set_2.TotalCount() + 1,
+            histogram_set_1.TotalCount());
+#else
   EXPECT_EQ(histogram_set_2.TotalCount(),
             histogram_set_1.TotalCount());
+#endif
 }
 
 namespace {
 
 class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
  public:
   MultiThreadedCookieMonsterTest() : other_thread_("CMTthread") {}
 
   // Helper methods for calling the asynchronous CookieMonster methods
   // from a different thread.
@@ skipping 218 matching lines @@
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_TRUE(callback.result());
 }
 
 TEST_F(CookieMonsterTest, InvalidExpiryTime) {
   ParsedCookie pc(std::string(kValidCookieLine) + "; expires=Blarg arg arg");
   scoped_ptr<CookieMonster::CanonicalCookie> cookie(
       CookieMonster::CanonicalCookie::Create(url_google_, pc));
 
+#if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
+  ASSERT_TRUE(cookie->IsPersistent());
+#else
   ASSERT_FALSE(cookie->IsPersistent());
+#endif
 }
 
 // Test that CookieMonster writes session cookies into the underlying
 // CookieStore if the "persist session cookies" option is on.
 TEST_F(CookieMonsterTest, PersistSessionCookies) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
   cm->SetPersistSessionCookies(true);
 
@@ skipping 56 matching lines @@
                         "A=Foo; expires=Mon, 18-Apr-22 22:50:14 GMT"));
   this->MatchCookieLines("A=Foo", GetCookies(cm, url_google_));
   ASSERT_EQ(5u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
 
   // Create some non-persistent cookies and check that they don't go to the
   // persistent storage.
   EXPECT_TRUE(SetCookie(cm, url_google_, "B=Bar"));
   this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm, url_google_));
+#if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
+  EXPECT_EQ(6u, store->commands().size());
+#else
   EXPECT_EQ(5u, store->commands().size());
+#endif
 }
 
 }  // namespace net