[Pepper] Wire up append mode writing support of FileIO

ppapi/proxy/file_system_resource_unittest.cc

 // 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 "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"
@@ skipping 220 matching lines @@
 
   // 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, &params, &msg));
   sink().ClearMessages();
 
   int64_t amount = 0;
-  FileOffsetMap max_written_offsets;
+  FileGrowthMap file_growths;
   ASSERT_TRUE(UnpackMessage<PpapiHostMsg_FileSystem_ReserveQuota>(
-      msg, &amount, &max_written_offsets));
+      msg, &amount, &file_growths));
   ASSERT_EQ(kQuotaRequestAmount1, amount);
-  ASSERT_EQ(2U, max_written_offsets.size());
-  ASSERT_EQ(0, max_written_offsets[file_io1.get()]);
-  ASSERT_EQ(0, max_written_offsets[file_io2.get()]);
+  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, &params, &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,
-                  max_written_offsets));
+                  FileGrowthMapToFileSizeMap(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.
@@ skipping 10 matching lines @@
       PpapiHostMsg_FileSystem_ReserveQuota::ID, &params, &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,
-                  max_written_offsets));
+                  FileGrowthMapToFileSizeMap(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.
@@ skipping 10 matching lines @@
       PpapiHostMsg_FileSystem_ReserveQuota::ID, &params, &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,
-                  max_written_offsets));
+                  FileGrowthMapToFileSizeMap(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, &params, &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,
-                  max_written_offsets));
+                  FileGrowthMapToFileSizeMap(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