// Copyright 2014 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 #include "base/message_loop/message_loop.h" #include "ppapi/c/pp_errors.h" #include "ppapi/c/ppb_file_io.h" #include "ppapi/c/ppb_file_ref.h" #include "ppapi/c/ppb_file_system.h" #include "ppapi/proxy/file_system_resource.h" #include "ppapi/proxy/locking_resource_releaser.h" #include "ppapi/proxy/plugin_message_filter.h" #include "ppapi/proxy/ppapi_message_utils.h" #include "ppapi/proxy/ppapi_messages.h" #include "ppapi/proxy/ppapi_proxy_test.h" #include "ppapi/shared_impl/proxy_lock.h" #include "ppapi/shared_impl/scoped_pp_var.h" #include "ppapi/shared_impl/var.h" #include "ppapi/thunk/enter.h" #include "ppapi/thunk/ppb_file_system_api.h" #include "ppapi/thunk/thunk.h" using ppapi::proxy::ResourceMessageTestSink; using ppapi::thunk::EnterResource; using ppapi::thunk::PPB_FileSystem_API; namespace ppapi { namespace proxy { namespace { const int64_t kExpectedFileSystemSize = 100; const int64_t kQuotaRequestAmount1 = 10; const int64_t kQuotaRequestAmount2 = 20; class MockCompletionCallback { public: MockCompletionCallback() : called_(false) {} bool called() { return called_; } int32_t result() { return result_; } static void Callback(void* user_data, int32_t result) { MockCompletionCallback* that = reinterpret_cast(user_data); that->called_ = true; that->result_ = result; } private: bool called_; int32_t result_; }; class MockRequestQuotaCallback { public: MockRequestQuotaCallback() : called_(false) {} bool called() { return called_; } int64_t result() { return result_; } void Reset() { called_ = false; } void Callback(int64_t result) { ASSERT_FALSE(called_); called_ = true; result_ = result; } private: bool called_; int64_t result_; }; class FileSystemResourceTest : public PluginProxyTest { public: const PPB_FileSystem_1_0* file_system_iface; const PPB_FileRef_1_1* file_ref_iface; const PPB_FileIO_1_1* file_io_iface; FileSystemResourceTest() : file_system_iface(thunk::GetPPB_FileSystem_1_0_Thunk()), file_ref_iface(thunk::GetPPB_FileRef_1_1_Thunk()), file_io_iface(thunk::GetPPB_FileIO_1_1_Thunk()) { } void SendReply(const ResourceMessageCallParams& params, int32_t result, const IPC::Message& nested_message) { ResourceMessageReplyParams reply_params(params.pp_resource(), params.sequence()); reply_params.set_result(result); PluginMessageFilter::DispatchResourceReplyForTest( reply_params, nested_message); } void SendOpenReply(const ResourceMessageCallParams& params, int32_t result) { SendReply(params, result, PpapiPluginMsg_FileSystem_OpenReply()); } // Opens the given file system. void OpenFileSystem(PP_Resource file_system) { MockCompletionCallback cb; int32_t result = file_system_iface->Open( file_system, kExpectedFileSystemSize, PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &cb)); ASSERT_EQ(PP_OK_COMPLETIONPENDING, result); // Should have sent two new "open" messages to the browser and renderer. ResourceMessageTestSink::ResourceCallVector open_messages = sink().GetAllResourceCallsMatching(PpapiHostMsg_FileSystem_Open::ID); ASSERT_EQ(2U, open_messages.size()); sink().ClearMessages(); // The resource is expecting two replies. SendOpenReply(open_messages[0].first, PP_OK); SendOpenReply(open_messages[1].first, PP_OK); ASSERT_TRUE(cb.called()); ASSERT_EQ(PP_OK, cb.result()); } // Opens the given file in the given file system. Since there is no host, // the file handle will be invalid. void OpenFile(PP_Resource file_io, PP_Resource file_ref, PP_Resource file_system) { MockCompletionCallback cb; int32_t result = file_io_iface->Open( file_io, file_ref, PP_FILEOPENFLAG_WRITE, PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &cb)); ASSERT_EQ(PP_OK_COMPLETIONPENDING, result); // Should have sent an "open" message. ResourceMessageCallParams params; IPC::Message msg; ASSERT_TRUE(sink().GetFirstResourceCallMatching( PpapiHostMsg_FileIO_Open::ID, ¶ms, &msg)); sink().ClearMessages(); // Send a success reply. ResourceMessageReplyParams reply_params(params.pp_resource(), params.sequence()); reply_params.set_result(PP_OK); PluginMessageFilter::DispatchResourceReplyForTest( reply_params, PpapiPluginMsg_FileIO_OpenReply(file_system, 0 /* max_written_offset */)); } }; } // namespace // Test that Open fails if either host returns failure. The other tests exercise // the case where both hosts return PP_OK. TEST_F(FileSystemResourceTest, OpenFailure) { // Fail if the first reply doesn't return PP_OK. { LockingResourceReleaser file_system( file_system_iface->Create(pp_instance(), PP_FILESYSTEMTYPE_LOCALTEMPORARY)); MockCompletionCallback cb; int32_t result = file_system_iface->Open( file_system.get(), kExpectedFileSystemSize, PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &cb)); ASSERT_EQ(PP_OK_COMPLETIONPENDING, result); ResourceMessageTestSink::ResourceCallVector open_messages = sink().GetAllResourceCallsMatching(PpapiHostMsg_FileSystem_Open::ID); ASSERT_EQ(2U, open_messages.size()); sink().ClearMessages(); SendOpenReply(open_messages[0].first, PP_ERROR_FAILED); SendOpenReply(open_messages[1].first, PP_OK); ASSERT_TRUE(cb.called()); ASSERT_EQ(PP_ERROR_FAILED, cb.result()); } // Fail if the second reply doesn't return PP_OK. { LockingResourceReleaser file_system( file_system_iface->Create(pp_instance(), PP_FILESYSTEMTYPE_LOCALTEMPORARY)); MockCompletionCallback cb; int32_t result = file_system_iface->Open( file_system.get(), kExpectedFileSystemSize, PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &cb)); ASSERT_EQ(PP_OK_COMPLETIONPENDING, result); ResourceMessageTestSink::ResourceCallVector open_messages = sink().GetAllResourceCallsMatching(PpapiHostMsg_FileSystem_Open::ID); ASSERT_EQ(2U, open_messages.size()); sink().ClearMessages(); SendOpenReply(open_messages[0].first, PP_OK); SendOpenReply(open_messages[1].first, PP_ERROR_FAILED); ASSERT_TRUE(cb.called()); ASSERT_EQ(PP_ERROR_FAILED, cb.result()); } } TEST_F(FileSystemResourceTest, RequestQuota) { LockingResourceReleaser file_system( file_system_iface->Create(pp_instance(), PP_FILESYSTEMTYPE_LOCALTEMPORARY)); OpenFileSystem(file_system.get()); // Create and open two files in the file system. FileIOResource calls // FileSystemResource::OpenQuotaFile on success. LockingResourceReleaser file_ref1( file_ref_iface->Create(file_system.get(), "/file1")); LockingResourceReleaser file_io1(file_io_iface->Create(pp_instance())); OpenFile(file_io1.get(), file_ref1.get(), file_system.get()); LockingResourceReleaser file_ref2( file_ref_iface->Create(file_system.get(), "/file2")); LockingResourceReleaser file_io2(file_io_iface->Create(pp_instance())); OpenFile(file_io2.get(), file_ref2.get(), file_system.get()); EnterResource enter(file_system.get(), true); ASSERT_FALSE(enter.failed()); PPB_FileSystem_API* file_system_api = enter.object(); MockRequestQuotaCallback cb1; int64_t result = file_system_api->RequestQuota( kQuotaRequestAmount1, base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1))); ASSERT_EQ(PP_OK_COMPLETIONPENDING, result); // Should have sent a "reserve quota" message, with the amount of the request // and a map of all currently open files to their max written offsets. ResourceMessageCallParams params; IPC::Message msg; ASSERT_TRUE(sink().GetFirstResourceCallMatching( PpapiHostMsg_FileSystem_ReserveQuota::ID, ¶ms, &msg)); sink().ClearMessages(); int64_t amount = 0; FileGrowthMap file_growths; ASSERT_TRUE(UnpackMessage( msg, &amount, &file_growths)); ASSERT_EQ(kQuotaRequestAmount1, amount); ASSERT_EQ(2U, file_growths.size()); ASSERT_EQ(0, file_growths[file_io1.get()].max_written_offset); ASSERT_EQ(0, file_growths[file_io2.get()].max_written_offset); // Make another request while the "reserve quota" message is pending. MockRequestQuotaCallback cb2; result = file_system_api->RequestQuota( kQuotaRequestAmount2, base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb2))); ASSERT_EQ(PP_OK_COMPLETIONPENDING, result); // No new "reserve quota" message should be sent while one is pending. ASSERT_FALSE(sink().GetFirstResourceCallMatching( PpapiHostMsg_FileSystem_ReserveQuota::ID, ¶ms, &msg)); { ProxyAutoUnlock unlock_to_prevent_deadlock; // Reply with quota reservation amount sufficient to cover both requests. // Both callbacks should be called with the requests granted. SendReply(params, PP_OK, PpapiPluginMsg_FileSystem_ReserveQuotaReply( kQuotaRequestAmount1 + kQuotaRequestAmount2, FileGrowthMapToFileSizeMapForTesting(file_growths))); } ASSERT_TRUE(cb1.called()); ASSERT_EQ(kQuotaRequestAmount1, cb1.result()); ASSERT_TRUE(cb2.called()); ASSERT_EQ(kQuotaRequestAmount2, cb2.result()); cb1.Reset(); cb2.Reset(); // All requests should fail when insufficient quota is returned to satisfy // the first request. result = file_system_api->RequestQuota( kQuotaRequestAmount1, base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1))); ASSERT_EQ(PP_OK_COMPLETIONPENDING, result); result = file_system_api->RequestQuota( kQuotaRequestAmount2, base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb2))); ASSERT_EQ(PP_OK_COMPLETIONPENDING, result); ASSERT_TRUE(sink().GetFirstResourceCallMatching( PpapiHostMsg_FileSystem_ReserveQuota::ID, ¶ms, &msg)); sink().ClearMessages(); { ProxyAutoUnlock unlock_to_prevent_deadlock; // Reply with quota reservation amount insufficient to cover the first // request. SendReply(params, PP_OK, PpapiPluginMsg_FileSystem_ReserveQuotaReply( kQuotaRequestAmount1 - 1, FileGrowthMapToFileSizeMapForTesting(file_growths))); } ASSERT_TRUE(cb1.called()); ASSERT_EQ(0, cb1.result()); ASSERT_TRUE(cb2.called()); ASSERT_EQ(0, cb2.result()); cb1.Reset(); cb2.Reset(); // A new request should be made if the quota reservation is enough to satisfy // at least one request. result = file_system_api->RequestQuota( kQuotaRequestAmount1, base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1))); ASSERT_EQ(PP_OK_COMPLETIONPENDING, result); result = file_system_api->RequestQuota( kQuotaRequestAmount2, base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb2))); ASSERT_EQ(PP_OK_COMPLETIONPENDING, result); ASSERT_TRUE(sink().GetFirstResourceCallMatching( PpapiHostMsg_FileSystem_ReserveQuota::ID, ¶ms, &msg)); sink().ClearMessages(); { ProxyAutoUnlock unlock_to_prevent_deadlock; // Reply with quota reservation amount sufficient only to cover the first // request. SendReply(params, PP_OK, PpapiPluginMsg_FileSystem_ReserveQuotaReply( kQuotaRequestAmount1, FileGrowthMapToFileSizeMapForTesting(file_growths))); } ASSERT_TRUE(cb1.called()); ASSERT_EQ(kQuotaRequestAmount1, cb1.result()); ASSERT_FALSE(cb2.called()); // Another request message should have been sent. ASSERT_TRUE(sink().GetFirstResourceCallMatching( PpapiHostMsg_FileSystem_ReserveQuota::ID, ¶ms, &msg)); sink().ClearMessages(); { ProxyAutoUnlock unlock_to_prevent_deadlock; // Reply with quota reservation amount sufficient to cover the second // request and some extra. SendReply(params, PP_OK, PpapiPluginMsg_FileSystem_ReserveQuotaReply( kQuotaRequestAmount1 + kQuotaRequestAmount2, FileGrowthMapToFileSizeMapForTesting(file_growths))); } ASSERT_TRUE(cb2.called()); ASSERT_EQ(kQuotaRequestAmount2, cb2.result()); cb1.Reset(); cb2.Reset(); // There is kQuotaRequestAmount1 of quota left, and a request for it should // succeed immediately. result = file_system_api->RequestQuota( kQuotaRequestAmount1, base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1))); ASSERT_EQ(kQuotaRequestAmount1, result); } } // namespace proxy } // namespace ppapi