Upstream version 10.39.225.0
[platform/framework/web/crosswalk.git] / src / content / browser / net / sqlite_persistent_cookie_store_unittest.cc
1 // Copyright (c) 2012 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 "content/browser/net/sqlite_persistent_cookie_store.h"
6
7 #include <map>
8 #include <set>
9
10 #include "base/bind.h"
11 #include "base/callback.h"
12 #include "base/files/file_util.h"
13 #include "base/files/scoped_temp_dir.h"
14 #include "base/memory/ref_counted.h"
15 #include "base/message_loop/message_loop.h"
16 #include "base/sequenced_task_runner.h"
17 #include "base/stl_util.h"
18 #include "base/synchronization/waitable_event.h"
19 #include "base/test/sequenced_worker_pool_owner.h"
20 #include "base/threading/sequenced_worker_pool.h"
21 #include "base/time/time.h"
22 #include "content/public/browser/cookie_crypto_delegate.h"
23 #include "content/public/browser/cookie_store_factory.h"
24 #include "crypto/encryptor.h"
25 #include "crypto/symmetric_key.h"
26 #include "net/cookies/canonical_cookie.h"
27 #include "net/cookies/cookie_constants.h"
28 #include "sql/connection.h"
29 #include "sql/meta_table.h"
30 #include "sql/statement.h"
31 #include "testing/gtest/include/gtest/gtest.h"
32 #include "url/gurl.h"
33
34 namespace content {
35
36 namespace {
37
38 const base::FilePath::CharType kCookieFilename[] = FILE_PATH_LITERAL("Cookies");
39
40 class CookieCryptor : public content::CookieCryptoDelegate {
41  public:
42   CookieCryptor();
43   virtual bool EncryptString(const std::string& plaintext,
44                              std::string* ciphertext) OVERRIDE;
45   virtual bool DecryptString(const std::string& ciphertext,
46                              std::string* plaintext) OVERRIDE;
47
48  private:
49   scoped_ptr<crypto::SymmetricKey> key_;
50   crypto::Encryptor encryptor_;
51 };
52
53 CookieCryptor::CookieCryptor() : key_(
54     crypto::SymmetricKey::DeriveKeyFromPassword(
55         crypto::SymmetricKey::AES, "password", "saltiest", 1000, 256)) {
56   std::string iv("the iv: 16 bytes");
57   encryptor_.Init(key_.get(), crypto::Encryptor::CBC, iv);
58 }
59
60 bool CookieCryptor::EncryptString(const std::string& plaintext,
61                                   std::string* ciphertext) {
62   return encryptor_.Encrypt(plaintext, ciphertext);
63 }
64
65 bool CookieCryptor::DecryptString(const std::string& ciphertext,
66                                   std::string* plaintext) {
67   return encryptor_.Decrypt(ciphertext, plaintext);
68 }
69
70 }  // namespace
71
72 typedef std::vector<net::CanonicalCookie*> CanonicalCookieVector;
73
74 class SQLitePersistentCookieStoreTest : public testing::Test {
75  public:
76   SQLitePersistentCookieStoreTest()
77       : pool_owner_(new base::SequencedWorkerPoolOwner(3, "Background Pool")),
78         loaded_event_(false, false),
79         key_loaded_event_(false, false),
80         db_thread_event_(false, false) {
81   }
82
83   void OnLoaded(const CanonicalCookieVector& cookies) {
84     cookies_ = cookies;
85     loaded_event_.Signal();
86   }
87
88   void OnKeyLoaded(const CanonicalCookieVector& cookies) {
89     cookies_ = cookies;
90     key_loaded_event_.Signal();
91   }
92
93   void Load(CanonicalCookieVector* cookies) {
94     EXPECT_FALSE(loaded_event_.IsSignaled());
95     store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
96                             base::Unretained(this)));
97     loaded_event_.Wait();
98     *cookies = cookies_;
99   }
100
101   void Flush() {
102     base::WaitableEvent event(false, false);
103     store_->Flush(base::Bind(&base::WaitableEvent::Signal,
104                              base::Unretained(&event)));
105     event.Wait();
106   }
107
108   scoped_refptr<base::SequencedTaskRunner> background_task_runner() {
109     return pool_owner_->pool()->GetSequencedTaskRunner(
110         pool_owner_->pool()->GetNamedSequenceToken("background"));
111   }
112
113   scoped_refptr<base::SequencedTaskRunner> client_task_runner() {
114     return pool_owner_->pool()->GetSequencedTaskRunner(
115         pool_owner_->pool()->GetNamedSequenceToken("client"));
116   }
117
118   void DestroyStore() {
119     store_ = NULL;
120     // Make sure we wait until the destructor has run by shutting down the pool
121     // resetting the owner (whose destructor blocks on the pool completion).
122     pool_owner_->pool()->Shutdown();
123     // Create a new pool for the few tests that create multiple stores. In other
124     // cases this is wasted but harmless.
125     pool_owner_.reset(new base::SequencedWorkerPoolOwner(3, "Background Pool"));
126   }
127
128   void CreateAndLoad(bool crypt_cookies,
129                      bool restore_old_session_cookies,
130                      CanonicalCookieVector* cookies) {
131     if (crypt_cookies)
132       cookie_crypto_delegate_.reset(new CookieCryptor());
133
134     store_ = new SQLitePersistentCookieStore(
135         temp_dir_.path().Append(kCookieFilename),
136         client_task_runner(),
137         background_task_runner(),
138         restore_old_session_cookies,
139         NULL,
140         cookie_crypto_delegate_.get());
141     Load(cookies);
142   }
143
144   void InitializeStore(bool crypt, bool restore_old_session_cookies) {
145     CanonicalCookieVector cookies;
146     CreateAndLoad(crypt, restore_old_session_cookies, &cookies);
147     EXPECT_EQ(0U, cookies.size());
148   }
149
150   // We have to create this method to wrap WaitableEvent::Wait, since we cannot
151   // bind a non-void returning method as a Closure.
152   void WaitOnDBEvent() {
153     db_thread_event_.Wait();
154   }
155
156   // Adds a persistent cookie to store_.
157   void AddCookie(const std::string& name,
158                  const std::string& value,
159                  const std::string& domain,
160                  const std::string& path,
161                  const base::Time& creation) {
162     store_->AddCookie(
163         net::CanonicalCookie(GURL(), name, value, domain, path, creation,
164                              creation, creation, false, false,
165                              net::COOKIE_PRIORITY_DEFAULT));
166   }
167
168   std::string ReadRawDBContents() {
169     std::string contents;
170     if (!base::ReadFileToString(temp_dir_.path().Append(kCookieFilename),
171                                 &contents))
172       return std::string();
173     return contents;
174   }
175
176   virtual void SetUp() OVERRIDE {
177     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
178   }
179
180   virtual void TearDown() OVERRIDE {
181     DestroyStore();
182     pool_owner_->pool()->Shutdown();
183   }
184
185  protected:
186   base::MessageLoop main_loop_;
187   scoped_ptr<base::SequencedWorkerPoolOwner> pool_owner_;
188   base::WaitableEvent loaded_event_;
189   base::WaitableEvent key_loaded_event_;
190   base::WaitableEvent db_thread_event_;
191   CanonicalCookieVector cookies_;
192   base::ScopedTempDir temp_dir_;
193   scoped_refptr<SQLitePersistentCookieStore> store_;
194   scoped_ptr<content::CookieCryptoDelegate> cookie_crypto_delegate_;
195 };
196
197 TEST_F(SQLitePersistentCookieStoreTest, TestInvalidMetaTableRecovery) {
198   InitializeStore(false, false);
199   AddCookie("A", "B", "foo.bar", "/", base::Time::Now());
200   DestroyStore();
201
202   // Load up the store and verify that it has good data in it.
203   CanonicalCookieVector cookies;
204   CreateAndLoad(false, false, &cookies);
205   ASSERT_EQ(1U, cookies.size());
206   ASSERT_STREQ("foo.bar", cookies[0]->Domain().c_str());
207   ASSERT_STREQ("A", cookies[0]->Name().c_str());
208   ASSERT_STREQ("B", cookies[0]->Value().c_str());
209   DestroyStore();
210   STLDeleteElements(&cookies);
211
212   // Now corrupt the meta table.
213   {
214     sql::Connection db;
215     ASSERT_TRUE(db.Open(temp_dir_.path().Append(kCookieFilename)));
216     sql::MetaTable meta_table_;
217     meta_table_.Init(&db, 1, 1);
218     ASSERT_TRUE(db.Execute("DELETE FROM meta"));
219     db.Close();
220   }
221
222   // Upon loading, the database should be reset to a good, blank state.
223   CreateAndLoad(false, false, &cookies);
224   ASSERT_EQ(0U, cookies.size());
225
226   // Verify that, after, recovery, the database persists properly.
227   AddCookie("X", "Y", "foo.bar", "/", base::Time::Now());
228   DestroyStore();
229   CreateAndLoad(false, false, &cookies);
230   ASSERT_EQ(1U, cookies.size());
231   ASSERT_STREQ("foo.bar", cookies[0]->Domain().c_str());
232   ASSERT_STREQ("X", cookies[0]->Name().c_str());
233   ASSERT_STREQ("Y", cookies[0]->Value().c_str());
234   STLDeleteElements(&cookies);
235 }
236
237 // Test if data is stored as expected in the SQLite database.
238 TEST_F(SQLitePersistentCookieStoreTest, TestPersistance) {
239   InitializeStore(false, false);
240   AddCookie("A", "B", "foo.bar", "/", base::Time::Now());
241   // Replace the store effectively destroying the current one and forcing it
242   // to write its data to disk. Then we can see if after loading it again it
243   // is still there.
244   DestroyStore();
245   // Reload and test for persistence
246   CanonicalCookieVector cookies;
247   CreateAndLoad(false, false, &cookies);
248   ASSERT_EQ(1U, cookies.size());
249   ASSERT_STREQ("foo.bar", cookies[0]->Domain().c_str());
250   ASSERT_STREQ("A", cookies[0]->Name().c_str());
251   ASSERT_STREQ("B", cookies[0]->Value().c_str());
252
253   // Now delete the cookie and check persistence again.
254   store_->DeleteCookie(*cookies[0]);
255   DestroyStore();
256   STLDeleteElements(&cookies);
257
258   // Reload and check if the cookie has been removed.
259   CreateAndLoad(false, false, &cookies);
260   ASSERT_EQ(0U, cookies.size());
261 }
262
263 // Test that priority load of cookies for a specfic domain key could be
264 // completed before the entire store is loaded
265 TEST_F(SQLitePersistentCookieStoreTest, TestLoadCookiesForKey) {
266   InitializeStore(false, false);
267   base::Time t = base::Time::Now();
268   AddCookie("A", "B", "foo.bar", "/", t);
269   t += base::TimeDelta::FromInternalValue(10);
270   AddCookie("A", "B", "www.aaa.com", "/", t);
271   t += base::TimeDelta::FromInternalValue(10);
272   AddCookie("A", "B", "travel.aaa.com", "/", t);
273   t += base::TimeDelta::FromInternalValue(10);
274   AddCookie("A", "B", "www.bbb.com", "/", t);
275   DestroyStore();
276
277   store_ = new SQLitePersistentCookieStore(
278       temp_dir_.path().Append(kCookieFilename),
279       client_task_runner(),
280       background_task_runner(),
281       false, NULL, NULL);
282
283   // Posting a blocking task to db_thread_ makes sure that the DB thread waits
284   // until both Load and LoadCookiesForKey have been posted to its task queue.
285   background_task_runner()->PostTask(
286       FROM_HERE,
287       base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
288                  base::Unretained(this)));
289   store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
290                           base::Unretained(this)));
291   store_->LoadCookiesForKey("aaa.com",
292     base::Bind(&SQLitePersistentCookieStoreTest::OnKeyLoaded,
293                base::Unretained(this)));
294   background_task_runner()->PostTask(
295       FROM_HERE,
296       base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
297                  base::Unretained(this)));
298
299   // Now the DB-thread queue contains:
300   // (active:)
301   // 1. Wait (on db_event)
302   // (pending:)
303   // 2. "Init And Chain-Load First Domain"
304   // 3. Priority Load (aaa.com)
305   // 4. Wait (on db_event)
306   db_thread_event_.Signal();
307   key_loaded_event_.Wait();
308   ASSERT_EQ(loaded_event_.IsSignaled(), false);
309   std::set<std::string> cookies_loaded;
310   for (CanonicalCookieVector::const_iterator it = cookies_.begin();
311        it != cookies_.end();
312        ++it) {
313     cookies_loaded.insert((*it)->Domain().c_str());
314   }
315   STLDeleteElements(&cookies_);
316   ASSERT_GT(4U, cookies_loaded.size());
317   ASSERT_EQ(true, cookies_loaded.find("www.aaa.com") != cookies_loaded.end());
318   ASSERT_EQ(true,
319             cookies_loaded.find("travel.aaa.com") != cookies_loaded.end());
320
321   db_thread_event_.Signal();
322   loaded_event_.Wait();
323   for (CanonicalCookieVector::const_iterator it = cookies_.begin();
324        it != cookies_.end();
325        ++it) {
326     cookies_loaded.insert((*it)->Domain().c_str());
327   }
328   ASSERT_EQ(4U, cookies_loaded.size());
329   ASSERT_EQ(cookies_loaded.find("foo.bar") != cookies_loaded.end(),
330             true);
331   ASSERT_EQ(cookies_loaded.find("www.bbb.com") != cookies_loaded.end(), true);
332   STLDeleteElements(&cookies_);
333 }
334
335 // Test that we can force the database to be written by calling Flush().
336 TEST_F(SQLitePersistentCookieStoreTest, TestFlush) {
337   InitializeStore(false, false);
338   // File timestamps don't work well on all platforms, so we'll determine
339   // whether the DB file has been modified by checking its size.
340   base::FilePath path = temp_dir_.path().Append(kCookieFilename);
341   base::File::Info info;
342   ASSERT_TRUE(base::GetFileInfo(path, &info));
343   int64 base_size = info.size;
344
345   // Write some large cookies, so the DB will have to expand by several KB.
346   for (char c = 'a'; c < 'z'; ++c) {
347     // Each cookie needs a unique timestamp for creation_utc (see DB schema).
348     base::Time t = base::Time::Now() + base::TimeDelta::FromMicroseconds(c);
349     std::string name(1, c);
350     std::string value(1000, c);
351     AddCookie(name, value, "foo.bar", "/", t);
352   }
353
354   Flush();
355
356   // We forced a write, so now the file will be bigger.
357   ASSERT_TRUE(base::GetFileInfo(path, &info));
358   ASSERT_GT(info.size, base_size);
359 }
360
361 // Test loading old session cookies from the disk.
362 TEST_F(SQLitePersistentCookieStoreTest, TestLoadOldSessionCookies) {
363   InitializeStore(false, true);
364
365   // Add a session cookie.
366   store_->AddCookie(
367       net::CanonicalCookie(
368           GURL(), "C", "D", "sessioncookie.com", "/", base::Time::Now(),
369           base::Time(), base::Time::Now(), false, false,
370           net::COOKIE_PRIORITY_DEFAULT));
371
372   // Force the store to write its data to the disk.
373   DestroyStore();
374
375   // Create a store that loads session cookies and test that the session cookie
376   // was loaded.
377   CanonicalCookieVector cookies;
378   CreateAndLoad(false, true, &cookies);
379
380   ASSERT_EQ(1U, cookies.size());
381   ASSERT_STREQ("sessioncookie.com", cookies[0]->Domain().c_str());
382   ASSERT_STREQ("C", cookies[0]->Name().c_str());
383   ASSERT_STREQ("D", cookies[0]->Value().c_str());
384   ASSERT_EQ(net::COOKIE_PRIORITY_DEFAULT, cookies[0]->Priority());
385
386   STLDeleteElements(&cookies);
387 }
388
389 // Test loading old session cookies from the disk.
390 TEST_F(SQLitePersistentCookieStoreTest, TestDontLoadOldSessionCookies) {
391   InitializeStore(false, true);
392
393   // Add a session cookie.
394   store_->AddCookie(
395       net::CanonicalCookie(
396           GURL(), "C", "D", "sessioncookie.com", "/", base::Time::Now(),
397           base::Time(), base::Time::Now(), false, false,
398           net::COOKIE_PRIORITY_DEFAULT));
399
400   // Force the store to write its data to the disk.
401   DestroyStore();
402
403   // Create a store that doesn't load old session cookies and test that the
404   // session cookie was not loaded.
405   CanonicalCookieVector cookies;
406   CreateAndLoad(false, false, &cookies);
407   ASSERT_EQ(0U, cookies.size());
408
409   // The store should also delete the session cookie. Wait until that has been
410   // done.
411   DestroyStore();
412
413   // Create a store that loads old session cookies and test that the session
414   // cookie is gone.
415   CreateAndLoad(false, true, &cookies);
416   ASSERT_EQ(0U, cookies.size());
417 }
418
419 TEST_F(SQLitePersistentCookieStoreTest, PersistIsPersistent) {
420   InitializeStore(false, true);
421   static const char kSessionName[] = "session";
422   static const char kPersistentName[] = "persistent";
423
424   // Add a session cookie.
425   store_->AddCookie(
426       net::CanonicalCookie(
427           GURL(), kSessionName, "val", "sessioncookie.com", "/",
428           base::Time::Now(), base::Time(), base::Time::Now(), false, false,
429           net::COOKIE_PRIORITY_DEFAULT));
430   // Add a persistent cookie.
431   store_->AddCookie(
432       net::CanonicalCookie(
433           GURL(), kPersistentName, "val", "sessioncookie.com", "/",
434           base::Time::Now() - base::TimeDelta::FromDays(1),
435           base::Time::Now() + base::TimeDelta::FromDays(1),
436           base::Time::Now(), false, false,
437           net::COOKIE_PRIORITY_DEFAULT));
438
439   // Force the store to write its data to the disk.
440   DestroyStore();
441
442   // Create a store that loads session cookie and test that the IsPersistent
443   // attribute is restored.
444   CanonicalCookieVector cookies;
445   CreateAndLoad(false, true, &cookies);
446   ASSERT_EQ(2U, cookies.size());
447
448   std::map<std::string, net::CanonicalCookie*> cookie_map;
449   for (CanonicalCookieVector::const_iterator it = cookies.begin();
450        it != cookies.end();
451        ++it) {
452     cookie_map[(*it)->Name()] = *it;
453   }
454
455   std::map<std::string, net::CanonicalCookie*>::const_iterator it =
456       cookie_map.find(kSessionName);
457   ASSERT_TRUE(it != cookie_map.end());
458   EXPECT_FALSE(cookie_map[kSessionName]->IsPersistent());
459
460   it = cookie_map.find(kPersistentName);
461   ASSERT_TRUE(it != cookie_map.end());
462   EXPECT_TRUE(cookie_map[kPersistentName]->IsPersistent());
463
464   STLDeleteElements(&cookies);
465 }
466
467 TEST_F(SQLitePersistentCookieStoreTest, PriorityIsPersistent) {
468   static const char kLowName[] = "low";
469   static const char kMediumName[] = "medium";
470   static const char kHighName[] = "high";
471   static const char kCookieDomain[] = "sessioncookie.com";
472   static const char kCookieValue[] = "value";
473   static const char kCookiePath[] = "/";
474
475   InitializeStore(false, true);
476
477   // Add a low-priority persistent cookie.
478   store_->AddCookie(
479       net::CanonicalCookie(
480           GURL(), kLowName, kCookieValue, kCookieDomain, kCookiePath,
481           base::Time::Now() - base::TimeDelta::FromMinutes(1),
482           base::Time::Now() + base::TimeDelta::FromDays(1),
483           base::Time::Now(), false, false,
484           net::COOKIE_PRIORITY_LOW));
485
486   // Add a medium-priority persistent cookie.
487   store_->AddCookie(
488       net::CanonicalCookie(
489           GURL(), kMediumName, kCookieValue, kCookieDomain, kCookiePath,
490           base::Time::Now() - base::TimeDelta::FromMinutes(2),
491           base::Time::Now() + base::TimeDelta::FromDays(1),
492           base::Time::Now(), false, false,
493           net::COOKIE_PRIORITY_MEDIUM));
494
495   // Add a high-priority peristent cookie.
496   store_->AddCookie(
497       net::CanonicalCookie(
498           GURL(), kHighName, kCookieValue, kCookieDomain, kCookiePath,
499           base::Time::Now() - base::TimeDelta::FromMinutes(3),
500           base::Time::Now() + base::TimeDelta::FromDays(1),
501           base::Time::Now(), false, false,
502           net::COOKIE_PRIORITY_HIGH));
503
504   // Force the store to write its data to the disk.
505   DestroyStore();
506
507   // Create a store that loads session cookie and test that the priority
508   // attribute values are restored.
509   CanonicalCookieVector cookies;
510   CreateAndLoad(false, true, &cookies);
511   ASSERT_EQ(3U, cookies.size());
512
513   // Put the cookies into a map, by name, so we can easily find them.
514   std::map<std::string, net::CanonicalCookie*> cookie_map;
515   for (CanonicalCookieVector::const_iterator it = cookies.begin();
516        it != cookies.end();
517        ++it) {
518     cookie_map[(*it)->Name()] = *it;
519   }
520
521   // Validate that each cookie has the correct priority.
522   std::map<std::string, net::CanonicalCookie*>::const_iterator it =
523       cookie_map.find(kLowName);
524   ASSERT_TRUE(it != cookie_map.end());
525   EXPECT_EQ(net::COOKIE_PRIORITY_LOW, cookie_map[kLowName]->Priority());
526
527   it = cookie_map.find(kMediumName);
528   ASSERT_TRUE(it != cookie_map.end());
529   EXPECT_EQ(net::COOKIE_PRIORITY_MEDIUM, cookie_map[kMediumName]->Priority());
530
531   it = cookie_map.find(kHighName);
532   ASSERT_TRUE(it != cookie_map.end());
533   EXPECT_EQ(net::COOKIE_PRIORITY_HIGH, cookie_map[kHighName]->Priority());
534
535   STLDeleteElements(&cookies);
536 }
537
538 TEST_F(SQLitePersistentCookieStoreTest, UpdateToEncryption) {
539   CanonicalCookieVector cookies;
540
541   // Create unencrypted cookie store and write something to it.
542   InitializeStore(false, false);
543   AddCookie("name", "value123XYZ", "foo.bar", "/", base::Time::Now());
544   DestroyStore();
545
546   // Verify that "value" is visible in the file.  This is necessary in order to
547   // have confidence in a later test that "encrypted_value" is not visible.
548   std::string contents = ReadRawDBContents();
549   EXPECT_NE(0U, contents.length());
550   EXPECT_NE(contents.find("value123XYZ"), std::string::npos);
551
552   // Create encrypted cookie store and ensure old cookie still reads.
553   STLDeleteElements(&cookies_);
554   EXPECT_EQ(0U, cookies_.size());
555   CreateAndLoad(true, false, &cookies);
556   EXPECT_EQ(1U, cookies_.size());
557   EXPECT_EQ("name", cookies_[0]->Name());
558   EXPECT_EQ("value123XYZ", cookies_[0]->Value());
559
560   // Make sure we can update existing cookie and add new cookie as encrypted.
561   store_->DeleteCookie(*(cookies_[0]));
562   AddCookie("name", "encrypted_value123XYZ", "foo.bar", "/", base::Time::Now());
563   AddCookie("other", "something456ABC", "foo.bar", "/",
564             base::Time::Now() + base::TimeDelta::FromInternalValue(10));
565   DestroyStore();
566   STLDeleteElements(&cookies_);
567   CreateAndLoad(true, false, &cookies);
568   EXPECT_EQ(2U, cookies_.size());
569   net::CanonicalCookie* cookie_name = NULL;
570   net::CanonicalCookie* cookie_other = NULL;
571   if (cookies_[0]->Name() == "name") {
572     cookie_name = cookies_[0];
573     cookie_other = cookies_[1];
574   } else {
575     cookie_name = cookies_[1];
576     cookie_other = cookies_[0];
577   }
578   EXPECT_EQ("encrypted_value123XYZ", cookie_name->Value());
579   EXPECT_EQ("something456ABC", cookie_other->Value());
580   DestroyStore();
581   STLDeleteElements(&cookies_);
582
583   // Examine the real record to make sure plaintext version doesn't exist.
584   sql::Connection db;
585   sql::Statement smt;
586   int resultcount = 0;
587   ASSERT_TRUE(db.Open(temp_dir_.path().Append(kCookieFilename)));
588   smt.Assign(db.GetCachedStatement(SQL_FROM_HERE,
589                                    "SELECT * "
590                                    "FROM cookies "
591                                    "WHERE host_key = 'foo.bar'"));
592   while (smt.Step()) {
593     resultcount++;
594     for (int i=0; i < smt.ColumnCount(); i++) {
595       EXPECT_EQ(smt.ColumnString(i).find("value"), std::string::npos);
596       EXPECT_EQ(smt.ColumnString(i).find("something"), std::string::npos);
597     }
598   }
599   EXPECT_EQ(2, resultcount);
600
601   // Verify that "encrypted_value" is NOT visible in the file.
602   contents = ReadRawDBContents();
603   EXPECT_NE(0U, contents.length());
604   EXPECT_EQ(contents.find("encrypted_value123XYZ"), std::string::npos);
605   EXPECT_EQ(contents.find("something456ABC"), std::string::npos);
606 }
607
608 }  // namespace content