Notify read access to the QuotaManager in FileSystemOperation

webkit/fileapi/file_system_operation_unittest.cc

 // Copyright (c) 2011 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 "webkit/fileapi/file_system_operation.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
-#include "base/sys_string_conversions.h"
-#include "base/utf_string_conversions.h"
+#include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation.h"
+#include "webkit/fileapi/file_system_quota_util.h"
 #include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/local_file_system_file_util.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 {
 
+namespace {
+
 const int kFileOperationStatusNotSet = 1;
 
-namespace {
-
 class MockQuotaManager : public QuotaManager {
  public:
-  MockQuotaManager(const FilePath& base_dir)
-      : QuotaManager(false /* is_incognito */, base_dir,
-                     base::MessageLoopProxy::CreateForCurrentThread(),
-                     base::MessageLoopProxy::CreateForCurrentThread()),
-        usage_(0),
-        quota_(QuotaFileUtil::kNoLimit) {}
+  explicit MockQuotaManager(const FilePath& base_dir,

[ericu, 2011/05/24 03:03:56]

The explicit shouldn't be needed on a multiple-argument constructor.

[kinuko, 2011/05/24 03:09:32]

Oops, yup, I was warned by lint before making this change.  Will fix.

+                            const GURL& origin,
+                            StorageType type)
+    : QuotaManager(false /* is_incognito */, base_dir,
+                   base::MessageLoopProxy::CreateForCurrentThread(),
+                   base::MessageLoopProxy::CreateForCurrentThread()),
+      origin_(origin),
+      type_(type),
+      usage_(0),
+      quota_(QuotaFileUtil::kNoLimit),
+      accessed_(0) {}
 
-  virtual void GetUsageAndQuota(const GURL& origin, quota::StorageType type,
-                                GetUsageAndQuotaCallback* callback) {
+  virtual void GetUsageAndQuota(
+      const GURL& origin, quota::StorageType type,
+      GetUsageAndQuotaCallback* callback) {
+    EXPECT_EQ(origin_, origin);
+    EXPECT_EQ(type_, type);
     callback->Run(quota::kQuotaStatusOk, usage_, quota_);
     delete callback;
   }
 
-  void set_usage(int64 usage) { usage_ = usage; }
-  void set_quota(int64 quota) { quota_ = quota; }
+ private:
+  friend class MockQuotaManagerProxy;
+  void SetQuota(const GURL& origin, StorageType type, int64 quota) {
+    EXPECT_EQ(origin_, origin);
+    EXPECT_EQ(type_, type);
+    quota_ = quota;
+  }
+
+  void RecordStorageAccessed(const GURL& origin, StorageType type) {
+    EXPECT_EQ(origin_, origin);
+    EXPECT_EQ(type_, type);
+    ++accessed_;
+  }
+
+  void UpdateUsage(const GURL& origin, StorageType type, int64 delta) {
+    EXPECT_EQ(origin_, origin);
+    EXPECT_EQ(type_, type);
+    usage_ += delta;
+  }
+
+  const GURL& origin_;
+  const StorageType type_;
+  int64 usage_;
+  int64 quota_;
+  int accessed_;
+};
+
+class MockQuotaManagerProxy : public QuotaManagerProxy {
+ public:
+  explicit MockQuotaManagerProxy(QuotaManager* quota_manager)
+      : QuotaManagerProxy(quota_manager,
+                          base::MessageLoopProxy::CreateForCurrentThread()) {}
+
+  // We don't mock them.
+  virtual void RegisterClient(QuotaClient* client) OVERRIDE {}

[oshima, 2011/05/25 20:43:38]

Looks like this has to call OnQuotaManagerDestoryed on the client when this
object is deleted?

+  virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
+  virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
+
+  virtual void NotifyStorageAccessed(QuotaClient::ID client_id,
+                                     const GURL& origin,
+                                     StorageType type) OVERRIDE {
+    mock_manager()->RecordStorageAccessed(origin, type);
+  }
+
+  virtual void NotifyStorageModified(QuotaClient::ID client_id,
+                                     const GURL& origin,
+                                     StorageType type,
+                                     int64 delta) OVERRIDE {
+    mock_manager()->UpdateUsage(origin, type, delta);
+  }
+
+  int storage_accessed_count() const {
+    return mock_manager()->accessed_;
+  }
+
+  void SetQuota(const GURL& origin, StorageType type, int64 quota) {
+    mock_manager()->SetQuota(origin, type, quota);
+  }
 
  private:
-  int64 usage_;
-  int64 quota_;
+  MockQuotaManager* mock_manager() const {
+    return static_cast<MockQuotaManager*>(quota_manager());
+  }
 };
 
-FilePath UTF8ToFilePath(const std::string& str) {
-  FilePath::StringType result;
-#if defined(OS_POSIX)
-  result = base::SysWideToNativeMB(UTF8ToWide(str));
-#elif defined(OS_WIN)
-  result = UTF8ToUTF16(str);
-#endif
-  return FilePath(result);
+FilePath ASCIIToFilePath(const std::string& str) {
+  return FilePath().AppendASCII(str);
 }
 
 }  // namespace (anonymous)
 
 // Test class for FileSystemOperation.  Note that this just tests low-level
 // operations but doesn't test OpenFileSystem.
 class FileSystemOperationTest : public testing::Test {
  public:
   FileSystemOperationTest()
       : status_(kFileOperationStatusNotSet) {
     EXPECT_TRUE(base_.CreateUniqueTempDir());
   }
 
   FileSystemOperation* operation();
 
-  void set_local_path(const FilePath& path) { local_path_ = path; }
-  const FilePath& local_path() const { return local_path_; }
   void set_status(int status) { status_ = status; }
   int status() const { return status_; }
   void set_info(const base::PlatformFileInfo& info) { info_ = info; }
   const base::PlatformFileInfo& info() const { return info_; }
   void set_path(const FilePath& path) { path_ = path; }
   const FilePath& path() const { return path_; }
   void set_entries(const std::vector<base::FileUtilProxy::Entry>& entries) {
     entries_ = entries;
   }
   const std::vector<base::FileUtilProxy::Entry>& entries() const {
     return entries_;
   }
 
   virtual void SetUp();
   virtual void TearDown();
 
  protected:
   // Common temp base for nondestructive uses.
   ScopedTempDir base_;
 
-  MockQuotaManager* quota_manager() {
-    return static_cast<MockQuotaManager*>(quota_manager_.get());
+  MockQuotaManagerProxy* quota_manager_proxy() {
+    return static_cast<MockQuotaManagerProxy*>(quota_manager_proxy_.get());
   }
 
   GURL URLForPath(const FilePath& path) const {
     return test_helper_.GetURLForPath(path);
   }
 
-  FilePath PlatformPath(FilePath virtual_path) {
+  FilePath PlatformPath(const FilePath& virtual_path) {
     return test_helper_.GetLocalPath(virtual_path);
   }
 
-  bool VirtualFileExists(FilePath virtual_path) {
+  bool VirtualFileExists(const FilePath& virtual_path) {
     return file_util::PathExists(PlatformPath(virtual_path)) &&
         !file_util::DirectoryExists(PlatformPath(virtual_path));
   }
 
-  bool VirtualDirectoryExists(FilePath virtual_path) {
+  bool VirtualDirectoryExists(const FilePath& virtual_path) {
     return file_util::DirectoryExists(PlatformPath(virtual_path));
   }
 
   FilePath CreateVirtualDirectory(const char* virtual_path_string) {
-    FilePath virtual_path(UTF8ToFilePath(virtual_path_string));
+    FilePath virtual_path(ASCIIToFilePath(virtual_path_string));
     file_util::CreateDirectory(PlatformPath(virtual_path));
     return virtual_path;
   }
 
   FilePath CreateVirtualDirectoryInDir(const char* virtual_path_string,
                                        const FilePath& virtual_dir_path) {
     FilePath virtual_path(virtual_dir_path.AppendASCII(virtual_path_string));
     file_util::CreateDirectory(PlatformPath(virtual_path));
     return virtual_path;
   }
@@ skipping 22 matching lines @@
   FilePath CreateVirtualTemporaryDir() {
     return CreateVirtualTemporaryDirInDir(FilePath());
   }
 
   FileSystemTestOriginHelper test_helper_;
 
   // For post-operation status.
   int status_;
   base::PlatformFileInfo info_;
   FilePath path_;
-  FilePath local_path_;
   std::vector<base::FileUtilProxy::Entry> entries_;
 
  private:
   scoped_refptr<QuotaManager> quota_manager_;
+  scoped_refptr<QuotaManagerProxy> quota_manager_proxy_;
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperationTest);
 };
 
 namespace {
 
 class MockDispatcher : public FileSystemCallbackDispatcher {
  public:
-  MockDispatcher(FileSystemOperationTest* test) : test_(test) { }
+  explicit MockDispatcher(FileSystemOperationTest* test) : test_(test) { }
 
   virtual void DidFail(base::PlatformFileError status) {
     test_->set_status(status);
   }
 
   virtual void DidSucceed() {
     test_->set_status(base::PLATFORM_FILE_OK);
   }
 
   virtual void DidReadMetadata(
@@ skipping 19 matching lines @@
   }
 
  private:
   FileSystemOperationTest* test_;
 };
 
 }  // namespace (anonymous)
 
 void FileSystemOperationTest::SetUp() {
   FilePath base_dir = base_.path().AppendASCII("filesystem");
-  quota_manager_ = new MockQuotaManager(base_dir);
+  quota_manager_ = new MockQuotaManager(
+      base_dir, test_helper_.origin(), test_helper_.storage_type());
+  quota_manager_proxy_ = new MockQuotaManagerProxy(quota_manager_.get());
   test_helper_.SetUp(base_dir,
                      false /* incognito */,
                      false /* unlimited quota */,
-                     quota_manager_->proxy(),
+                     quota_manager_proxy_.get(),
                      LocalFileSystemFileUtil::GetInstance());
 }
 
 void FileSystemOperationTest::TearDown() {
   quota_manager_ = NULL;
+  quota_manager_proxy_ = NULL;
   test_helper_.TearDown();
 }
 
 FileSystemOperation* FileSystemOperationTest::operation() {
   return test_helper_.NewOperation(new MockDispatcher(this));
 }
 
 TEST_F(FileSystemOperationTest, TestMoveFailureSrcDoesntExist) {
   GURL src(URLForPath(FilePath(FILE_PATH_LITERAL("a"))));
   GURL dest(URLForPath(FilePath(FILE_PATH_LITERAL("b"))));
@@ skipping 57 matching lines @@
 TEST_F(FileSystemOperationTest, TestMoveSuccessSrcFileAndOverwrite) {
   FilePath src_dir_path(CreateVirtualTemporaryDir());
   FilePath src_file_path(CreateVirtualTemporaryFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateVirtualTemporaryDir());
   FilePath dest_file_path(CreateVirtualTemporaryFileInDir(dest_dir_path));
 
   operation()->Move(URLForPath(src_file_path), URLForPath(dest_file_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(VirtualFileExists(dest_file_path));
+
+  // Move is considered 'write' access (for both side), and won't be counted
+  // as read access.
+  EXPECT_EQ(0, quota_manager_proxy()->storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationTest, TestMoveSuccessSrcFileAndNew) {
   FilePath src_dir_path(CreateVirtualTemporaryDir());
   FilePath src_file_path(CreateVirtualTemporaryFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateVirtualTemporaryDir());
   FilePath dest_file_path(dest_dir_path.Append(FILE_PATH_LITERAL("NewFile")));
 
   operation()->Move(URLForPath(src_file_path), URLForPath(dest_file_path));
   MessageLoop::current()->RunAllPending();
@@ skipping 110 matching lines @@
 }
 
 TEST_F(FileSystemOperationTest, TestCopyFailureByQuota) {
   base::PlatformFileInfo info;
 
   FilePath src_dir_path(CreateVirtualTemporaryDir());
   FilePath src_file_path(CreateVirtualTemporaryFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateVirtualTemporaryDir());
   FilePath dest_file_path(dest_dir_path.Append(FILE_PATH_LITERAL("NewFile")));
 
-  quota_manager()->set_quota(11);
+  quota_manager_proxy()->SetQuota(test_helper_.origin(),
+                                  test_helper_.storage_type(),
+                                  11);
 
   operation()->Truncate(URLForPath(src_file_path), 6);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
 
   EXPECT_TRUE(file_util::GetFileInfo(PlatformPath(src_file_path), &info));
   EXPECT_EQ(6, info.size);
 
-  quota_manager()->set_usage(6);
-
   operation()->Copy(URLForPath(src_file_path), URLForPath(dest_file_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, status());
   EXPECT_FALSE(VirtualFileExists(dest_file_path));
 }
 
 TEST_F(FileSystemOperationTest, TestCopySuccessSrcFileAndOverwrite) {
   FilePath src_dir_path(CreateVirtualTemporaryDir());
   FilePath src_file_path(CreateVirtualTemporaryFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateVirtualTemporaryDir());
   FilePath dest_file_path(CreateVirtualTemporaryFileInDir(dest_dir_path));
 
   operation()->Copy(URLForPath(src_file_path), URLForPath(dest_file_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(VirtualFileExists(dest_file_path));
+  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationTest, TestCopySuccessSrcFileAndNew) {
   FilePath src_dir_path(CreateVirtualTemporaryDir());
   FilePath src_file_path(CreateVirtualTemporaryFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateVirtualTemporaryDir());
   FilePath dest_file_path(dest_dir_path.Append(FILE_PATH_LITERAL("NewFile")));
 
   operation()->Copy(URLForPath(src_file_path), URLForPath(dest_file_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(VirtualFileExists(dest_file_path));
+  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationTest, TestCopySuccessSrcDirAndOverwrite) {
   FilePath src_dir_path(CreateVirtualTemporaryDir());
   FilePath dest_dir_path(CreateVirtualTemporaryDir());
 
   operation()->Copy(URLForPath(src_dir_path), URLForPath(dest_dir_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
 
   // Make sure we've overwritten but not copied the source under the |dest_dir|.
   EXPECT_TRUE(VirtualDirectoryExists(dest_dir_path));
   EXPECT_FALSE(VirtualDirectoryExists(
       dest_dir_path.Append(src_dir_path.BaseName())));
+  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationTest, TestCopySuccessSrcDirAndNew) {
   FilePath src_dir_path(CreateVirtualTemporaryDir());
   FilePath dest_parent_dir_path(CreateVirtualTemporaryDir());
   FilePath dest_child_dir_path(dest_parent_dir_path.
       Append(FILE_PATH_LITERAL("NewDirectory")));
 
   operation()->Copy(URLForPath(src_dir_path), URLForPath(dest_child_dir_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(VirtualDirectoryExists(dest_child_dir_path));
+  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationTest, TestCopySuccessSrcDirRecursive) {
   FilePath src_dir_path(CreateVirtualTemporaryDir());
   FilePath child_dir_path(CreateVirtualTemporaryDirInDir(src_dir_path));
   FilePath grandchild_file_path(
       CreateVirtualTemporaryFileInDir(child_dir_path));
 
   FilePath dest_dir_path(CreateVirtualTemporaryDir());
 
   operation()->Copy(URLForPath(src_dir_path), URLForPath(dest_dir_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(VirtualDirectoryExists(dest_dir_path.Append(
       child_dir_path.BaseName())));
   EXPECT_TRUE(VirtualFileExists(dest_dir_path.Append(
       child_dir_path.BaseName()).Append(
       grandchild_file_path.BaseName())));
+  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationTest, TestCreateFileFailure) {
   // Already existing file and exclusive true.
   FilePath dir_path(CreateVirtualTemporaryDir());
   FilePath file_path(CreateVirtualTemporaryFileInDir(dir_path));
   operation()->CreateFile(URLForPath(file_path), true);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, status());
 }
@@ skipping 27 matching lines @@
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
 }
 
 TEST_F(FileSystemOperationTest,
        TestCreateDirFailureDestParentDoesntExist) {
   // Dest. parent path does not exist.
   FilePath nonexisting_path(FilePath(
       FILE_PATH_LITERAL("DirDoesntExist")));
   FilePath nonexisting_file_path(nonexisting_path.Append(
       FILE_PATH_LITERAL("FileDoesntExist")));
-  operation()->CreateDirectory(URLForPath(nonexisting_file_path), false, false);
+  operation()->CreateDirectory(
+      URLForPath(nonexisting_file_path), false, false);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 }
 
 TEST_F(FileSystemOperationTest, TestCreateDirFailureDirExists) {
   // Exclusive and dir existing at path.
   FilePath src_dir_path(CreateVirtualTemporaryDir());
   operation()->CreateDirectory(URLForPath(src_dir_path), true, false);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, status());
@@ skipping 11 matching lines @@
 TEST_F(FileSystemOperationTest, TestCreateDirSuccess) {
   // Dir exists and exclusive is false.
   FilePath dir_path(CreateVirtualTemporaryDir());
   operation()->CreateDirectory(URLForPath(dir_path), false, false);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
 
   // Dir doesn't exist.
   FilePath nonexisting_dir_path(FilePath(
       FILE_PATH_LITERAL("nonexistingdir")));
-  operation()->CreateDirectory(URLForPath(nonexisting_dir_path), false, false);
+  operation()->CreateDirectory(
+      URLForPath(nonexisting_dir_path), false, false);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(VirtualDirectoryExists(nonexisting_dir_path));
 }
 
 TEST_F(FileSystemOperationTest, TestCreateDirSuccessExclusive) {
   // Dir doesn't exist.
   FilePath nonexisting_dir_path(FilePath(
       FILE_PATH_LITERAL("nonexistingdir")));
 
-  operation()->CreateDirectory(URLForPath(nonexisting_dir_path), true, false);
+  operation()->CreateDirectory(
+      URLForPath(nonexisting_dir_path), true, false);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(VirtualDirectoryExists(nonexisting_dir_path));
 }
 
 TEST_F(FileSystemOperationTest, TestExistsAndMetadataFailure) {
   FilePath nonexisting_dir_path(FilePath(
       FILE_PATH_LITERAL("nonexistingdir")));
   operation()->GetMetadata(URLForPath(nonexisting_dir_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 
   operation()->FileExists(URLForPath(nonexisting_dir_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 
   file_util::EnsureEndsWithSeparator(&nonexisting_dir_path);
   operation()->DirectoryExists(URLForPath(nonexisting_dir_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 }
 
 TEST_F(FileSystemOperationTest, TestExistsAndMetadataSuccess) {
   FilePath dir_path(CreateVirtualTemporaryDir());
+  int read_access = 0;
 
   operation()->DirectoryExists(URLForPath(dir_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  ++read_access;
 
   operation()->GetMetadata(URLForPath(dir_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(info().is_directory);
   EXPECT_EQ(PlatformPath(dir_path), path());
+  ++read_access;
 
   FilePath file_path(CreateVirtualTemporaryFileInDir(dir_path));
   operation()->FileExists(URLForPath(file_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  ++read_access;
 
   operation()->GetMetadata(URLForPath(file_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_FALSE(info().is_directory);
   EXPECT_EQ(PlatformPath(file_path), path());
+  ++read_access;
+
+  EXPECT_EQ(read_access, quota_manager_proxy()->storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationTest, TestTypeMismatchErrors) {
   FilePath dir_path(CreateVirtualTemporaryDir());
   operation()->FileExists(URLForPath(dir_path));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_FILE, status());
 
   FilePath file_path(CreateVirtualTemporaryFileInDir(dir_path));
   ASSERT_FALSE(file_path.empty());
@@ skipping 37 matching lines @@
 
   for (size_t i = 0; i < entries().size(); ++i) {
     if (entries()[i].is_directory) {
       EXPECT_EQ(child_dir_path.BaseName().value(),
                 entries()[i].name);
     } else {
       EXPECT_EQ(child_file_path.BaseName().value(),
                 entries()[i].name);
     }
   }
+  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationTest, TestRemoveFailure) {
   // Path doesn't exist.
   FilePath nonexisting_path(FilePath(
       FILE_PATH_LITERAL("NonExistingDir")));
   file_util::EnsureEndsWithSeparator(&nonexisting_path);
 
   operation()->Remove(URLForPath(nonexisting_path), false /* recursive */);
   MessageLoop::current()->RunAllPending();
@@ skipping 32 matching lines @@
   // Verify deleting parent_dir.
   FilePath parent_dir_path(CreateVirtualTemporaryDir());
   FilePath child_file_path(CreateVirtualTemporaryFileInDir(parent_dir_path));
   FilePath child_dir_path(CreateVirtualTemporaryDirInDir(parent_dir_path));
   ASSERT_FALSE(child_dir_path.empty());
 
   operation()->Remove(URLForPath(parent_dir_path), true /* recursive */);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_FALSE(VirtualDirectoryExists(parent_dir_path));
+
+  // Remove is not a 'read' access.
+  EXPECT_EQ(0, quota_manager_proxy()->storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationTest, TestTruncate) {
   FilePath dir_path(CreateVirtualTemporaryDir());
   FilePath file_path(CreateVirtualTemporaryFileInDir(dir_path));
 
   char test_data[] = "test data";
   int data_size = static_cast<int>(sizeof(test_data));
   EXPECT_EQ(data_size,
             file_util::WriteFile(PlatformPath(file_path),
@@ skipping 32 matching lines @@
   operation()->Truncate(URLForPath(file_path), length);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
 
   // Check that its length is now 3 and that it contains only bits of test data.
   EXPECT_TRUE(file_util::GetFileInfo(PlatformPath(file_path), &info));
   EXPECT_EQ(length, info.size);
   EXPECT_EQ(length, file_util::ReadFile(PlatformPath(file_path), data, length));
   for (int i = 0; i < length; ++i)
     EXPECT_EQ(test_data[i], data[i]);
+
+  // Truncate is not a 'read' access.  (Here expected access count is 1
+  // since we made 1 read access for GetMetadata.)
+  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationTest, TestTruncateFailureByQuota) {
   base::PlatformFileInfo info;
 
   FilePath dir_path(CreateVirtualTemporaryDir());
   FilePath file_path(CreateVirtualTemporaryFileInDir(dir_path));
 
-  quota_manager()->set_quota(10);
+  quota_manager_proxy()->SetQuota(test_helper_.origin(),
+                                  test_helper_.storage_type(),
+                                  10);
 
   operation()->Truncate(URLForPath(file_path), 10);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
 
   EXPECT_TRUE(file_util::GetFileInfo(PlatformPath(file_path), &info));
   EXPECT_EQ(10, info.size);
 
-  quota_manager()->set_usage(10);
-
   operation()->Truncate(URLForPath(file_path), 11);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, status());
 
   EXPECT_TRUE(file_util::GetFileInfo(PlatformPath(file_path), &info));
   EXPECT_EQ(10, info.size);
 }
 
 }  // namespace fileapi