Home | History | Annotate | Download | only in proxy 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/message_loop/message_loop.h"
      6 #include "ppapi/c/pp_errors.h"
      7 #include "ppapi/c/ppb_file_io.h"
      8 #include "ppapi/c/ppb_file_ref.h"
      9 #include "ppapi/c/ppb_file_system.h"
     10 #include "ppapi/proxy/file_system_resource.h"
     11 #include "ppapi/proxy/locking_resource_releaser.h"
     12 #include "ppapi/proxy/plugin_message_filter.h"
     13 #include "ppapi/proxy/ppapi_message_utils.h"
     14 #include "ppapi/proxy/ppapi_messages.h"
     15 #include "ppapi/proxy/ppapi_proxy_test.h"
     16 #include "ppapi/shared_impl/proxy_lock.h"
     17 #include "ppapi/shared_impl/scoped_pp_var.h"
     18 #include "ppapi/shared_impl/var.h"
     19 #include "ppapi/thunk/enter.h"
     20 #include "ppapi/thunk/ppb_file_system_api.h"
     21 #include "ppapi/thunk/thunk.h"
     22 
     23 using ppapi::proxy::ResourceMessageTestSink;
     24 using ppapi::thunk::EnterResource;
     25 using ppapi::thunk::PPB_FileSystem_API;
     26 
     27 namespace ppapi {
     28 namespace proxy {
     29 
     30 namespace {
     31 
     32 const int64_t kExpectedFileSystemSize = 100;
     33 const int64_t kQuotaRequestAmount1 = 10;
     34 const int64_t kQuotaRequestAmount2 = 20;
     35 
     36 class MockCompletionCallback {
     37  public:
     38   MockCompletionCallback() : called_(false) {}
     39 
     40   bool called() { return called_; }
     41   int32_t result() { return result_; }
     42 
     43   static void Callback(void* user_data, int32_t result) {
     44     MockCompletionCallback* that =
     45         reinterpret_cast<MockCompletionCallback*>(user_data);
     46     that->called_ = true;
     47     that->result_ = result;
     48   }
     49 
     50  private:
     51   bool called_;
     52   int32_t result_;
     53 };
     54 
     55 class MockRequestQuotaCallback {
     56  public:
     57   MockRequestQuotaCallback() : called_(false) {}
     58 
     59   bool called() { return called_; }
     60   int64_t result() { return result_; }
     61 
     62   void Reset() { called_ = false; }
     63 
     64   void Callback(int64_t result) {
     65     ASSERT_FALSE(called_);
     66     called_ = true;
     67     result_ = result;
     68   }
     69 
     70  private:
     71   bool called_;
     72   int64_t result_;
     73 };
     74 
     75 class FileSystemResourceTest : public PluginProxyTest {
     76  public:
     77   const PPB_FileSystem_1_0* file_system_iface;
     78   const PPB_FileRef_1_1* file_ref_iface;
     79   const PPB_FileIO_1_1* file_io_iface;
     80 
     81   FileSystemResourceTest()
     82       : file_system_iface(thunk::GetPPB_FileSystem_1_0_Thunk()),
     83         file_ref_iface(thunk::GetPPB_FileRef_1_1_Thunk()),
     84         file_io_iface(thunk::GetPPB_FileIO_1_1_Thunk()) {
     85   }
     86 
     87   void SendReply(const ResourceMessageCallParams& params,
     88                  int32_t result,
     89                  const IPC::Message& nested_message) {
     90     ResourceMessageReplyParams reply_params(params.pp_resource(),
     91                                             params.sequence());
     92     reply_params.set_result(result);
     93     PluginMessageFilter::DispatchResourceReplyForTest(
     94         reply_params, nested_message);
     95   }
     96 
     97   void SendOpenReply(const ResourceMessageCallParams& params, int32_t result) {
     98     SendReply(params, result, PpapiPluginMsg_FileSystem_OpenReply());
     99   }
    100 
    101   // Opens the given file system.
    102   void OpenFileSystem(PP_Resource file_system) {
    103     MockCompletionCallback cb;
    104     int32_t result = file_system_iface->Open(
    105         file_system,
    106         kExpectedFileSystemSize,
    107         PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &cb));
    108     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    109 
    110     // Should have sent two new "open" messages to the browser and renderer.
    111     ResourceMessageTestSink::ResourceCallVector open_messages =
    112         sink().GetAllResourceCallsMatching(PpapiHostMsg_FileSystem_Open::ID);
    113     ASSERT_EQ(2U, open_messages.size());
    114     sink().ClearMessages();
    115 
    116     // The resource is expecting two replies.
    117     SendOpenReply(open_messages[0].first, PP_OK);
    118     SendOpenReply(open_messages[1].first, PP_OK);
    119 
    120     ASSERT_TRUE(cb.called());
    121     ASSERT_EQ(PP_OK, cb.result());
    122   }
    123 
    124   // Opens the given file in the given file system. Since there is no host,
    125   // the file handle will be invalid.
    126   void OpenFile(PP_Resource file_io,
    127                 PP_Resource file_ref,
    128                 PP_Resource file_system) {
    129     MockCompletionCallback cb;
    130     int32_t result = file_io_iface->Open(
    131         file_io,
    132         file_ref,
    133         PP_FILEOPENFLAG_WRITE,
    134         PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &cb));
    135     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    136 
    137     // Should have sent an "open" message.
    138     ResourceMessageCallParams params;
    139     IPC::Message msg;
    140     ASSERT_TRUE(sink().GetFirstResourceCallMatching(
    141         PpapiHostMsg_FileIO_Open::ID, &params, &msg));
    142     sink().ClearMessages();
    143 
    144     // Send a success reply.
    145     ResourceMessageReplyParams reply_params(params.pp_resource(),
    146                                             params.sequence());
    147     reply_params.set_result(PP_OK);
    148     PluginMessageFilter::DispatchResourceReplyForTest(
    149         reply_params,
    150         PpapiPluginMsg_FileIO_OpenReply(file_system,
    151                                         0 /* max_written_offset */));
    152   }
    153 };
    154 
    155 }  // namespace
    156 
    157 // Test that Open fails if either host returns failure. The other tests exercise
    158 // the case where both hosts return PP_OK.
    159 TEST_F(FileSystemResourceTest, OpenFailure) {
    160   // Fail if the first reply doesn't return PP_OK.
    161   {
    162     LockingResourceReleaser file_system(
    163         file_system_iface->Create(pp_instance(),
    164                                   PP_FILESYSTEMTYPE_LOCALTEMPORARY));
    165 
    166     MockCompletionCallback cb;
    167     int32_t result = file_system_iface->Open(
    168         file_system.get(),
    169         kExpectedFileSystemSize,
    170         PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &cb));
    171     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    172 
    173     ResourceMessageTestSink::ResourceCallVector open_messages =
    174         sink().GetAllResourceCallsMatching(PpapiHostMsg_FileSystem_Open::ID);
    175     ASSERT_EQ(2U, open_messages.size());
    176     sink().ClearMessages();
    177 
    178     SendOpenReply(open_messages[0].first, PP_ERROR_FAILED);
    179     SendOpenReply(open_messages[1].first, PP_OK);
    180 
    181     ASSERT_TRUE(cb.called());
    182     ASSERT_EQ(PP_ERROR_FAILED, cb.result());
    183   }
    184   // Fail if the second reply doesn't return PP_OK.
    185   {
    186     LockingResourceReleaser file_system(
    187         file_system_iface->Create(pp_instance(),
    188                                   PP_FILESYSTEMTYPE_LOCALTEMPORARY));
    189 
    190     MockCompletionCallback cb;
    191     int32_t result = file_system_iface->Open(
    192         file_system.get(),
    193         kExpectedFileSystemSize,
    194         PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &cb));
    195     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    196 
    197     ResourceMessageTestSink::ResourceCallVector open_messages =
    198         sink().GetAllResourceCallsMatching(PpapiHostMsg_FileSystem_Open::ID);
    199     ASSERT_EQ(2U, open_messages.size());
    200     sink().ClearMessages();
    201 
    202     SendOpenReply(open_messages[0].first, PP_OK);
    203     SendOpenReply(open_messages[1].first, PP_ERROR_FAILED);
    204 
    205     ASSERT_TRUE(cb.called());
    206     ASSERT_EQ(PP_ERROR_FAILED, cb.result());
    207   }
    208 }
    209 
    210 TEST_F(FileSystemResourceTest, RequestQuota) {
    211   LockingResourceReleaser file_system(
    212       file_system_iface->Create(pp_instance(),
    213                                 PP_FILESYSTEMTYPE_LOCALTEMPORARY));
    214 
    215   OpenFileSystem(file_system.get());
    216 
    217   // Create and open two files in the file system. FileIOResource calls
    218   // FileSystemResource::OpenQuotaFile on success.
    219   LockingResourceReleaser file_ref1(
    220       file_ref_iface->Create(file_system.get(), "/file1"));
    221   LockingResourceReleaser file_io1(file_io_iface->Create(pp_instance()));
    222   OpenFile(file_io1.get(), file_ref1.get(), file_system.get());
    223   LockingResourceReleaser file_ref2(
    224       file_ref_iface->Create(file_system.get(), "/file2"));
    225   LockingResourceReleaser file_io2(file_io_iface->Create(pp_instance()));
    226   OpenFile(file_io2.get(), file_ref2.get(), file_system.get());
    227 
    228   EnterResource<PPB_FileSystem_API> enter(file_system.get(), true);
    229   ASSERT_FALSE(enter.failed());
    230   PPB_FileSystem_API* file_system_api = enter.object();
    231 
    232   MockRequestQuotaCallback cb1;
    233   int64_t result = file_system_api->RequestQuota(
    234       kQuotaRequestAmount1,
    235       base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1)));
    236   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    237 
    238   // Should have sent a "reserve quota" message, with the amount of the request
    239   // and a map of all currently open files to their max written offsets.
    240   ResourceMessageCallParams params;
    241   IPC::Message msg;
    242   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
    243       PpapiHostMsg_FileSystem_ReserveQuota::ID, &params, &msg));
    244   sink().ClearMessages();
    245 
    246   int64_t amount = 0;
    247   FileGrowthMap file_growths;
    248   ASSERT_TRUE(UnpackMessage<PpapiHostMsg_FileSystem_ReserveQuota>(
    249       msg, &amount, &file_growths));
    250   ASSERT_EQ(kQuotaRequestAmount1, amount);
    251   ASSERT_EQ(2U, file_growths.size());
    252   ASSERT_EQ(0, file_growths[file_io1.get()].max_written_offset);
    253   ASSERT_EQ(0, file_growths[file_io2.get()].max_written_offset);
    254 
    255   // Make another request while the "reserve quota" message is pending.
    256   MockRequestQuotaCallback cb2;
    257   result = file_system_api->RequestQuota(
    258       kQuotaRequestAmount2,
    259       base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb2)));
    260   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    261   // No new "reserve quota" message should be sent while one is pending.
    262   ASSERT_FALSE(sink().GetFirstResourceCallMatching(
    263       PpapiHostMsg_FileSystem_ReserveQuota::ID, &params, &msg));
    264   {
    265     ProxyAutoUnlock unlock_to_prevent_deadlock;
    266     // Reply with quota reservation amount sufficient to cover both requests.
    267     // Both callbacks should be called with the requests granted.
    268     SendReply(params,
    269               PP_OK,
    270               PpapiPluginMsg_FileSystem_ReserveQuotaReply(
    271                   kQuotaRequestAmount1 + kQuotaRequestAmount2,
    272                   FileGrowthMapToFileSizeMapForTesting(file_growths)));
    273   }
    274   ASSERT_TRUE(cb1.called());
    275   ASSERT_EQ(kQuotaRequestAmount1, cb1.result());
    276   ASSERT_TRUE(cb2.called());
    277   ASSERT_EQ(kQuotaRequestAmount2, cb2.result());
    278   cb1.Reset();
    279   cb2.Reset();
    280 
    281   // All requests should fail when insufficient quota is returned to satisfy
    282   // the first request.
    283   result = file_system_api->RequestQuota(
    284       kQuotaRequestAmount1,
    285       base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1)));
    286   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    287   result = file_system_api->RequestQuota(
    288       kQuotaRequestAmount2,
    289       base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb2)));
    290   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    291 
    292   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
    293       PpapiHostMsg_FileSystem_ReserveQuota::ID, &params, &msg));
    294   sink().ClearMessages();
    295   {
    296     ProxyAutoUnlock unlock_to_prevent_deadlock;
    297     // Reply with quota reservation amount insufficient to cover the first
    298     // request.
    299     SendReply(params,
    300               PP_OK,
    301               PpapiPluginMsg_FileSystem_ReserveQuotaReply(
    302                   kQuotaRequestAmount1 - 1,
    303                   FileGrowthMapToFileSizeMapForTesting(file_growths)));
    304   }
    305   ASSERT_TRUE(cb1.called());
    306   ASSERT_EQ(0, cb1.result());
    307   ASSERT_TRUE(cb2.called());
    308   ASSERT_EQ(0, cb2.result());
    309   cb1.Reset();
    310   cb2.Reset();
    311 
    312   // A new request should be made if the quota reservation is enough to satisfy
    313   // at least one request.
    314   result = file_system_api->RequestQuota(
    315       kQuotaRequestAmount1,
    316       base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1)));
    317   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    318   result = file_system_api->RequestQuota(
    319       kQuotaRequestAmount2,
    320       base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb2)));
    321   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    322 
    323   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
    324       PpapiHostMsg_FileSystem_ReserveQuota::ID, &params, &msg));
    325   sink().ClearMessages();
    326   {
    327     ProxyAutoUnlock unlock_to_prevent_deadlock;
    328     // Reply with quota reservation amount sufficient only to cover the first
    329     // request.
    330     SendReply(params,
    331               PP_OK,
    332               PpapiPluginMsg_FileSystem_ReserveQuotaReply(
    333                   kQuotaRequestAmount1,
    334                   FileGrowthMapToFileSizeMapForTesting(file_growths)));
    335   }
    336   ASSERT_TRUE(cb1.called());
    337   ASSERT_EQ(kQuotaRequestAmount1, cb1.result());
    338   ASSERT_FALSE(cb2.called());
    339 
    340   // Another request message should have been sent.
    341   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
    342       PpapiHostMsg_FileSystem_ReserveQuota::ID, &params, &msg));
    343   sink().ClearMessages();
    344   {
    345     ProxyAutoUnlock unlock_to_prevent_deadlock;
    346     // Reply with quota reservation amount sufficient to cover the second
    347     // request and some extra.
    348     SendReply(params,
    349               PP_OK,
    350               PpapiPluginMsg_FileSystem_ReserveQuotaReply(
    351                   kQuotaRequestAmount1 + kQuotaRequestAmount2,
    352                   FileGrowthMapToFileSizeMapForTesting(file_growths)));
    353   }
    354 
    355   ASSERT_TRUE(cb2.called());
    356   ASSERT_EQ(kQuotaRequestAmount2, cb2.result());
    357   cb1.Reset();
    358   cb2.Reset();
    359 
    360   // There is kQuotaRequestAmount1 of quota left, and a request for it should
    361   // succeed immediately.
    362   result = file_system_api->RequestQuota(
    363       kQuotaRequestAmount1,
    364       base::Bind(&MockRequestQuotaCallback::Callback, base::Unretained(&cb1)));
    365   ASSERT_EQ(kQuotaRequestAmount1, result);
    366 }
    367 
    368 }  // namespace proxy
    369 }  // namespace ppapi
    370