Index: webkit/plugins/ppapi/quota_file_io_unittest.cc |
=================================================================== |
--- webkit/plugins/ppapi/quota_file_io_unittest.cc (revision 213561) |
+++ webkit/plugins/ppapi/quota_file_io_unittest.cc (working copy) |
@@ -1,500 +0,0 @@ |
-// 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 <deque> |
-#include <limits> |
-#include <string> |
- |
-#include "base/basictypes.h" |
-#include "base/bind.h" |
-#include "base/file_util.h" |
-#include "base/files/scoped_temp_dir.h" |
-#include "base/memory/weak_ptr.h" |
-#include "base/message_loop/message_loop.h" |
-#include "base/platform_file.h" |
-#include "webkit/plugins/ppapi/mock_plugin_delegate.h" |
-#include "webkit/plugins/ppapi/ppapi_plugin_instance_impl.h" |
-#include "webkit/plugins/ppapi/ppapi_unittest.h" |
-#include "webkit/plugins/ppapi/quota_file_io.h" |
- |
-using base::MessageLoopProxy; |
-using base::PlatformFile; |
-using base::PlatformFileError; |
- |
-namespace webkit { |
-namespace ppapi { |
- |
-namespace { |
-class QuotaMockPluginDelegate : public MockPluginDelegate { |
- public: |
- typedef PluginDelegate::AvailableSpaceCallback Callback; |
- |
- QuotaMockPluginDelegate() |
- : available_space_(0), |
- will_update_count_(0), |
- file_thread_(MessageLoopProxy::current()), |
- weak_factory_(this) { |
- } |
- virtual ~QuotaMockPluginDelegate() {} |
- |
- virtual scoped_refptr<MessageLoopProxy> GetFileThreadMessageLoopProxy() { |
- return file_thread_; |
- } |
- |
- virtual void QueryAvailableSpace( |
- const GURL& origin, |
- quota::StorageType type, |
- const Callback& callback) OVERRIDE { |
- DCHECK_EQ(false, callback.is_null()); |
- MessageLoopProxy::current()->PostTask( |
- FROM_HERE, base::Bind( |
- &QuotaMockPluginDelegate::RunAvailableSpaceCallback, |
- weak_factory_.GetWeakPtr(), callback)); |
- } |
- |
- virtual void WillUpdateFile(const GURL& file_path) OVERRIDE { |
- file_path_ = file_path; |
- ++will_update_count_; |
- } |
- |
- virtual void DidUpdateFile(const GURL& file_path, int64_t delta) OVERRIDE { |
- ASSERT_EQ(file_path_, file_path); |
- ASSERT_GT(will_update_count_, 0); |
- --will_update_count_; |
- available_space_ -= delta; |
- } |
- |
- void set_available_space(int64 available) { available_space_ = available; } |
- int64_t available_space() const { return available_space_; } |
- |
- private: |
- void RunAvailableSpaceCallback(const Callback& callback) { |
- callback.Run(available_space_); |
- } |
- |
- int64_t available_space_; |
- int will_update_count_; |
- GURL file_path_; |
- scoped_refptr<MessageLoopProxy> file_thread_; |
- base::WeakPtrFactory<QuotaMockPluginDelegate> weak_factory_; |
-}; |
-} // namespace |
- |
-class QuotaFileIOTest : public PpapiUnittest { |
- public: |
- QuotaFileIOTest() |
- : weak_factory_(this) {} |
- |
- virtual void SetUp() OVERRIDE { |
- PpapiUnittest::SetUp(); |
- ASSERT_TRUE(dir_.CreateUniqueTempDir()); |
- base::FilePath path; |
- ASSERT_TRUE(file_util::CreateTemporaryFileInDir(dir_.path(), &path)); |
- int file_flags = base::PLATFORM_FILE_OPEN | |
- base::PLATFORM_FILE_READ | |
- base::PLATFORM_FILE_WRITE | |
- base::PLATFORM_FILE_WRITE_ATTRIBUTES; |
- bool created = false; |
- file_ = base::kInvalidPlatformFileValue; |
- PlatformFileError error = base::PLATFORM_FILE_OK; |
- file_ = base::CreatePlatformFile(path, file_flags, &created, &error); |
- ASSERT_EQ(base::PLATFORM_FILE_OK, error); |
- ASSERT_NE(base::kInvalidPlatformFileValue, file_); |
- ASSERT_FALSE(created); |
- quota_file_io_.reset(new QuotaFileIO( |
- instance()->pp_instance(), file_, GURL(), |
- PP_FILESYSTEMTYPE_LOCALTEMPORARY)); |
- } |
- |
- virtual void TearDown() OVERRIDE { |
- quota_file_io_.reset(); |
- if (file_ != base::kInvalidPlatformFileValue) |
- base::ClosePlatformFile(file_); |
- PpapiUnittest::TearDown(); |
- } |
- |
- protected: |
- virtual MockPluginDelegate* NewPluginDelegate() OVERRIDE { |
- return static_cast<MockPluginDelegate*>(new QuotaMockPluginDelegate); |
- } |
- |
- void WriteTestBody(bool will_operation) { |
- // Attempt to write zero bytes. |
- EXPECT_FALSE(quota_file_io_->Write( |
- 0, "data", 0, |
- base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr()))); |
- // Attempt to write negative number of bytes. |
- EXPECT_FALSE(quota_file_io_->Write( |
- 0, "data", std::numeric_limits<int32_t>::min(), |
- base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr()))); |
- |
- quota_plugin_delegate()->set_available_space(100); |
- std::string read_buffer; |
- |
- // Write 8 bytes at offset 0 (-> length=8). |
- std::string data("12345678"); |
- Write(0, data, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(static_cast<int>(data.size()), bytes_written().front()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(100 - 8, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- if (will_operation) { |
- // WillWrite doesn't actually write. |
- EXPECT_EQ(0, GetPlatformFileSize()); |
- // Adjust the actual file size to 'fake' write to proceed testing. |
- SetPlatformFileSize(8); |
- } else { |
- EXPECT_EQ(8, GetPlatformFileSize()); |
- ReadPlatformFile(&read_buffer); |
- EXPECT_EQ(data, read_buffer); |
- } |
- |
- // Write 5 bytes at offset 5 (-> length=10). |
- data = "55555"; |
- Write(5, data, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(static_cast<int>(data.size()), bytes_written().front()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(100 - 10, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- if (will_operation) { |
- EXPECT_EQ(8, GetPlatformFileSize()); |
- SetPlatformFileSize(10); |
- } else { |
- EXPECT_EQ(10, GetPlatformFileSize()); |
- ReadPlatformFile(&read_buffer); |
- EXPECT_EQ("1234555555", read_buffer); |
- } |
- |
- // Write 7 bytes at offset 8 (-> length=15). |
- data = "9012345"; |
- Write(8, data, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(static_cast<int>(data.size()), bytes_written().front()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(100 - 15, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- if (will_operation) { |
- EXPECT_EQ(10, GetPlatformFileSize()); |
- SetPlatformFileSize(15); |
- } else { |
- EXPECT_EQ(15, GetPlatformFileSize()); |
- ReadPlatformFile(&read_buffer); |
- EXPECT_EQ("123455559012345", read_buffer); |
- } |
- |
- // Write 2 bytes at offset 2 (-> length=15). |
- data = "33"; |
- Write(2, data, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(static_cast<int>(data.size()), bytes_written().front()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(100 - 15, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- if (will_operation) { |
- EXPECT_EQ(15, GetPlatformFileSize()); |
- } else { |
- EXPECT_EQ(15, GetPlatformFileSize()); |
- ReadPlatformFile(&read_buffer); |
- EXPECT_EQ("123355559012345", read_buffer); |
- } |
- |
- // Write 4 bytes at offset 20 (-> length=24). |
- data = "XXXX"; |
- Write(20, data, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(static_cast<int>(data.size()), bytes_written().front()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(100 - 24, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- if (will_operation) { |
- EXPECT_EQ(15, GetPlatformFileSize()); |
- SetPlatformFileSize(24); |
- } else { |
- EXPECT_EQ(24, GetPlatformFileSize()); |
- ReadPlatformFile(&read_buffer); |
- EXPECT_EQ(std::string("123355559012345\0\0\0\0\0XXXX", 24), read_buffer); |
- } |
- |
- quota_plugin_delegate()->set_available_space(5); |
- |
- // Quota error case. Write 7 bytes at offset 23 (-> length is unchanged) |
- data = "ABCDEFG"; |
- Write(23, data, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, status().front()); |
- EXPECT_EQ(5, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- // Overlapping write. Write 6 bytes at offset 2 (-> length is unchanged) |
- data = "ABCDEF"; |
- Write(2, data, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(static_cast<int>(data.size()), bytes_written().front()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(5, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- // Overlapping + extending the file size, but within the quota. |
- // Write 6 bytes at offset 23 (-> length=29). |
- Write(23, data, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(static_cast<int>(data.size()), bytes_written().front()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(0, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- if (!will_operation) { |
- EXPECT_EQ(29, GetPlatformFileSize()); |
- ReadPlatformFile(&read_buffer); |
- EXPECT_EQ(std::string("12ABCDEF9012345\0\0\0\0\0XXXABCDEF", 29), |
- read_buffer); |
- } |
- } |
- |
- void SetLengthTestBody(bool will_operation) { |
- quota_plugin_delegate()->set_available_space(100); |
- |
- SetLength(0, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(0, GetPlatformFileSize()); |
- EXPECT_EQ(100, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- SetLength(8, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(100 - 8, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- if (will_operation) { |
- EXPECT_EQ(0, GetPlatformFileSize()); |
- SetPlatformFileSize(8); |
- } else { |
- EXPECT_EQ(8, GetPlatformFileSize()); |
- } |
- |
- SetLength(16, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(100 - 16, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- if (will_operation) { |
- EXPECT_EQ(8, GetPlatformFileSize()); |
- SetPlatformFileSize(16); |
- } else { |
- EXPECT_EQ(16, GetPlatformFileSize()); |
- } |
- |
- SetLength(4, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(100 - 4, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- if (will_operation) { |
- EXPECT_EQ(16, GetPlatformFileSize()); |
- SetPlatformFileSize(4); |
- } else { |
- EXPECT_EQ(4, GetPlatformFileSize()); |
- } |
- |
- SetLength(0, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- EXPECT_EQ(100, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- |
- if (will_operation) { |
- EXPECT_EQ(4, GetPlatformFileSize()); |
- SetPlatformFileSize(0); |
- } else { |
- EXPECT_EQ(0, GetPlatformFileSize()); |
- } |
- |
- quota_plugin_delegate()->set_available_space(5); |
- |
- // Quota error case. |
- SetLength(7, will_operation); |
- base::MessageLoop::current()->RunUntilIdle(); |
- ASSERT_EQ(1U, num_results()); |
- EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, status().front()); |
- EXPECT_EQ(5, quota_plugin_delegate()->available_space()); |
- reset_results(); |
- } |
- |
- QuotaMockPluginDelegate* quota_plugin_delegate() { |
- return static_cast<QuotaMockPluginDelegate*>(delegate()); |
- } |
- |
- void Write(int64_t offset, const std::string& data, bool will_operation) { |
- if (will_operation) { |
- ASSERT_TRUE(quota_file_io_->WillWrite( |
- offset, data.size(), |
- base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr()))); |
- } else { |
- ASSERT_TRUE(quota_file_io_->Write( |
- offset, data.c_str(), data.size(), |
- base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr()))); |
- } |
- } |
- |
- void SetLength(int64_t length, bool will_operation) { |
- if (will_operation) { |
- ASSERT_TRUE(quota_file_io_->WillSetLength( |
- length, |
- base::Bind(&QuotaFileIOTest::DidSetLength, |
- weak_factory_.GetWeakPtr()))); |
- } else { |
- ASSERT_TRUE(quota_file_io_->SetLength( |
- length, |
- base::Bind(&QuotaFileIOTest::DidSetLength, |
- weak_factory_.GetWeakPtr()))); |
- } |
- } |
- |
- void DidWrite(PlatformFileError status, int bytes_written) { |
- status_.push_back(status); |
- bytes_written_.push_back(bytes_written); |
- } |
- |
- void DidSetLength(PlatformFileError status) { |
- status_.push_back(status); |
- } |
- |
- size_t num_results() const { return status_.size(); } |
- const std::deque<int>& bytes_written() const { return bytes_written_; } |
- const std::deque<PlatformFileError>& status() const { return status_; } |
- |
- void reset_results() { |
- bytes_written_.clear(); |
- status_.clear(); |
- } |
- |
- void pop_result() { |
- bytes_written_.pop_front(); |
- status_.pop_front(); |
- } |
- |
- void ReadPlatformFile(std::string* data) { |
- data->clear(); |
- char buf[256]; |
- int32_t read_offset = 0; |
- for (;;) { |
- int rv = base::ReadPlatformFile(file_, read_offset, buf, sizeof(buf)); |
- ASSERT_GE(rv, 0); |
- if (rv == 0) |
- break; |
- read_offset += rv; |
- data->append(buf, rv); |
- } |
- } |
- |
- int64_t GetPlatformFileSize() { |
- base::PlatformFileInfo info; |
- EXPECT_TRUE(base::GetPlatformFileInfo(file_, &info)); |
- return info.size; |
- } |
- |
- void SetPlatformFileSize(int64_t length) { |
- EXPECT_TRUE(base::TruncatePlatformFile(file_, length)); |
- } |
- |
- private: |
- base::ScopedTempDir dir_; |
- PlatformFile file_; |
- scoped_ptr<QuotaFileIO> quota_file_io_; |
- std::deque<int> bytes_written_; |
- std::deque<PlatformFileError> status_; |
- base::WeakPtrFactory<QuotaFileIOTest> weak_factory_; |
-}; |
- |
-TEST_F(QuotaFileIOTest, Write) { |
- WriteTestBody(false); |
-} |
- |
-TEST_F(QuotaFileIOTest, WillWrite) { |
- WriteTestBody(true); |
-} |
- |
-TEST_F(QuotaFileIOTest, SetLength) { |
- SetLengthTestBody(false); |
-} |
- |
-TEST_F(QuotaFileIOTest, WillSetLength) { |
- SetLengthTestBody(true); |
-} |
- |
-TEST_F(QuotaFileIOTest, ParallelWrites) { |
- quota_plugin_delegate()->set_available_space(22); |
- std::string read_buffer; |
- |
- const std::string data1[] = { |
- std::string("12345678"), |
- std::string("55555"), |
- std::string("9012345"), |
- }; |
- Write(0, data1[0], false); |
- Write(5, data1[1], false); |
- Write(8, data1[2], false); |
- base::MessageLoop::current()->RunUntilIdle(); |
- |
- ASSERT_EQ(ARRAYSIZE_UNSAFE(data1), num_results()); |
- for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data1); ++i) { |
- EXPECT_EQ(static_cast<int>(data1[i].size()), bytes_written().front()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- pop_result(); |
- } |
- |
- EXPECT_EQ(22 - 15, quota_plugin_delegate()->available_space()); |
- EXPECT_EQ(15, GetPlatformFileSize()); |
- ReadPlatformFile(&read_buffer); |
- EXPECT_EQ("123455559012345", read_buffer); |
- |
- // The second write will fail for quota error. |
- const std::string data2[] = { |
- std::string("33"), |
- std::string("XXXX"), |
- }; |
- Write(2, data2[0], false); |
- Write(20, data2[1], false); |
- base::MessageLoop::current()->RunUntilIdle(); |
- |
- ASSERT_EQ(ARRAYSIZE_UNSAFE(data2), num_results()); |
- EXPECT_EQ(static_cast<int>(data2[0].size()), bytes_written().front()); |
- EXPECT_EQ(base::PLATFORM_FILE_OK, status().front()); |
- pop_result(); |
- EXPECT_EQ(0, bytes_written().front()); |
- EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, status().front()); |
- pop_result(); |
- |
- EXPECT_EQ(22 - 15, quota_plugin_delegate()->available_space()); |
- EXPECT_EQ(15, GetPlatformFileSize()); |
- ReadPlatformFile(&read_buffer); |
- EXPECT_EQ("123355559012345", read_buffer); |
-} |
- |
-} // namespace ppapi |
-} // namespace webkit |