mandoline filesystem: Save cookie data to the mojo:filesystem.

net/extras/sqlite/sqlite_persistent_cookie_store_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/extras/sqlite/sqlite_persistent_cookie_store.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 109 matching lines @@
   void DestroyStore() {
     store_ = nullptr;
     // Make sure we wait until the destructor has run by shutting down the pool
     // resetting the owner (whose destructor blocks on the pool completion).
     pool_owner_->pool()->Shutdown();
     // Create a new pool for the few tests that create multiple stores. In other
     // cases this is wasted but harmless.
     pool_owner_.reset(new base::SequencedWorkerPoolOwner(3, "Background Pool"));
   }
 
-  void CreateAndLoad(bool crypt_cookies,
-                     bool restore_old_session_cookies,
-                     CanonicalCookieVector* cookies) {
+  void Create(bool crypt_cookies, bool restore_old_session_cookies) {
     if (crypt_cookies)
       cookie_crypto_delegate_.reset(new CookieCryptor());
 
     store_ = new SQLitePersistentCookieStore(
         temp_dir_.path().Append(kCookieFilename), client_task_runner(),
         background_task_runner(), restore_old_session_cookies,
         cookie_crypto_delegate_.get());
+  }
+
+  void CreateAndLoad(bool crypt_cookies,
+                     bool restore_old_session_cookies,
+                     CanonicalCookieVector* cookies) {
+    Create(crypt_cookies, restore_old_session_cookies);
     Load(cookies);
   }
 
   void InitializeStore(bool crypt, bool restore_old_session_cookies) {
     CanonicalCookieVector cookies;
     CreateAndLoad(crypt, restore_old_session_cookies, &cookies);
     EXPECT_EQ(0U, cookies.size());
   }
 
   // We have to create this method to wrap WaitableEvent::Wait, since we cannot
@@ skipping 503 matching lines @@
   }
   EXPECT_EQ(2, resultcount);
 
   // Verify that "encrypted_value" is NOT visible in the file.
   contents = ReadRawDBContents();
   EXPECT_NE(0U, contents.length());
   EXPECT_EQ(contents.find("encrypted_value123XYZ"), std::string::npos);
   EXPECT_EQ(contents.find("something456ABC"), std::string::npos);
 }
 
+namespace {
+void WasCalledWithNoCookies(bool* was_called_with_no_cookies,
+                            const std::vector<CanonicalCookie*>& cookies) {
+  *was_called_with_no_cookies = cookies.empty();
+}
+}
+
+TEST_F(SQLitePersistentCookieStoreTest, EmptyLoadAfterClose) {
+  // Create unencrypted cookie store and write something to it.
+  InitializeStore(false, false);
+  AddCookie("name", "value123XYZ", "foo.bar", "/", base::Time::Now());
+  DestroyStore();
+
+  // Create the cookie store, but immediately close it.
+  Create(false, false);
+  store_->Close(base::Closure());
+
+  // Expect any attempt to call Load() to synchronously respond with an empty
+  // vector of cookies after we've Close()d the database.
+  bool was_called_with_no_cookies = false;
+  store_->Load(base::Bind(WasCalledWithNoCookies, &was_called_with_no_cookies));
+  EXPECT_TRUE(was_called_with_no_cookies);
+
+  // Same with trying to load a specific cookie.
+  was_called_with_no_cookies = false;
+  store_->LoadCookiesForKey("foo.bar", base::Bind(WasCalledWithNoCookies,
+                                                  &was_called_with_no_cookies));
+  EXPECT_TRUE(was_called_with_no_cookies);
+}
+
 }  // namespace net