[Pepper][FileAPI] Interface clean up (3/6)

webkit/browser/fileapi/quota/quota_reservation_manager_unittest.cc

 // Copyright 2013 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/browser/fileapi/quota/quota_reservation_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 161 matching lines @@
     // For each open file for write, the client should create OpenFileHandle
     // object.
     // It's OK to create multiple OpenFileHandle for single file.
     scoped_ptr<OpenFileHandle> open_file =
         reservation->GetOpenFileHandle(file_path());
 
     // Before reserved quota ran out, the client can perform any number of
     // operation for the file.
     // The client should calculate how much quota is consumed by itself.
     int64 remaining_quota = reservation->remaining_quota();
-    int64 base_file_size = open_file->base_file_size();
+    int64 base_file_size = open_file->GetEstimatedFileSize();
     int64 max_written_offset = base_file_size;
     ExtendFileTo(90);
     max_written_offset = 90;
     remaining_quota -= max_written_offset - base_file_size;
 
     // When the reserved quota ran out, the client can request quota refresh
     // through Reservation.  Before requesting another portion of quota, the
     // client should report maximum written offset for each modified files.
     open_file->UpdateMaxWrittenOffset(max_written_offset);
     EXPECT_EQ(remaining_quota, reservation->remaining_quota());
@@ skipping 25 matching lines @@
   EXPECT_EQ(100, reservation->remaining_quota());
 
   {
     scoped_ptr<OpenFileHandle> open_file1 =
         reservation->GetOpenFileHandle(file_path());
     scoped_ptr<OpenFileHandle> open_file2 =
         reservation->GetOpenFileHandle(file_path());
 
     int64 remaining_quota = reservation->remaining_quota();
 
-    int64 base_file_size_for_file1 = open_file1->base_file_size();
+    int64 base_file_size_for_file1 = open_file1->GetEstimatedFileSize();
     int64 max_written_offset_for_file1 = base_file_size_for_file1;
 
-    int64 base_file_size_for_file2 = open_file2->base_file_size();
+    int64 base_file_size_for_file2 = open_file2->GetEstimatedFileSize();
     int64 max_written_offset_for_file2 = base_file_size_for_file2;
 
     // Each writer should maintain max_written_offset and base_file_size
     // independently even if there are multiple writers for the same file.
     max_written_offset_for_file1 = 50;
     ExtendFileTo(max_written_offset_for_file1);
     remaining_quota -= max_written_offset_for_file1 - base_file_size_for_file1;
     base_file_size_for_file1 = max_written_offset_for_file1;
 
     max_written_offset_for_file2 = 90;
     ExtendFileTo(max_written_offset_for_file2);
     remaining_quota -= max_written_offset_for_file2 - base_file_size_for_file2;
     base_file_size_for_file2 = max_written_offset_for_file2;
 
     // Before requesting quota refresh, each writer should report their
     // maximum_written_offset.  UpdateMaxWrittenOffset returns updated
     // base_file_size that the writer should calculate quota consumption based
     // on that.
-    base_file_size_for_file1 =
-        open_file1->UpdateMaxWrittenOffset(max_written_offset_for_file1);
+    open_file1->UpdateMaxWrittenOffset(max_written_offset_for_file1);
+    base_file_size_for_file1 = open_file1->GetEstimatedFileSize();
     max_written_offset_for_file1 = base_file_size_for_file1;
     EXPECT_EQ(100 - (50 - kInitialFileSize), reservation->remaining_quota());
 
-    base_file_size_for_file2 =
-        open_file2->UpdateMaxWrittenOffset(max_written_offset_for_file2);
+    open_file2->UpdateMaxWrittenOffset(max_written_offset_for_file2);
+    base_file_size_for_file2 = open_file2->GetEstimatedFileSize();
     max_written_offset_for_file2 = base_file_size_for_file2;
     EXPECT_EQ(100 - (50 - kInitialFileSize) - (90 - 50),
               reservation->remaining_quota());
 
     RefreshQuota(reservation, 100);
     EXPECT_EQ(100, reservation->remaining_quota());
   }
 
   EXPECT_EQ(90, GetFileSize());
   EXPECT_EQ(100, fake_backend()->on_memory_usage());
@@ skipping 23 matching lines @@
   EXPECT_EQ(500, reservation2->remaining_quota());
 
   // Attach a file to both of two reservations.
   scoped_ptr<OpenFileHandle> open_file1 =
       reservation1->GetOpenFileHandle(file_path());
   scoped_ptr<OpenFileHandle> open_file2 =
       reservation2->GetOpenFileHandle(file_path());
 
   // Each client should manage reserved quota and its consumption separately.
   int64 remaining_quota1 = reservation1->remaining_quota();
-  int64 base_file_size1 = open_file1->base_file_size();
+  int64 base_file_size1 = open_file1->GetEstimatedFileSize();
   int64 max_written_offset1 = base_file_size1;
 
   int64 remaining_quota2 = reservation2->remaining_quota();
-  int64 base_file_size2 = open_file2->base_file_size();
+  int64 base_file_size2 = open_file2->GetEstimatedFileSize();
   int64 max_written_offset2 = base_file_size2;
 
   max_written_offset1 = 50;
   remaining_quota1 -= max_written_offset1 - base_file_size1;
   base_file_size1 = max_written_offset1;
   ExtendFileTo(max_written_offset1);
 
   max_written_offset2 = 400;
   remaining_quota2 -= max_written_offset2 - base_file_size2;
   base_file_size2 = max_written_offset2;
   ExtendFileTo(max_written_offset2);
 
   // For multiple Reservation case, RefreshQuota needs usage report only from
   // associated OpenFile's.
-  base_file_size1 =
-      open_file1->UpdateMaxWrittenOffset(max_written_offset1);
+  open_file1->UpdateMaxWrittenOffset(max_written_offset1);
+  base_file_size1 = open_file1->GetEstimatedFileSize();
   max_written_offset1 = base_file_size1;
   EXPECT_EQ(100 - (50 - kInitialFileSize), reservation1->remaining_quota());
 
   RefreshQuota(reservation1, 200);
   EXPECT_EQ(200, reservation1->remaining_quota());
 
-  base_file_size2 =
-      open_file2->UpdateMaxWrittenOffset(max_written_offset2);
+  open_file2->UpdateMaxWrittenOffset(max_written_offset2);
+  base_file_size2 = open_file2->GetEstimatedFileSize();
   max_written_offset2 = base_file_size2;
   EXPECT_EQ(500 - (400 - 50), reservation2->remaining_quota());
 
   RefreshQuota(reservation2, 150);
   EXPECT_EQ(150, reservation2->remaining_quota());
 
   open_file1.reset();
   open_file2.reset();
 
   EXPECT_EQ(400, GetFileSize());
@@ skipping 10 matching lines @@
 
   EXPECT_EQ(400, GetFileSize());
   EXPECT_EQ(0, fake_backend()->on_memory_usage());
   EXPECT_EQ(400 - kInitialFileSize, fake_backend()->on_disk_usage());
 }
 
 // TODO(tzik): Add Truncate test.
 // TODO(tzik): Add PluginCrash test and DropReservationManager test.
 
 }  // namespace fileapi