Using a mock LevelDBTransaction for corruption tests.

content/browser/indexed_db/indexed_db_browsertest.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/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
+#include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/thread_test_helper.h"
 #include "content/browser/browser_main_loop.h"
+#include "content/browser/indexed_db/indexed_db_class_factory.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
+#include "content/browser/indexed_db/mock_browsertest_indexed_db_class_factory.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
+#include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "webkit/browser/database/database_util.h"
 #include "webkit/browser/quota/quota_manager.h"
 
 using base::ASCIIToUTF16;
 using quota::QuotaManager;
 using webkit_database::DatabaseUtil;
 
 namespace content {
 
 // This browser test is aimed towards exercising the IndexedDB bindings and
 // the actual implementation that lives in the browser side.
 class IndexedDBBrowserTest : public ContentBrowserTest {
  public:
   IndexedDBBrowserTest() : disk_usage_(-1) {}
 
+  virtual void SetUp() OVERRIDE {
+    GetTestClassFactory()->Reset();
+    IndexedDBClassFactory::SetIndexedDBClassFactoryGetter(GetIDBClassFactory);
+    ContentBrowserTest::SetUp();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    IndexedDBClassFactory::SetIndexedDBClassFactoryGetter(NULL);
+    ContentBrowserTest::TearDown();
+  }
+
+  void FailOperation(FailClass failure_class,
+                     FailMethod failure_method,
+                     int fail_on_instance_num,
+                     int fail_on_call_num) {
+    GetTestClassFactory()->FailOperation(
+        failure_class, failure_method, fail_on_instance_num, fail_on_call_num);
+  }
+
   void SimpleTest(const GURL& test_url, bool incognito = false) {
     // The test page will perform tests on IndexedDB, then navigate to either
     // a #pass or #fail ref.
     Shell* the_browser = incognito ? CreateOffTheRecordBrowser() : shell();
 
     VLOG(0) << "Navigating to URL and blocking.";
     NavigateToURLBlockUntilNavigationsComplete(the_browser, test_url, 2);
     VLOG(0) << "Navigation done.";
     std::string result =
         the_browser->web_contents()->GetLastCommittedURL().ref();
@@ skipping 62 matching lines @@
     scoped_refptr<base::ThreadTestHelper> helper(new base::ThreadTestHelper(
         BrowserMainLoop::GetInstance()->indexed_db_thread()->
             message_loop_proxy()));
     EXPECT_TRUE(helper->Run());
     // Wait for DidGetDiskUsage to be called.
     base::MessageLoop::current()->RunUntilIdle();
     return disk_usage_;
   }
 
  private:
+  static MockBrowserTestIndexedDBClassFactory* GetTestClassFactory() {
+    static ::base::LazyInstance<MockBrowserTestIndexedDBClassFactory>::Leaky
+        s_factory = LAZY_INSTANCE_INITIALIZER;
+    return s_factory.Pointer();
+  }
+
+  static IndexedDBClassFactory* GetIDBClassFactory() {
+    return GetTestClassFactory();
+  }
+
   virtual void DidGetDiskUsage(int64 bytes) {
     EXPECT_GT(bytes, 0);
     disk_usage_ = bytes;
   }
 
   int64 disk_usage_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBBrowserTest);
 };
 
@@ skipping 295 matching lines @@
           << " with " << numErrors << " errors";
   signal_when_finished->Signal();
 }
 
 const std::string s_corrupt_db_test_prefix = "/corrupt/test/";
 
 static scoped_ptr<net::test_server::HttpResponse> CorruptDBRequestHandler(
     IndexedDBContextImpl* context,
     const GURL& origin_url,
     const std::string& path,
+    IndexedDBBrowserTest* test,
     const net::test_server::HttpRequest& request) {
-
   std::string request_path;
   if (path.find(s_corrupt_db_test_prefix) != std::string::npos)
     request_path = request.relative_url.substr(s_corrupt_db_test_prefix.size());
   else
     return scoped_ptr<net::test_server::HttpResponse>();
 
   // Remove the query string if present.
   std::string request_query;
   size_t query_pos = request_path.find('?');
   if (query_pos != std::string::npos) {
     request_query = request_path.substr(query_pos + 1);
     request_path = request_path.substr(0, query_pos);
   }
 
   if (request_path == "corruptdb" && !request_query.empty()) {
     VLOG(0) << "Requested to corrupt IndexedDB: " << request_query;
     base::WaitableEvent signal_when_finished(false, false);
     context->TaskRunner()->PostTask(FROM_HERE,
                                     base::Bind(&CorruptIndexedDBDatabase,
                                                base::ConstRef(context),
                                                origin_url,
                                                &signal_when_finished));
     signal_when_finished.Wait();
 
     scoped_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse);
     http_response->set_code(net::HTTP_OK);
     return http_response.PassAs<net::test_server::HttpResponse>();
+  } else if (request_path == "fail" && !request_query.empty()) {
+    FailClass failure_class = FAIL_CLASS_NOTHING;
+    FailMethod failure_method = FAIL_METHOD_NOTHING;
+    int instance_num = 1;
+    int call_num = 1;
+    std::string fail_class;
+    std::string fail_method;
+
+    url::Component query(0, request_query.length()), key_pos, value_pos;
+    while (url::ExtractQueryKeyValue(
+        request_query.c_str(), &query, &key_pos, &value_pos)) {
+      std::string escaped_key(request_query.substr(key_pos.begin, key_pos.len));
+      std::string escaped_value(
+          request_query.substr(value_pos.begin, value_pos.len));
+
+      std::string key = net::UnescapeURLComponent(
+          escaped_key,
+          net::UnescapeRule::NORMAL | net::UnescapeRule::SPACES |
+              net::UnescapeRule::URL_SPECIAL_CHARS);
+
+      std::string value = net::UnescapeURLComponent(
+          escaped_value,
+          net::UnescapeRule::NORMAL | net::UnescapeRule::SPACES |
+              net::UnescapeRule::URL_SPECIAL_CHARS);
+
+      if (key == "method")
+        fail_method = value;
+      else if (key == "class")
+        fail_class = value;
+      else if (key == "instNum")
+        instance_num = atoi(value.c_str());
+      else if (key == "callNum")
+        call_num = atoi(value.c_str());
+      else
+        NOTREACHED() << "Unknown param: \"" << key << "\"";
+    }
+
+    if (fail_class == "LevelDBTransaction") {
+      failure_class = FAIL_CLASS_LEVELDB_TRANSACTION;
+      if (fail_method == "Get")
+        failure_method = FAIL_METHOD_GET;
+      else if (fail_method == "Commit")
+        failure_method = FAIL_METHOD_COMMIT;
+      else {
+        NOTREACHED() << "Unknown method: \"" << fail_method << "\"";
+      }
+    }
+
+    DCHECK_GE(instance_num, 1);
+    DCHECK_GE(call_num, 1);
+
+    test->FailOperation(failure_class, failure_method, instance_num, call_num);
+
+    scoped_ptr<net::test_server::BasicHttpResponse> http_response(
+        new net::test_server::BasicHttpResponse);
+    http_response->set_code(net::HTTP_OK);
+    return http_response.PassAs<net::test_server::HttpResponse>();
   }
 
   // A request for a test resource
   base::FilePath resourcePath =
       content::GetTestFilePath("indexeddb", request_path.c_str());
   scoped_ptr<net::test_server::BasicHttpResponse> http_response(
       new net::test_server::BasicHttpResponse);
   http_response->set_code(net::HTTP_OK);
   std::string file_contents;
   if (!base::ReadFileToString(resourcePath, &file_contents))
@@ skipping 10 matching lines @@
 
 IN_PROC_BROWSER_TEST_P(IndexedDBBrowserCorruptionTest,
                        OperationOnCorruptedOpenDatabase) {
   ASSERT_TRUE(embedded_test_server()->Started() ||
               embedded_test_server()->InitializeAndWaitUntilReady());
   const GURL& origin_url = embedded_test_server()->base_url();
   embedded_test_server()->RegisterRequestHandler(
       base::Bind(&CorruptDBRequestHandler,
                  base::ConstRef(GetContext()),
                  origin_url,
-                 s_corrupt_db_test_prefix));
+                 s_corrupt_db_test_prefix,
+                 this));
 
   std::string test_file = s_corrupt_db_test_prefix +
                           "corrupted_open_db_detection.html#" + GetParam();
   SimpleTest(embedded_test_server()->GetURL(test_file));
 
   test_file = s_corrupt_db_test_prefix + "corrupted_open_db_recovery.html";
   SimpleTest(embedded_test_server()->GetURL(test_file));
 }
 
 INSTANTIATE_TEST_CASE_P(IndexedDBBrowserCorruptionTestInstantiation,
@@ skipping 113 matching lines @@
 #define MAYBE_RenderThreadShutdownTest DISABLED_RenderThreadShutdownTest
 #else
 #define MAYBE_RenderThreadShutdownTest RenderThreadShutdownTest
 #endif
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTestSingleProcess,
                        MAYBE_RenderThreadShutdownTest) {
   SimpleTest(GetTestUrl("indexeddb", "shutdown_with_requests.html"));
 }
 
 }  // namespace content