Add blob-writing functionality [as yet un-called] to IDB's backend.

content/browser/indexed_db/indexed_db_cleanup_on_io_error_unittest.cc

 // Copyright (c) 2013 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 <cerrno>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/strings/string16.h"
@@ skipping 11 matching lines @@
 using content::LevelDBSnapshot;
 
 namespace base {
 class TaskRunner;
 }
 
 namespace content {
 class IndexedDBFactory;
 }
 
+namespace net {
+class URLRequestContext;
+}
+
 namespace {
 
 class BustedLevelDBDatabase : public LevelDBDatabase {
  public:
   static scoped_ptr<LevelDBDatabase> Open(
       const base::FilePath& file_name,
       const LevelDBComparator* /*comparator*/) {
     return scoped_ptr<LevelDBDatabase>(new BustedLevelDBDatabase);
   }
   virtual leveldb::Status Get(const base::StringPiece& key,
@@ skipping 26 matching lines @@
  private:
   bool destroy_called_;
 };
 
 TEST(IndexedDBIOErrorTest, CleanUpTest) {
   content::IndexedDBFactory* factory = NULL;
   const GURL origin("http://localhost:81");
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
   const base::FilePath path = temp_directory.path();
+  net::URLRequestContext* request_context = NULL;
   MockLevelDBFactory mock_leveldb_factory;
   blink::WebIDBDataLoss data_loss =
       blink::WebIDBDataLossNone;
   std::string data_loss_message;
   bool disk_full = false;
   base::TaskRunner* task_runner = NULL;
   scoped_refptr<IndexedDBBackingStore> backing_store =
       IndexedDBBackingStore::Open(factory,
                                   origin,
                                   path,
+                                  request_context,
                                   &data_loss,
                                   &data_loss_message,
                                   &disk_full,
                                   &mock_leveldb_factory,
                                   task_runner);
 }
 
 // TODO(dgrogan): Remove expect_destroy if we end up not using it again. It is
 // currently set to false in all 4 calls below.
 template <class T>
@@ skipping 23 matching lines @@
 
  private:
   T error_;
   bool expect_destroy_;
   bool destroy_called_;
 };
 
 TEST(IndexedDBNonRecoverableIOErrorTest, NuancedCleanupTest) {
   content::IndexedDBFactory* factory = NULL;
   const GURL origin("http://localhost:81");
+  net::URLRequestContext* request_context = NULL;
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
   const base::FilePath path = temp_directory.path();
   blink::WebIDBDataLoss data_loss =
       blink::WebIDBDataLossNone;
   std::string data_loss_reason;
   bool disk_full = false;
   base::TaskRunner* task_runner = NULL;
 
   MockErrorLevelDBFactory<int> mock_leveldb_factory(ENOSPC, false);
   scoped_refptr<IndexedDBBackingStore> backing_store =
       IndexedDBBackingStore::Open(factory,
                                   origin,
                                   path,
+                                  request_context,
                                   &data_loss,
                                   &data_loss_reason,
                                   &disk_full,
                                   &mock_leveldb_factory,
                                   task_runner);
 
   MockErrorLevelDBFactory<base::File::Error> mock_leveldb_factory2(
       base::File::FILE_ERROR_NO_MEMORY, false);
   scoped_refptr<IndexedDBBackingStore> backing_store2 =
       IndexedDBBackingStore::Open(factory,
                                   origin,
                                   path,
+                                  request_context,
                                   &data_loss,
                                   &data_loss_reason,
                                   &disk_full,
                                   &mock_leveldb_factory2,
                                   task_runner);
 
   MockErrorLevelDBFactory<int> mock_leveldb_factory3(EIO, false);
   scoped_refptr<IndexedDBBackingStore> backing_store3 =
       IndexedDBBackingStore::Open(factory,
                                   origin,
                                   path,
+                                  request_context,
                                   &data_loss,
                                   &data_loss_reason,
                                   &disk_full,
                                   &mock_leveldb_factory3,
                                   task_runner);
 
   MockErrorLevelDBFactory<base::File::Error> mock_leveldb_factory4(
       base::File::FILE_ERROR_FAILED, false);
   scoped_refptr<IndexedDBBackingStore> backing_store4 =
       IndexedDBBackingStore::Open(factory,
                                   origin,
                                   path,
+                                  request_context,
                                   &data_loss,
                                   &data_loss_reason,
                                   &disk_full,
                                   &mock_leveldb_factory4,
                                   task_runner);
 }
 
 }  // namespace