Reinitialize the cookie database if the meta table gets corrupted.

chrome/browser/net/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 "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/thread_test_helper.h"
 #include "base/time.h"
 #include "chrome/browser/net/sqlite_persistent_cookie_store.h"
 #include "chrome/common/chrome_constants.h"
 #include "content/test/test_browser_thread.h"
 #include "googleurl/src/gurl.h"
+#include "sql/connection.h"
+#include "sql/meta_table.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
 class SQLitePersistentCookieStoreTest : public testing::Test {
  public:
   SQLitePersistentCookieStoreTest()
       : ui_thread_(BrowserThread::UI),
         db_thread_(BrowserThread::DB),
         io_thread_(BrowserThread::IO),
@@ skipping 101 matching lines @@
   InitializeStore(false);
   // Put some data - any data - on disk, to have something to remove.
   AddCookie("A", "B", "http://foo.bar", "/", base::Time::Now());
   store_->SetClearLocalStateOnExit(true);
   DestroyStore();
 
   ASSERT_FALSE(file_util::PathExists(
       temp_dir_.path().Append(chrome::kCookieFilename)));
 }
 
+TEST_F(SQLitePersistentCookieStoreTest, TestInvalidMetaTableRecovery) {
+  InitializeStore(false);
+  AddCookie("A", "B", "http://foo.bar", "/", base::Time::Now());
+  DestroyStore();
+
+  // Load up the store and verify that it has good data in it.
+  std::vector<net::CookieMonster::CanonicalCookie*> cookies;
+  CreateAndLoad(false, &cookies);
+  ASSERT_EQ(1U, cookies.size());
+  ASSERT_STREQ("http://foo.bar", cookies[0]->Domain().c_str());
+  ASSERT_STREQ("A", cookies[0]->Name().c_str());
+  ASSERT_STREQ("B", cookies[0]->Value().c_str());
+  DestroyStore();
+  STLDeleteContainerPointers(cookies.begin(), cookies.end());
+  cookies.clear();
+
+  // Now corrupt the meta table.
+  {
+    sql::Connection db;
+    ASSERT_TRUE(db.Open(temp_dir_.path().Append(chrome::kCookieFilename)));
+    sql::MetaTable meta_table_;
+    meta_table_.Init(&db, 0, 0);
+    meta_table_.SetVersionNumber(0);
+    meta_table_.SetCompatibleVersionNumber(0);
+    db.Close();
+  }
+
+  // Upon loading, the database should be reset to a good, blank state.
+  CreateAndLoad(false, &cookies);
+  ASSERT_EQ(0U, cookies.size());
+
+  // Verify that, after, recovery, the database persists properly.
+  AddCookie("X", "Y", "http://foo.bar", "/", base::Time::Now());
+  DestroyStore();
+  CreateAndLoad(false, &cookies);
+  ASSERT_EQ(1U, cookies.size());
+  ASSERT_STREQ("http://foo.bar", cookies[0]->Domain().c_str());
+  ASSERT_STREQ("X", cookies[0]->Name().c_str());
+  ASSERT_STREQ("Y", cookies[0]->Value().c_str());
+  STLDeleteContainerPointers(cookies.begin(), cookies.end());
+  cookies.clear();
+}
+
 // Test if data is stored as expected in the SQLite database.
 TEST_F(SQLitePersistentCookieStoreTest, TestPersistance) {
   InitializeStore(false);
   AddCookie("A", "B", "http://foo.bar", "/", base::Time::Now());
   // Replace the store effectively destroying the current one and forcing it
   // to write it's data to disk. Then we can see if after loading it again it
   // is still there.
   DestroyStore();
   // Reload and test for persistence
   std::vector<net::CookieMonster::CanonicalCookie*> cookies;
@@ skipping 251 matching lines @@
 
   EXPECT_FALSE(cookie_map["session-noexpires"]->DoesExpire());
   EXPECT_FALSE(cookie_map["session-noexpires"]->IsPersistent());
 
   EXPECT_TRUE(cookie_map["persistent"]->DoesExpire());
   EXPECT_TRUE(cookie_map["persistent"]->IsPersistent());
 
   STLDeleteContainerPointers(cookies.begin(), cookies.end());
   cookies.clear();
 }