Revert r84649 and r84671: "Move MockQuotaManager out of anonymous namespace to

fix build" and "Notify the quota manager when write operation is made in
FileSystem API."

FileSystemExtensionApiTest.FileBrowserTest is consistently crashing on chrome OS.

TBR=kinuko

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@84699 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 101 insertions, 234 deletions

diff --git a/webkit/fileapi/file_writer_delegate.cc b/webkit/fileapi/file_writer_delegate.cc
index 7045970..1f80620 100644
--- a/webkit/fileapi/file_writer_delegate.cc
+++ b/webkit/fileapi/file_writer_delegate.cc
@@ -12,9 +12,7 @@
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
-#include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/quota_file_util.h"
-#include "webkit/quota/quota_manager.h"
 
 namespace fileapi {
 
@@ -94,7 +92,7 @@ FileWriterDelegate::FileWriterDelegate(
       file_(base::kInvalidPlatformFileValue),
       offset_(offset),
       proxy_(proxy),
-      bytes_written_backlog_(0),
+      bytes_read_backlog_(0),
       bytes_written_(0),
       bytes_read_(0),
       total_bytes_written_(0),
@@ -262,40 +260,31 @@ void FileWriterDelegate::OnError(base::PlatformFileError error) {
   file_system_operation_->DidWrite(error, 0, true);
 }
 
-void FileWriterDelegate::OnProgress(int bytes_written, bool done) {
-  DCHECK(bytes_written + bytes_written_backlog_ >= bytes_written_backlog_);
-  if (bytes_written > 0 && !usage_file_path_.empty()) {
+void FileWriterDelegate::OnProgress(int bytes_read, bool done) {
+  DCHECK(bytes_read + bytes_read_backlog_ >= bytes_read_backlog_);
+  if (bytes_read > 0 && !usage_file_path_.empty()) {
     proxy_->PostTask(FROM_HERE, NewRunnableFunction(
         &FileSystemUsageCache::AtomicUpdateUsageByDelta,
-        usage_file_path_, bytes_written));
-    FileSystemOperationContext* operation_context =
-        file_system_operation_->file_system_operation_context();
-    if (file_system_operation_->file_system_context()->quota_manager_proxy())
-      file_system_operation_->file_system_context()->
-          quota_manager_proxy()->NotifyStorageModified(
-              quota::QuotaClient::kFileSystem,
-              operation_context->src_origin_url(),
-              FileSystemTypeToQuotaStorageType(operation_context->src_type()),
-              bytes_written);
+        usage_file_path_, bytes_read));
   }
   static const int kMinProgressDelayMS = 200;
   base::Time currentTime = base::Time::Now();
   if (done || last_progress_event_time_.is_null() ||
       (currentTime - last_progress_event_time_).InMilliseconds() >
           kMinProgressDelayMS) {
-    bytes_written += bytes_written_backlog_;
+    bytes_read += bytes_read_backlog_;
     last_progress_event_time_ = currentTime;
-    bytes_written_backlog_ = 0;
+    bytes_read_backlog_ = 0;
     if (done && !usage_file_path_.empty()) {
       // Decrement the dirty when the Write operation finishes.
       proxy_->PostTask(FROM_HERE, NewRunnableFunction(
           &FileSystemUsageCache::DecrementDirty, usage_file_path_));
     }
     file_system_operation_->DidWrite(
-        base::PLATFORM_FILE_OK, bytes_written, done);
+        base::PLATFORM_FILE_OK, bytes_read, done);
     return;
   }
-  bytes_written_backlog_ += bytes_written;
+  bytes_read_backlog_ += bytes_read;
 }
 
 }  // namespace fileapi
diff --git a/webkit/fileapi/file_writer_delegate.h b/webkit/fileapi/file_writer_delegate.h
index d75bd31..d95cc42 100644
--- a/webkit/fileapi/file_writer_delegate.h
+++ b/webkit/fileapi/file_writer_delegate.h
@@ -67,7 +67,7 @@ class FileWriterDelegate : public net::URLRequest::Delegate {
   int64 offset_;
   scoped_refptr<base::MessageLoopProxy> proxy_;
   base::Time last_progress_event_time_;
-  int bytes_written_backlog_;
+  int bytes_read_backlog_;
   int bytes_written_;
   int bytes_read_;
   FilePath usage_file_path_;
diff --git a/webkit/fileapi/file_writer_delegate_unittest.cc b/webkit/fileapi/file_writer_delegate_unittest.cc
index af46faf..d56c7ae 100644
--- a/webkit/fileapi/file_writer_delegate_unittest.cc
+++ b/webkit/fileapi/file_writer_delegate_unittest.cc
@@ -27,12 +27,6 @@
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_writer_delegate.h"
 #include "webkit/fileapi/quota_file_util.h"
-#include "webkit/quota/quota_manager.h"
-
-using quota::QuotaClient;
-using quota::QuotaManager;
-using quota::QuotaManagerProxy;
-using quota::StorageType;
 
 namespace fileapi {
 
@@ -57,29 +51,6 @@ class MockFileSystemPathManager : public FileSystemPathManager {
   FilePath test_filesystem_path_;
 };
 
-class MockQuotaManager : public QuotaManager {
- public:
-  MockQuotaManager(const FilePath& filesystem_path)
-      : QuotaManager(false /* is_incognito */,
-                     filesystem_path,
-                     base::MessageLoopProxy::CreateForCurrentThread(),
-                     base::MessageLoopProxy::CreateForCurrentThread()),
-        usage_(0) {}
-  int64 usage() const { return usage_; }
-
- protected:
-  virtual void NotifyStorageModified(QuotaClient::ID client_id,
-                                     const GURL& origin,
-                                     StorageType type,
-                                     int64 delta) {
-    DCHECK(client_id == QuotaClient::kFileSystem);
-    usage_ += delta;
-  }
-
- private:
-  int64 usage_;
-};
-
 class Result {
  public:
   Result()
@@ -110,7 +81,40 @@ class Result {
   bool complete_;
 };
 
-static const char* g_content = NULL;
+}  // namespace (anonymous)
+
+class FileWriterDelegateTest : public PlatformTest {
+ public:
+  FileWriterDelegateTest()
+      : loop_(MessageLoop::TYPE_IO) {}
+
+ protected:
+  virtual void SetUp();
+  virtual void TearDown();
+
+  int64 GetCachedUsage() {
+    return FileSystemUsageCache::GetUsage(usage_file_path_);
+  }
+
+  static net::URLRequest::ProtocolFactory Factory;
+
+  scoped_ptr<FileWriterDelegate> file_writer_delegate_;
+  scoped_ptr<net::URLRequest> request_;
+  scoped_ptr<FileSystemOperationContext> context_;
+  scoped_ptr<Result> result_;
+
+  MessageLoop loop_;
+
+  ScopedTempDir dir_;
+  FilePath filesystem_dir_;
+  FilePath usage_file_path_;
+  FilePath file_path_;
+  PlatformFile file_;
+};
+
+namespace {
+
+static std::string g_content;
 
 class FileWriterDelegateTestJob : public net::URLRequestJob {
  public:
@@ -187,47 +191,6 @@ class MockDispatcher : public FileSystemCallbackDispatcher {
 
 }  // namespace (anonymous)
 
-class FileWriterDelegateTest : public PlatformTest {
- public:
-  FileWriterDelegateTest()
-      : loop_(MessageLoop::TYPE_IO) {}
-
- protected:
-  virtual void SetUp();
-  virtual void TearDown();
-
-  int64 GetCachedUsage() {
-    return FileSystemUsageCache::GetUsage(usage_file_path_);
-  }
-
-  int64 GetManagerUsage() const {
-    DCHECK(quota_manager_.get());
-    return quota_manager_->usage();
-  }
-
-  FileSystemContext* file_system_context() const {
-    return file_system_context_.get();
-  }
-
-  static net::URLRequest::ProtocolFactory Factory;
-
-  scoped_ptr<FileWriterDelegate> file_writer_delegate_;
-  scoped_ptr<net::URLRequest> request_;
-  scoped_ptr<FileSystemOperationContext> context_;
-  scoped_ptr<Result> result_;
-
-  scoped_refptr<FileSystemContext> file_system_context_;
-  scoped_refptr<MockQuotaManager> quota_manager_;
-
-  MessageLoop loop_;
-
-  ScopedTempDir dir_;
-  FilePath filesystem_dir_;
-  FilePath usage_file_path_;
-  FilePath file_path_;
-  PlatformFile file_;
-};
-
 // static
 net::URLRequestJob* FileWriterDelegateTest::Factory(
     net::URLRequest* request,
@@ -242,17 +205,13 @@ void FileWriterDelegateTest::SetUp() {
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(filesystem_dir_,
                                                   &file_path_));
 
-  quota_manager_ = new MockQuotaManager(filesystem_dir_);
-  file_system_context_ =
+  context_.reset(new FileSystemOperationContext(
       new FileSystemContext(base::MessageLoopProxy::CreateForCurrentThread(),
                             base::MessageLoopProxy::CreateForCurrentThread(),
-                            NULL, quota_manager_->proxy(),
-                            FilePath(), false /* is_incognito */,
+                            NULL, NULL, FilePath(), false /* is_incognito */,
                             true, true,
                             new MockFileSystemPathManager(filesystem_dir_)),
-
-  context_.reset(new FileSystemOperationContext(
-      file_system_context_.get(), NULL));
+      NULL));
 
   usage_file_path_ =
       filesystem_dir_.AppendASCII(FileSystemUsageCache::kUsageFileName);
@@ -274,32 +233,25 @@ void FileWriterDelegateTest::SetUp() {
 
 void FileWriterDelegateTest::TearDown() {
   net::URLRequest::RegisterProtocolFactory("blob", NULL);
-  result_.reset();
+  result_.reset(NULL);
   base::ClosePlatformFile(file_);
-  context_.reset();
-  file_system_context_ = NULL;
-  quota_manager_ = NULL;
-  // Make sure objects that need to be freed on a particular thread go away.
-  MessageLoop::current()->RunAllPending();
+  context_.reset(NULL);
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
   GURL blob_url("blob:nolimit");
-  g_content = "The quick brown fox jumps over the lazy dog.\n";
+  g_content = std::string("The quick brown fox jumps over the lazy dog.\n");
   file_writer_delegate_.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result_.get()),
-                              NULL, file_system_context(),
+      new FileSystemOperation(new MockDispatcher(result_.get()), NULL, NULL,
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
 
   ASSERT_EQ(0, GetCachedUsage());
-  ASSERT_EQ(0, GetManagerUsage());
   context_->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
   file_writer_delegate_->Start(file_, request_.get(), *context_);
   MessageLoop::current()->Run();
   ASSERT_EQ(45, GetCachedUsage());
-  ASSERT_EQ(45, GetManagerUsage());
 
   EXPECT_EQ(45, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
@@ -310,10 +262,9 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
   GURL blob_url("blob:just");
-  g_content = "The quick brown fox jumps over the lazy dog.\n";
+  g_content = std::string("The quick brown fox jumps over the lazy dog.\n");
   file_writer_delegate_.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result_.get()),
-                              NULL, file_system_context(),
+      new FileSystemOperation(new MockDispatcher(result_.get()), NULL, NULL,
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
@@ -323,7 +274,6 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
   file_writer_delegate_->Start(file_, request_.get(), *context_);
   MessageLoop::current()->Run();
   ASSERT_EQ(45, GetCachedUsage());
-  ASSERT_EQ(45, GetManagerUsage());
 
   file_writer_delegate_.reset(NULL);
 
@@ -334,10 +284,9 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
 
 TEST_F(FileWriterDelegateTest, WriteFailureByQuota) {
   GURL blob_url("blob:failure");
-  g_content = "The quick brown fox jumps over the lazy dog.\n";
+  g_content = std::string("The quick brown fox jumps over the lazy dog.\n");
   file_writer_delegate_.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result_.get()),
-                              NULL, file_system_context(),
+      new FileSystemOperation(new MockDispatcher(result_.get()), NULL, NULL,
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
@@ -347,7 +296,6 @@ TEST_F(FileWriterDelegateTest, WriteFailureByQuota) {
   file_writer_delegate_->Start(file_, request_.get(), *context_);
   MessageLoop::current()->Run();
   ASSERT_EQ(44, GetCachedUsage());
-  ASSERT_EQ(44, GetManagerUsage());
 
   file_writer_delegate_.reset(NULL);
 
@@ -358,10 +306,9 @@ TEST_F(FileWriterDelegateTest, WriteFailureByQuota) {
 
 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) {
   GURL blob_url("blob:zero");
-  g_content = "";
+  g_content = std::string("");
   file_writer_delegate_.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result_.get()),
-                              NULL, file_system_context(),
+      new FileSystemOperation(new MockDispatcher(result_.get()), NULL, NULL,
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
@@ -371,7 +318,6 @@ TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) {
   file_writer_delegate_->Start(file_, request_.get(), *context_);
   MessageLoop::current()->Run();
   ASSERT_EQ(0, GetCachedUsage());
-  ASSERT_EQ(0, GetManagerUsage());
 
   file_writer_delegate_.reset(NULL);
 
@@ -397,20 +343,24 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimitConcurrent) {
   ASSERT_EQ(base::PLATFORM_FILE_OK, error_code);
 
   context2.reset(new FileSystemOperationContext(
-      file_system_context(), NULL));
+      new FileSystemContext(base::MessageLoopProxy::CreateForCurrentThread(),
+                            base::MessageLoopProxy::CreateForCurrentThread(),
+                            NULL, NULL, FilePath(), false /* is_incognito */,
+                            true, true,
+                            new MockFileSystemPathManager(filesystem_dir_)),
+      NULL));
+
   result2.reset(new Result());
 
   GURL blob_url("blob:nolimitconcurrent");
   GURL blob_url2("blob:nolimitconcurrent2");
-  g_content = "The quick brown fox jumps over the lazy dog.\n";
+  g_content = std::string("The quick brown fox jumps over the lazy dog.\n");
   file_writer_delegate_.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result_.get()),
-                              NULL, file_system_context(),
+      new FileSystemOperation(new MockDispatcher(result_.get()), NULL, NULL,
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   file_writer_delegate2.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result2.get()),
-                              NULL, file_system_context(),
+      new FileSystemOperation(new MockDispatcher(result2.get()), NULL, NULL,
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
@@ -425,7 +375,6 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimitConcurrent) {
   if (!result_->complete() || !result2->complete())
     MessageLoop::current()->Run();
   ASSERT_EQ(90, GetCachedUsage());
-  ASSERT_EQ(90, GetManagerUsage());
 
   file_writer_delegate_.reset(NULL);
 
diff --git a/webkit/fileapi/quota_file_util.cc b/webkit/fileapi/quota_file_util.cc
index 3167313..820b6a8 100644
--- a/webkit/fileapi/quota_file_util.cc
+++ b/webkit/fileapi/quota_file_util.cc
@@ -6,13 +6,10 @@
 
 #include "base/file_util.h"
 #include "base/logging.h"
-#include "base/message_loop_proxy.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
-#include "webkit/fileapi/file_system_util.h"
-#include "webkit/quota/quota_manager.h"
 
 namespace fileapi {
 
@@ -57,23 +54,13 @@ static FilePath InitUsageFile(FileSystemOperationContext* fs_context) {
   return usage_file_path;
 }
 
-static void UpdateUsage(
-    FileSystemOperationContext* fs_context,
-    const GURL& modified_origin,
-    FileSystemType type,
-    const FilePath& usage_file_path, int64 growth) {
+static void UpdateUsageFile(const FilePath& usage_file_path, int64 growth) {
   if (FileSystemUsageCache::Exists(usage_file_path))
     FileSystemUsageCache::DecrementDirty(usage_file_path);
 
-  FileSystemUsageCache::AtomicUpdateUsageByDelta(usage_file_path, growth);
-
-  if (fs_context->file_system_context()->quota_manager_proxy())
-    fs_context->file_system_context()->quota_manager_proxy()
-        ->NotifyStorageModified(
-            quota::QuotaClient::kFileSystem,
-            GURL(modified_origin),
-            FileSystemTypeToQuotaStorageType(type),
-            growth);
+  int64 usage = FileSystemUsageCache::GetUsage(usage_file_path);
+  if (usage >= 0)
+    FileSystemUsageCache::UpdateUsage(usage_file_path, usage + growth);
 }
 
 }  // namespace (anonymous)
@@ -112,9 +99,7 @@ base::PlatformFileError QuotaFileUtil::CopyOrMoveFile(
   base::PlatformFileError error = FileSystemFileUtil::GetInstance()->
       CopyOrMoveFile(fs_context, src_file_path, dest_file_path, copy);
 
-  UpdateUsage(fs_context,
-              fs_context->dest_origin_url(), fs_context->dest_type(),
-              usage_file_path, growth);
+  UpdateUsageFile(usage_file_path, growth);
 
   return error;
 }
@@ -133,8 +118,7 @@ base::PlatformFileError QuotaFileUtil::DeleteFile(
   base::PlatformFileError error = FileSystemFileUtil::GetInstance()->
       DeleteFile(fs_context, file_path);
 
-  UpdateUsage(fs_context, fs_context->src_origin_url(), fs_context->src_type(),
-              usage_file_path, growth);
+  UpdateUsageFile(usage_file_path, growth);
 
   return error;
 }
@@ -164,8 +148,7 @@ base::PlatformFileError QuotaFileUtil::Truncate(
   base::PlatformFileError error = FileSystemFileUtil::GetInstance()->Truncate(
       fs_context, path, length);
 
-  UpdateUsage(fs_context, fs_context->src_origin_url(), fs_context->src_type(),
-              usage_file_path, growth);
+  UpdateUsageFile(usage_file_path, growth);
 
   return error;
 }
diff --git a/webkit/fileapi/quota_file_util_unittest.cc b/webkit/fileapi/quota_file_util_unittest.cc
index 0877df4..bb76f65 100644
--- a/webkit/fileapi/quota_file_util_unittest.cc
+++ b/webkit/fileapi/quota_file_util_unittest.cc
@@ -16,14 +16,8 @@
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
-#include "webkit/quota/quota_client.h"
-#include "webkit/quota/quota_manager.h"
 
 using namespace fileapi;
-using quota::QuotaClient;
-using quota::QuotaManager;
-using quota::QuotaManagerProxy;
-using quota::StorageType;
 
 namespace {
 
@@ -48,30 +42,6 @@ class MockFileSystemPathManager : public FileSystemPathManager {
 
 }  // namespace (anonymous)
 
-class MockQuotaManager : public QuotaManager {
- public:
-  MockQuotaManager(const FilePath& filesystem_path)
-      : QuotaManager(false /* is_incognito */,
-                     filesystem_path,
-                     base::MessageLoopProxy::CreateForCurrentThread(),
-                     base::MessageLoopProxy::CreateForCurrentThread()),
-        usage_(0) {}
-
-  int64 usage() const { return usage_; }
-
- protected:
-  virtual void NotifyStorageModified(QuotaClient::ID client_id,
-                                     const GURL& origin,
-                                     StorageType type,
-                                     int64 delta) {
-    DCHECK(client_id == QuotaClient::kFileSystem);
-    usage_ += delta;
-  }
-
- private:
-  int64 usage_;
-};
-
 class QuotaFileUtilTest : public testing::Test {
  public:
   QuotaFileUtilTest()
@@ -85,8 +55,6 @@ class QuotaFileUtilTest : public testing::Test {
 
     usage_file_path_ = Path(FileSystemUsageCache::kUsageFileName);
     FileSystemUsageCache::UpdateUsage(usage_file_path_, 0);
-
-    quota_manager_ = new MockQuotaManager(filesystem_dir_);
   }
 
  protected:
@@ -94,7 +62,7 @@ class QuotaFileUtilTest : public testing::Test {
     FileSystemOperationContext *context = new FileSystemOperationContext(
         new FileSystemContext(base::MessageLoopProxy::CreateForCurrentThread(),
                               base::MessageLoopProxy::CreateForCurrentThread(),
-                              NULL, quota_manager_proxy(), FilePath(), false,
+                              NULL, NULL, FilePath(), false,
                               true, true,
                               new MockFileSystemPathManager(filesystem_dir_)),
         QuotaFileUtil::GetInstance());
@@ -131,21 +99,11 @@ class QuotaFileUtilTest : public testing::Test {
     return FileSystemUsageCache::GetUsage(usage_file_path_);
   }
 
-  int64 usage() const {
-    DCHECK(quota_manager_.get());
-    return quota_manager_->usage();
-  }
-  QuotaManagerProxy* quota_manager_proxy() const {
-    DCHECK(quota_manager_.get());
-    return quota_manager_->proxy();
-  }
-
  private:
   ScopedTempDir data_dir_;
   FilePath filesystem_dir_;
   FilePath usage_file_path_;
   base::ScopedCallbackFactory<QuotaFileUtilTest> callback_factory_;
-  scoped_refptr<MockQuotaManager> quota_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaFileUtilTest);
 };
@@ -189,7 +147,6 @@ TEST_F(QuotaFileUtilTest, Truncate) {
                                                    Path(file_name),
                                                    1020));
   ASSERT_EQ(1020, GetCachedUsage());
-  ASSERT_EQ(1020, usage());
 
   truncate_context.reset(NewContext());
   truncate_context->set_allowed_bytes_growth(0);
@@ -198,7 +155,6 @@ TEST_F(QuotaFileUtilTest, Truncate) {
                                                    Path(file_name),
                                                    0));
   ASSERT_EQ(0, GetCachedUsage());
-  ASSERT_EQ(0, usage());
 
   truncate_context.reset(NewContext());
   truncate_context->set_allowed_bytes_growth(1020);
@@ -207,7 +163,6 @@ TEST_F(QuotaFileUtilTest, Truncate) {
                                                    Path(file_name),
                                                    1021));
   ASSERT_EQ(0, GetCachedUsage());
-  ASSERT_EQ(0, usage());
 }
 
 TEST_F(QuotaFileUtilTest, CopyFile) {
@@ -229,7 +184,6 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
                                                    Path(from_file),
                                                    1020));
   ASSERT_EQ(1020, GetCachedUsage());
-  ASSERT_EQ(1020, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -238,7 +192,6 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
                                                    Path(obstacle_file),
                                                    1));
   ASSERT_EQ(1021, GetCachedUsage());
-  ASSERT_EQ(1021, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1020);
@@ -247,7 +200,6 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
                                                Path(from_file),
                                                Path(to_file1)));
   ASSERT_EQ(2041, GetCachedUsage());
-  ASSERT_EQ(2041, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1019);
@@ -256,7 +208,6 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
                                                Path(from_file),
                                                Path(to_file2)));
   ASSERT_EQ(2041, GetCachedUsage());
-  ASSERT_EQ(2041, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1019);
@@ -265,7 +216,6 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
                                                Path(from_file),
                                                Path(obstacle_file)));
   ASSERT_EQ(3060, GetCachedUsage());
-  ASSERT_EQ(3060, usage());
 }
 
 TEST_F(QuotaFileUtilTest, CopyDirectory) {
@@ -291,7 +241,6 @@ TEST_F(QuotaFileUtilTest, CopyDirectory) {
                                                    Path(from_file),
                                                    1020));
   ASSERT_EQ(1020, GetCachedUsage());
-  ASSERT_EQ(1020, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1020);
@@ -300,7 +249,6 @@ TEST_F(QuotaFileUtilTest, CopyDirectory) {
                                                Path(from_dir),
                                                Path(to_dir1)));
   ASSERT_EQ(2040, GetCachedUsage());
-  ASSERT_EQ(2040, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1019);
@@ -309,7 +257,6 @@ TEST_F(QuotaFileUtilTest, CopyDirectory) {
                                                Path(from_dir),
                                                Path(to_dir2)));
   ASSERT_EQ(2040, GetCachedUsage());
-  ASSERT_EQ(2040, usage());
 }
 
 TEST_F(QuotaFileUtilTest, MoveFile) {
@@ -328,7 +275,6 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
                                                    Path(from_file),
                                                    1020));
   ASSERT_EQ(1020, GetCachedUsage());
-  ASSERT_EQ(1020, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(0);
@@ -337,7 +283,6 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
                                                Path(from_file),
                                                Path(to_file)));
   ASSERT_EQ(1020, GetCachedUsage());
-  ASSERT_EQ(1020, usage());
 
   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(from_file, &created));
   ASSERT_TRUE(created);
@@ -351,7 +296,6 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
                                                    Path(from_file),
                                                    1020));
   ASSERT_EQ(2040, GetCachedUsage());
-  ASSERT_EQ(2040, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -360,7 +304,6 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
                                                    Path(obstacle_file),
                                                    1));
   ASSERT_EQ(2041, GetCachedUsage());
-  ASSERT_EQ(2041, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(0);
@@ -369,7 +312,6 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
                                                Path(from_file),
                                                Path(obstacle_file)));
   ASSERT_EQ(2040, GetCachedUsage());
-  ASSERT_EQ(2040, usage());
 }
 
 TEST_F(QuotaFileUtilTest, MoveDirectory) {
@@ -395,7 +337,6 @@ TEST_F(QuotaFileUtilTest, MoveDirectory) {
                                                    Path(from_file),
                                                    1020));
   ASSERT_EQ(1020, GetCachedUsage());
-  ASSERT_EQ(1020, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1020);
@@ -404,7 +345,6 @@ TEST_F(QuotaFileUtilTest, MoveDirectory) {
                                                Path(from_dir),
                                                Path(to_dir1)));
   ASSERT_EQ(1020, GetCachedUsage());
-  ASSERT_EQ(1020, usage());
 
   context.reset(NewContext());
   ASSERT_EQ(base::PLATFORM_FILE_OK,
@@ -421,7 +361,6 @@ TEST_F(QuotaFileUtilTest, MoveDirectory) {
                                                    Path(from_file),
                                                    1020));
   ASSERT_EQ(2040, GetCachedUsage());
-  ASSERT_EQ(2040, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1019);
@@ -430,7 +369,6 @@ TEST_F(QuotaFileUtilTest, MoveDirectory) {
                                                Path(from_dir),
                                                Path(to_dir2)));
   ASSERT_EQ(2040, GetCachedUsage());
-  ASSERT_EQ(2040, usage());
 }
 
 TEST_F(QuotaFileUtilTest, Remove) {
@@ -460,7 +398,6 @@ TEST_F(QuotaFileUtilTest, Remove) {
                                                    Path(file),
                                                    340));
   ASSERT_EQ(340, GetCachedUsage());
-  ASSERT_EQ(340, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -469,7 +406,6 @@ TEST_F(QuotaFileUtilTest, Remove) {
                                                    Path(dfile1),
                                                    1020));
   ASSERT_EQ(1360, GetCachedUsage());
-  ASSERT_EQ(1360, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -478,7 +414,6 @@ TEST_F(QuotaFileUtilTest, Remove) {
                                                    Path(dfile2),
                                                    120));
   ASSERT_EQ(1480, GetCachedUsage());
-  ASSERT_EQ(1480, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -487,7 +422,6 @@ TEST_F(QuotaFileUtilTest, Remove) {
                                                  Path(file),
                                                  false));
   ASSERT_EQ(1140, GetCachedUsage());
-  ASSERT_EQ(1140, usage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -496,5 +430,4 @@ TEST_F(QuotaFileUtilTest, Remove) {
                                                  Path(dir),
                                                  true));
   ASSERT_EQ(0, GetCachedUsage());
-  ASSERT_EQ(0, usage());
 }
diff --git a/webkit/quota/quota_database_unittest.cc b/webkit/quota/quota_database_unittest.cc
index 5e2f2d6..ccbe74f 100644
--- a/webkit/quota/quota_database_unittest.cc
+++ b/webkit/quota/quota_database_unittest.cc
@@ -10,6 +10,21 @@
 #include "googleurl/src/gurl.h"
 #include "webkit/quota/quota_database.h"
 
+namespace {
+
+const base::Time kZeroTime;
+
+class TestErrorDelegate : public sql::ErrorDelegate {
+ public:
+  virtual ~TestErrorDelegate() { }
+  virtual int OnError(
+      int error, sql::Connection* connection, sql::Statement* stmt) {
+    return error;
+  }
+};
+
+}  // namespace
+
 namespace quota {
 
 TEST(QuotaDatabaseTest, LazyOpen) {
diff --git a/webkit/quota/quota_manager.h b/webkit/quota/quota_manager.h
index 949f1e2..eb8d70f 100644
--- a/webkit/quota/quota_manager.h
+++ b/webkit/quota/quota_manager.h
@@ -81,16 +81,6 @@ class QuotaManager : public QuotaTaskObserver,
 
   const static int64 kIncognitoDefaultTemporaryQuota;
 
- protected:
-  // Called by clients via proxy.
-  // QuotaClients must call this method whenever they have made any
-  // modifications that change the amount of data stored in their storage.
-  // This method is declared as virtual only to allow test code to override.
-  virtual void NotifyStorageModified(QuotaClient::ID client_id,
-                                     const GURL& origin,
-                                     StorageType type,
-                                     int64 delta);
-
  private:
   class InitializeTask;
   class TemporaryGlobalQuotaUpdateTask;
@@ -117,6 +107,14 @@ class QuotaManager : public QuotaTaskObserver,
   // The client must remain valid until OnQuotaManagerDestored is called.
   void RegisterClient(QuotaClient* client);
 
+  // Called by clients via proxy.
+  // QuotaClients must call this method whenever they have made any
+  // modifications that change the amount of data stored in their storage.
+  void NotifyStorageModified(QuotaClient::ID client_id,
+                             const GURL& origin,
+                             StorageType type,
+                             int64 delta);
+
   UsageTracker* GetUsageTracker(StorageType type) const;
 
   void DidGetTemporaryGlobalQuota(int64 quota);
@@ -162,9 +160,9 @@ class QuotaManagerProxy
  public:
   void RegisterClient(QuotaClient* client);
   void NotifyStorageModified(QuotaClient::ID client_id,
-                             const GURL& origin,
-                             StorageType type,
-                             int64 delta);
+                            const GURL& origin,
+                            StorageType type,
+                            int64 delta);
  private:
   friend class QuotaManager;
   friend class base::RefCountedThreadSafe<QuotaManagerProxy>;