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/string_split.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_browsertest_mock_factory.h"
+#include "content/browser/indexed_db/indexed_db_class_factory.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.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"
@@ skipping 12 matching lines @@
 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 IndexedDBBrowserTestClassFactory* GetTestClassFactory() {
+    static ::base::LazyInstance<IndexedDBBrowserTestClassFactory>::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.

[jsbell, 2014/06/19 21:08:47]

Wasn't there a thread about a utility for query string parsing?

   std::string request_query;
+  std::vector<std::pair<std::string, std::string> > query_params;
   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);
+    base::SplitStringIntoKeyValuePairs(request_query, '=', '&', &query_params);
   }
 
   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" && !query_params.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;
+
+    for (std::vector<std::pair<std::string, std::string> >::iterator it =

[jsbell, 2014/06/19 21:08:47]

Might be marginally more readable if the vector<> above was just iterated over
to produce a map<> and then this could just pluck the values out. But this is
fine.

[cmumford, 2014/06/19 22:45:58]

I switched to url::ExtractQueryKeyValue, and although slightly more verbose I
think it reads easier and is more correct.

+             query_params.begin();
+         it != query_params.end();
+         it++) {
+      if (it->first == "method")
+        fail_method = it->second;
+      else if (it->first == "class")
+        fail_class = it->second;
+      else if (it->first == "instNum")
+        instance_num = atoi(it->second.c_str());
+      else if (it->first == "callNum")
+        call_num = atoi(it->second.c_str());
+      else
+        NOTREACHED() << "Unknown param: \"" << it->first << "\"";
+    }
+
+    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(instance_num >= 1);

[jsbell, 2014/06/19 21:08:47]

DCHECK_GE

[cmumford, 2014/06/19 22:17:11]

Done.

+    DCHECK(call_num >= 1);

[jsbell, 2014/06/19 21:08:47]

DCHECK_GE

[cmumford, 2014/06/19 22:17:11]

Done.

+
+    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