Appcache::OnCorruptionDetected handling

webkit/browser/appcache/appcache_storage_impl_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 <stack>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
+#include "sql/test/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/appcache/appcache.h"
 #include "webkit/browser/appcache/appcache_backend_impl.h"
 #include "webkit/browser/appcache/appcache_database.h"
 #include "webkit/browser/appcache/appcache_entry.h"
 #include "webkit/browser/appcache/appcache_group.h"
 #include "webkit/browser/appcache/appcache_host.h"
 #include "webkit/browser/appcache/appcache_interceptor.h"
 #include "webkit/browser/appcache/appcache_request_handler.h"
 #include "webkit/browser/appcache/appcache_service.h"
@@ skipping 223 matching lines @@
                        base::FilePath(),
                        io_thread->message_loop_proxy().get(),
                        db_thread->message_loop_proxy().get(),
                        NULL),
           async_(false) {}
 
     virtual void GetUsageAndQuota(
         const GURL& origin,
         quota::StorageType type,
         const GetUsageAndQuotaCallback& callback) OVERRIDE {
-      EXPECT_EQ(kOrigin, origin);
       EXPECT_EQ(quota::kStorageTypeTemporary, type);
       if (async_) {
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&MockQuotaManager::CallCallback,
                        base::Unretained(this),
                        callback));
         return;
       }
       CallCallback(callback);
@@ skipping 1287 matching lines @@
           &AppCacheStorageImplTest::Verify_ExclusionNotFound,
           base::Unretained(this), kOnlineNamespaceWithinFallback, 3));
       storage()->FindResponseForMainRequest(
           kOnlineNamespaceWithinFallback, GURL(), delegate());
       return;
     }
 
     TestFinished();
   }
 
-  // Reinitialize  -------------------------------
-  // This test is somewhat of a system integration test.
-  // It relies on running a mock http server on our IO thread,
+  // Reinitialize -------------------------------
+  // These tests are somewhat of a system integration test.
+  // They rely on running a mock http server on our IO thread,
   // and involves other appcache classes to get some code
   // coverage thruout when Reinitialize happens.
 
   class MockServiceObserver : public AppCacheService::Observer {
    public:
     explicit MockServiceObserver(AppCacheStorageImplTest* test)
         : test_(test) {}
 
     virtual void OnServiceReinitialized(
         AppCacheStorageReference* old_storage_ref) OVERRIDE {
@@ skipping 24 matching lines @@
       error_event_was_raised_ = true;
     }
     virtual void OnLogMessage(int host_id, LogLevel log_level,
                               const std::string& message) OVERRIDE {}
     virtual void OnContentBlocked(
         int host_id, const GURL& manifest_url) OVERRIDE {}
 
     bool error_event_was_raised_;
   };
 
+  enum ReinitTestCase {
+     CORRUPT_CACHE_ON_INSTALL,
+     CORRUPT_CACHE_ON_LOAD_EXISTING,
+     CORRUPT_SQL_ON_INSTALL
+  };
+
   void Reinitialize1() {
-    Reinitialize(1);
+    // Recover from a corrupt disk cache discovered while
+    // installing a new appcache.
+    Reinitialize(CORRUPT_CACHE_ON_INSTALL);
   }
 
   void Reinitialize2() {
-    Reinitialize(2);
+    // Recover from a corrupt disk cache discovered while
+    // trying to load a resource from an existing appcache.
+    Reinitialize(CORRUPT_CACHE_ON_LOAD_EXISTING);
   }
 
-  void Reinitialize(int test_case) {
+  void Reinitialize3() {
+    // Recover from a corrupt sql database discovered while
+    // installing a new appcache.
+    Reinitialize(CORRUPT_SQL_ON_INSTALL);
+  }
+
+  void Reinitialize(ReinitTestCase test_case) {
     // Unlike all of the other tests, this one actually read/write files.
     ASSERT_TRUE(temp_directory_.CreateUniqueTempDir());
 
-    // Create a corrupt/unopenable disk_cache index file.
-    const std::string kCorruptData("deadbeef");
-    base::FilePath disk_cache_directory =
-        temp_directory_.path().AppendASCII("Cache");
-    ASSERT_TRUE(base::CreateDirectory(disk_cache_directory));
-    base::FilePath index_file = disk_cache_directory.AppendASCII("index");
-    EXPECT_EQ(static_cast<int>(kCorruptData.length()),
-              file_util::WriteFile(
-                  index_file, kCorruptData.data(), kCorruptData.length()));
+    AppCacheDatabase db(temp_directory_.path().AppendASCII("Index"));
+    EXPECT_TRUE(db.LazyOpen(true));
+
+    if (test_case == CORRUPT_CACHE_ON_INSTALL ||
+        test_case == CORRUPT_CACHE_ON_LOAD_EXISTING) {
+      // Create a corrupt/unopenable disk_cache index file.
+      const std::string kCorruptData("deadbeef");
+      base::FilePath disk_cache_directory =
+          temp_directory_.path().AppendASCII("Cache");
+      ASSERT_TRUE(base::CreateDirectory(disk_cache_directory));
+      base::FilePath index_file = disk_cache_directory.AppendASCII("index");
+      EXPECT_EQ(static_cast<int>(kCorruptData.length()),
+                file_util::WriteFile(
+                    index_file, kCorruptData.data(), kCorruptData.length()));
+    }
 
     // Create records for a degenerate cached manifest that only contains
     // one entry for the manifest file resource.
-    if (test_case == 2) {
+    if (test_case == CORRUPT_CACHE_ON_LOAD_EXISTING) {
       AppCacheDatabase db(temp_directory_.path().AppendASCII("Index"));
       GURL manifest_url = MockHttpServer::GetMockUrl("manifest");
 
       AppCacheDatabase::GroupRecord group_record;
       group_record.group_id = 1;
       group_record.manifest_url = manifest_url;
       group_record.origin = manifest_url.GetOrigin();
       EXPECT_TRUE(db.InsertGroup(&group_record));
       AppCacheDatabase::CacheRecord cache_record;
       cache_record.cache_id = 1;
@@ skipping 29 matching lines @@
     // We continue after the init task is complete including the callback
     // on the current thread.
     FlushDbThreadTasks();
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&AppCacheStorageImplTest::Continue_Reinitialize,
                    base::Unretained(this),
                    test_case));
   }
 
-  void Continue_Reinitialize(int test_case) {
+  void Continue_Reinitialize(ReinitTestCase test_case) {
     const int kMockProcessId = 1;
     backend_.reset(new AppCacheBackendImpl);
     backend_->Initialize(service_.get(), &frontend_, kMockProcessId);
 
-    if (test_case == 1) {
+    if (test_case == CORRUPT_SQL_ON_INSTALL) {
+      // Break the db file
+      EXPECT_FALSE(database()->was_corruption_detected());
+      ASSERT_TRUE(sql::test::CorruptSizeInHeader(
+          temp_directory_.path().AppendASCII("Index")));
+    }
+
+    if (test_case == CORRUPT_CACHE_ON_INSTALL  ||
+        test_case == CORRUPT_SQL_ON_INSTALL) {
       // Try to create a new appcache, the resulting update job will
       // eventually fail when it gets to disk cache initialization.
       backend_->RegisterHost(1);
       AppCacheHost* host1 = backend_->GetHost(1);
       const GURL kEmptyPageUrl(MockHttpServer::GetMockUrl("empty.html"));
       host1->first_party_url_ = kEmptyPageUrl;
       host1->SelectCache(kEmptyPageUrl,
                          kNoCacheId,
                          MockHttpServer::GetMockUrl("manifest"));
     } else {
-      ASSERT_EQ(2, test_case);
+      ASSERT_EQ(CORRUPT_CACHE_ON_LOAD_EXISTING, test_case);
       // Try to access the existing cache manifest.
       // The URLRequestJob  will eventually fail when it gets to disk
       // cache initialization.
       backend_->RegisterHost(2);
       AppCacheHost* host2 = backend_->GetHost(2);
       GURL manifest_url = MockHttpServer::GetMockUrl("manifest");
       request_ = service()->request_context()->CreateRequest(
           manifest_url, net::DEFAULT_PRIORITY, NULL);
       AppCacheInterceptor::SetExtraRequestInfo(
           request_.get(), service_.get(),
           backend_->process_id(), host2->host_id(),
           ResourceType::MAIN_FRAME);
       request_->Start();
     }
 
     PushNextTask(base::Bind(
         &AppCacheStorageImplTest::Verify_Reinitialized,
         base::Unretained(this),
         test_case));
   }
 
-  void Verify_Reinitialized(int test_case) {
+  void Verify_Reinitialized(ReinitTestCase test_case) {
     // Verify we got notified of reinit and a new storage instance is created,
     // and that the old data has been deleted.
     EXPECT_TRUE(observer_->observed_old_storage_.get());
     EXPECT_TRUE(observer_->observed_old_storage_->storage() != storage());
     EXPECT_FALSE(PathExists(
         temp_directory_.path().AppendASCII("Cache").AppendASCII("index")));
     EXPECT_FALSE(PathExists(
         temp_directory_.path().AppendASCII("Index")));
 
+    if (test_case == CORRUPT_SQL_ON_INSTALL) {
+      AppCacheStorageImpl* storage = static_cast<AppCacheStorageImpl*>(
+          observer_->observed_old_storage_->storage());
+      EXPECT_TRUE(storage->database_->was_corruption_detected());
+    }
+
     // Verify that the hosts saw appropriate events.
-    if (test_case == 1) {
+    if (test_case == CORRUPT_CACHE_ON_INSTALL ||
+        test_case == CORRUPT_SQL_ON_INSTALL) {
       EXPECT_TRUE(frontend_.error_event_was_raised_);
       AppCacheHost* host1 = backend_->GetHost(1);
       EXPECT_FALSE(host1->associated_cache());
       EXPECT_FALSE(host1->group_being_updated_);
       EXPECT_TRUE(host1->disabled_storage_reference_.get());
     } else {
-      ASSERT_EQ(2, test_case);
+      ASSERT_EQ(CORRUPT_CACHE_ON_LOAD_EXISTING, test_case);
       AppCacheHost* host2 = backend_->GetHost(2);
       EXPECT_EQ(1, host2->main_resource_cache_->cache_id());
       EXPECT_TRUE(host2->disabled_storage_reference_.get());
     }
 
     // Cleanup and claim victory.
     service_->RemoveObserver(observer_.get());
     request_.reset();
     backend_.reset();
     observer_.reset();
@@ skipping 194 matching lines @@
 }
 
 TEST_F(AppCacheStorageImplTest, Reinitialize1) {
   RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize1);
 }
 
 TEST_F(AppCacheStorageImplTest, Reinitialize2) {
   RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize2);
 }
 
+TEST_F(AppCacheStorageImplTest, Reinitialize3) {
+  RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize3);
+}
+
 // That's all folks!
 
 }  // namespace appcache