Notify the quota manager when write operation is made in FileSystem API.

BUG=74841
TEST=QuotaFileUtilTest.*


Review URL: http://codereview.chromium.org/6903067

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

7 files changed, 234 insertions, 101 deletions

diff --git a/webkit/fileapi/file_writer_delegate.cc b/webkit/fileapi/file_writer_delegate.cc
index 1f80620..7045970 100644
--- a/webkit/fileapi/file_writer_delegate.cc
+++ b/webkit/fileapi/file_writer_delegate.cc
@@ -12,7 +12,9 @@
 #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 {
 
@@ -92,7 +94,7 @@ FileWriterDelegate::FileWriterDelegate(
       file_(base::kInvalidPlatformFileValue),
       offset_(offset),
       proxy_(proxy),
-      bytes_read_backlog_(0),
+      bytes_written_backlog_(0),
       bytes_written_(0),
       bytes_read_(0),
       total_bytes_written_(0),
@@ -260,31 +262,40 @@ void FileWriterDelegate::OnError(base::PlatformFileError error) {
   file_system_operation_->DidWrite(error, 0, true);
 }
 
-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()) {
+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()) {
     proxy_->PostTask(FROM_HERE, NewRunnableFunction(
         &FileSystemUsageCache::AtomicUpdateUsageByDelta,
-        usage_file_path_, bytes_read));
+        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);
   }
   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_read += bytes_read_backlog_;
+    bytes_written += bytes_written_backlog_;
     last_progress_event_time_ = currentTime;
-    bytes_read_backlog_ = 0;
+    bytes_written_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_read, done);
+        base::PLATFORM_FILE_OK, bytes_written, done);
     return;
   }
-  bytes_read_backlog_ += bytes_read;
+  bytes_written_backlog_ += bytes_written;
 }
 
 }  // namespace fileapi
diff --git a/webkit/fileapi/file_writer_delegate.h b/webkit/fileapi/file_writer_delegate.h
index d95cc42..d75bd31 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_read_backlog_;
+  int bytes_written_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 d56c7ae..af46faf 100644
--- a/webkit/fileapi/file_writer_delegate_unittest.cc
+++ b/webkit/fileapi/file_writer_delegate_unittest.cc
@@ -27,6 +27,12 @@
 #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 {
 
@@ -51,6 +57,29 @@ 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()
@@ -81,40 +110,7 @@ class Result {
   bool complete_;
 };
 
-}  // 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;
+static const char* g_content = NULL;
 
 class FileWriterDelegateTestJob : public net::URLRequestJob {
  public:
@@ -191,6 +187,47 @@ 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,
@@ -205,13 +242,17 @@ void FileWriterDelegateTest::SetUp() {
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(filesystem_dir_,
                                                   &file_path_));
 
-  context_.reset(new FileSystemOperationContext(
+  quota_manager_ = new MockQuotaManager(filesystem_dir_);
+  file_system_context_ =
       new FileSystemContext(base::MessageLoopProxy::CreateForCurrentThread(),
                             base::MessageLoopProxy::CreateForCurrentThread(),
-                            NULL, NULL, FilePath(), false /* is_incognito */,
+                            NULL, quota_manager_->proxy(),
+                            FilePath(), false /* is_incognito */,
                             true, true,
                             new MockFileSystemPathManager(filesystem_dir_)),
-      NULL));
+
+  context_.reset(new FileSystemOperationContext(
+      file_system_context_.get(), NULL));
 
   usage_file_path_ =
       filesystem_dir_.AppendASCII(FileSystemUsageCache::kUsageFileName);
@@ -233,25 +274,32 @@ void FileWriterDelegateTest::SetUp() {
 
 void FileWriterDelegateTest::TearDown() {
   net::URLRequest::RegisterProtocolFactory("blob", NULL);
-  result_.reset(NULL);
+  result_.reset();
   base::ClosePlatformFile(file_);
-  context_.reset(NULL);
+  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();
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
   GURL blob_url("blob:nolimit");
-  g_content = std::string("The quick brown fox jumps over the lazy dog.\n");
+  g_content = "The quick brown fox jumps over the lazy dog.\n";
   file_writer_delegate_.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result_.get()), NULL, NULL,
+      new FileSystemOperation(new MockDispatcher(result_.get()),
+                              NULL, file_system_context(),
                               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());
@@ -262,9 +310,10 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
   GURL blob_url("blob:just");
-  g_content = std::string("The quick brown fox jumps over the lazy dog.\n");
+  g_content = "The quick brown fox jumps over the lazy dog.\n";
   file_writer_delegate_.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result_.get()), NULL, NULL,
+      new FileSystemOperation(new MockDispatcher(result_.get()),
+                              NULL, file_system_context(),
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
@@ -274,6 +323,7 @@ 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);
 
@@ -284,9 +334,10 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
 
 TEST_F(FileWriterDelegateTest, WriteFailureByQuota) {
   GURL blob_url("blob:failure");
-  g_content = std::string("The quick brown fox jumps over the lazy dog.\n");
+  g_content = "The quick brown fox jumps over the lazy dog.\n";
   file_writer_delegate_.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result_.get()), NULL, NULL,
+      new FileSystemOperation(new MockDispatcher(result_.get()),
+                              NULL, file_system_context(),
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
@@ -296,6 +347,7 @@ 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);
 
@@ -306,9 +358,10 @@ TEST_F(FileWriterDelegateTest, WriteFailureByQuota) {
 
 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) {
   GURL blob_url("blob:zero");
-  g_content = std::string("");
+  g_content = "";
   file_writer_delegate_.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result_.get()), NULL, NULL,
+      new FileSystemOperation(new MockDispatcher(result_.get()),
+                              NULL, file_system_context(),
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
@@ -318,6 +371,7 @@ 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);
 
@@ -343,24 +397,20 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimitConcurrent) {
   ASSERT_EQ(base::PLATFORM_FILE_OK, error_code);
 
   context2.reset(new FileSystemOperationContext(
-      new FileSystemContext(base::MessageLoopProxy::CreateForCurrentThread(),
-                            base::MessageLoopProxy::CreateForCurrentThread(),
-                            NULL, NULL, FilePath(), false /* is_incognito */,
-                            true, true,
-                            new MockFileSystemPathManager(filesystem_dir_)),
-      NULL));
-
+      file_system_context(), NULL));
   result2.reset(new Result());
 
   GURL blob_url("blob:nolimitconcurrent");
   GURL blob_url2("blob:nolimitconcurrent2");
-  g_content = std::string("The quick brown fox jumps over the lazy dog.\n");
+  g_content = "The quick brown fox jumps over the lazy dog.\n";
   file_writer_delegate_.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result_.get()), NULL, NULL,
+      new FileSystemOperation(new MockDispatcher(result_.get()),
+                              NULL, file_system_context(),
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   file_writer_delegate2.reset(new FileWriterDelegate(
-      new FileSystemOperation(new MockDispatcher(result2.get()), NULL, NULL,
+      new FileSystemOperation(new MockDispatcher(result2.get()),
+                              NULL, file_system_context(),
                               QuotaFileUtil::GetInstance()),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
   request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
@@ -375,6 +425,7 @@ 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 820b6a8..3167313 100644
--- a/webkit/fileapi/quota_file_util.cc
+++ b/webkit/fileapi/quota_file_util.cc
@@ -6,10 +6,13 @@
 
 #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 {
 
@@ -54,13 +57,23 @@ static FilePath InitUsageFile(FileSystemOperationContext* fs_context) {
   return usage_file_path;
 }
 
-static void UpdateUsageFile(const FilePath& usage_file_path, int64 growth) {
+static void UpdateUsage(
+    FileSystemOperationContext* fs_context,
+    const GURL& modified_origin,
+    FileSystemType type,
+    const FilePath& usage_file_path, int64 growth) {
   if (FileSystemUsageCache::Exists(usage_file_path))
     FileSystemUsageCache::DecrementDirty(usage_file_path);
 
-  int64 usage = FileSystemUsageCache::GetUsage(usage_file_path);
-  if (usage >= 0)
-    FileSystemUsageCache::UpdateUsage(usage_file_path, usage + growth);
+  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);
 }
 
 }  // namespace (anonymous)
@@ -99,7 +112,9 @@ base::PlatformFileError QuotaFileUtil::CopyOrMoveFile(
   base::PlatformFileError error = FileSystemFileUtil::GetInstance()->
       CopyOrMoveFile(fs_context, src_file_path, dest_file_path, copy);
 
-  UpdateUsageFile(usage_file_path, growth);
+  UpdateUsage(fs_context,
+              fs_context->dest_origin_url(), fs_context->dest_type(),
+              usage_file_path, growth);
 
   return error;
 }
@@ -118,7 +133,8 @@ base::PlatformFileError QuotaFileUtil::DeleteFile(
   base::PlatformFileError error = FileSystemFileUtil::GetInstance()->
       DeleteFile(fs_context, file_path);
 
-  UpdateUsageFile(usage_file_path, growth);
+  UpdateUsage(fs_context, fs_context->src_origin_url(), fs_context->src_type(),
+              usage_file_path, growth);
 
   return error;
 }
@@ -148,7 +164,8 @@ base::PlatformFileError QuotaFileUtil::Truncate(
   base::PlatformFileError error = FileSystemFileUtil::GetInstance()->Truncate(
       fs_context, path, length);
 
-  UpdateUsageFile(usage_file_path, growth);
+  UpdateUsage(fs_context, fs_context->src_origin_url(), fs_context->src_type(),
+              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 bb76f65..4fad014 100644
--- a/webkit/fileapi/quota_file_util_unittest.cc
+++ b/webkit/fileapi/quota_file_util_unittest.cc
@@ -16,8 +16,14 @@
 #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 {
 
@@ -40,6 +46,30 @@ 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_;
+};
+
 }  // namespace (anonymous)
 
 class QuotaFileUtilTest : public testing::Test {
@@ -55,6 +85,8 @@ class QuotaFileUtilTest : public testing::Test {
 
     usage_file_path_ = Path(FileSystemUsageCache::kUsageFileName);
     FileSystemUsageCache::UpdateUsage(usage_file_path_, 0);
+
+    quota_manager_ = new MockQuotaManager(filesystem_dir_);
   }
 
  protected:
@@ -62,7 +94,7 @@ class QuotaFileUtilTest : public testing::Test {
     FileSystemOperationContext *context = new FileSystemOperationContext(
         new FileSystemContext(base::MessageLoopProxy::CreateForCurrentThread(),
                               base::MessageLoopProxy::CreateForCurrentThread(),
-                              NULL, NULL, FilePath(), false,
+                              NULL, quota_manager_proxy(), FilePath(), false,
                               true, true,
                               new MockFileSystemPathManager(filesystem_dir_)),
         QuotaFileUtil::GetInstance());
@@ -99,11 +131,21 @@ 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);
 };
@@ -147,6 +189,7 @@ 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);
@@ -155,6 +198,7 @@ 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);
@@ -163,6 +207,7 @@ TEST_F(QuotaFileUtilTest, Truncate) {
                                                    Path(file_name),
                                                    1021));
   ASSERT_EQ(0, GetCachedUsage());
+  ASSERT_EQ(0, usage());
 }
 
 TEST_F(QuotaFileUtilTest, CopyFile) {
@@ -184,6 +229,7 @@ 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);
@@ -192,6 +238,7 @@ 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);
@@ -200,6 +247,7 @@ 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);
@@ -208,6 +256,7 @@ 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);
@@ -216,6 +265,7 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
                                                Path(from_file),
                                                Path(obstacle_file)));
   ASSERT_EQ(3060, GetCachedUsage());
+  ASSERT_EQ(3060, usage());
 }
 
 TEST_F(QuotaFileUtilTest, CopyDirectory) {
@@ -241,6 +291,7 @@ 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);
@@ -249,6 +300,7 @@ 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);
@@ -257,6 +309,7 @@ TEST_F(QuotaFileUtilTest, CopyDirectory) {
                                                Path(from_dir),
                                                Path(to_dir2)));
   ASSERT_EQ(2040, GetCachedUsage());
+  ASSERT_EQ(2040, usage());
 }
 
 TEST_F(QuotaFileUtilTest, MoveFile) {
@@ -275,6 +328,7 @@ 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);
@@ -283,6 +337,7 @@ 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);
@@ -296,6 +351,7 @@ 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);
@@ -304,6 +360,7 @@ 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);
@@ -312,6 +369,7 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
                                                Path(from_file),
                                                Path(obstacle_file)));
   ASSERT_EQ(2040, GetCachedUsage());
+  ASSERT_EQ(2040, usage());
 }
 
 TEST_F(QuotaFileUtilTest, MoveDirectory) {
@@ -337,6 +395,7 @@ 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);
@@ -345,6 +404,7 @@ 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,
@@ -361,6 +421,7 @@ 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);
@@ -369,6 +430,7 @@ TEST_F(QuotaFileUtilTest, MoveDirectory) {
                                                Path(from_dir),
                                                Path(to_dir2)));
   ASSERT_EQ(2040, GetCachedUsage());
+  ASSERT_EQ(2040, usage());
 }
 
 TEST_F(QuotaFileUtilTest, Remove) {
@@ -398,6 +460,7 @@ 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);
@@ -406,6 +469,7 @@ 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);
@@ -414,6 +478,7 @@ 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);
@@ -422,6 +487,7 @@ 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);
@@ -430,4 +496,5 @@ 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 ccbe74f..5e2f2d6 100644
--- a/webkit/quota/quota_database_unittest.cc
+++ b/webkit/quota/quota_database_unittest.cc
@@ -10,21 +10,6 @@
 #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 eb8d70f..949f1e2 100644
--- a/webkit/quota/quota_manager.h
+++ b/webkit/quota/quota_manager.h
@@ -81,6 +81,16 @@ 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;
@@ -107,14 +117,6 @@ 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);
@@ -160,9 +162,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>;