[Pepper] Use platform path for QuotaReservation::GetOpenFileHandle

content/browser/renderer_host/pepper/quota_reservation_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 "content/browser/renderer_host/pepper/quota_reservation.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 64 matching lines @@
     ASSERT_TRUE(work_dir_.CreateUniqueTempDir());
 
     reservation_manager_.reset(new QuotaReservationManager(
         scoped_ptr<QuotaReservationManager::QuotaBackend>(new FakeBackend)));
   }
 
   virtual void TearDown() OVERRIDE {
     reservation_manager_.reset();
   }
 
-  base::FilePath MakeFilePath(base::FilePath::StringType file_name) {
+  base::FilePath MakeFilePath(const base::FilePath::StringType& file_name) {

[bbudge, 2014/01/09 13:23:50]

Thanks for fixing it, but I think it can be removed, as it's not called anymore.

[tzik, 2014/01/10 05:34:08]

That is used in SetFileSize(), and now used in MakeFileSystemURL.

     return work_dir_.path().Append(file_name);
   }
 
+  fileapi::FileSystemURL MakeFileSystemURL(
+      const base::FilePath::StringType& file_name) {
+    return fileapi::FileSystemURL::CreateForTest(
+        GURL(kOrigin), kType, work_dir_.path().Append(file_name));
+  }
+
   scoped_refptr<QuotaReservation> CreateQuotaReservation(
       scoped_refptr<fileapi::QuotaReservation> reservation,
       const GURL& origin,
       FileSystemType type) {
     // Sets reservation_ as a side effect.
     return scoped_refptr<QuotaReservation>(
         new QuotaReservation(reservation, origin, type));
   }
 
   void SetFileSize(const base::FilePath::StringType& file_name, int64 size) {
@@ skipping 58 matching lines @@
   int64 amount = 100;
   int64 reserved_quota;
   QuotaReservation::OffsetMap max_written_offsets;
   ReserveQuota(test, amount, &reserved_quota, &max_written_offsets);
   EXPECT_EQ(amount, reserved_quota);
   EXPECT_EQ(0U, max_written_offsets.size());
 
   // Open a file, refresh the reservation, extend the file, and close it.
   int64 file_size = 10;
   SetFileSize(file1_name, file_size);
-  int64 open_file_size = test->OpenFile(kFile1ID, MakeFilePath(file1_name));
+  int64 open_file_size = test->OpenFile(kFile1ID,
+                                        MakeFileSystemURL(file1_name));
   EXPECT_EQ(file_size, open_file_size);
 
   max_written_offsets[kFile1ID] = file_size;  // 1 file open.
   ReserveQuota(test, amount, &reserved_quota, &max_written_offsets);
   EXPECT_EQ(amount, reserved_quota);
   EXPECT_EQ(1U, max_written_offsets.size());
   EXPECT_EQ(file_size, max_written_offsets[kFile1ID]);
 
   int64 new_file_size = 30;
   SetFileSize(file1_name, new_file_size);
@@ skipping 11 matching lines @@
   FileSystemType type = kType;
 
   scoped_refptr<fileapi::QuotaReservation> reservation(
      reservation_manager()->CreateReservation(origin, type));
   scoped_refptr<QuotaReservation> test =
       CreateQuotaReservation(reservation, origin, type);
 
   // Open some files of different sizes.
   int64 file1_size = 10;
   SetFileSize(file1_name, file1_size);
-  int64 open_file1_size = test->OpenFile(kFile1ID, MakeFilePath(file1_name));
+  int64 open_file1_size = test->OpenFile(kFile1ID,
+                                         MakeFileSystemURL(file1_name));
   EXPECT_EQ(file1_size, open_file1_size);
   int64 file2_size = 20;
   SetFileSize(file2_name, file2_size);
-  int64 open_file2_size = test->OpenFile(kFile2ID, MakeFilePath(file2_name));
+  int64 open_file2_size = test->OpenFile(kFile2ID,
+                                         MakeFileSystemURL(file2_name));
   EXPECT_EQ(file2_size, open_file2_size);
   int64 file3_size = 30;
   SetFileSize(file3_name, file3_size);
-  int64 open_file3_size = test->OpenFile(kFile3ID, MakeFilePath(file3_name));
+  int64 open_file3_size = test->OpenFile(kFile3ID,
+                                         MakeFileSystemURL(file3_name));
   EXPECT_EQ(file3_size, open_file3_size);
 
   // Reserve quota.
   int64 amount = 100;
   int64 reserved_quota;
   QuotaReservation::OffsetMap max_written_offsets;
   max_written_offsets[kFile1ID] = file1_size;  // 3 files open.
   max_written_offsets[kFile2ID] = file2_size;
   max_written_offsets[kFile3ID] = file3_size;
 
@@ skipping 11 matching lines @@
   EXPECT_EQ(amount, reserved_quota);
   EXPECT_EQ(2U, max_written_offsets.size());
   EXPECT_EQ(file1_size, max_written_offsets[kFile1ID]);
   EXPECT_EQ(file3_size, max_written_offsets[kFile3ID]);
 
   test->CloseFile(kFile1ID, file1_size);
   test->CloseFile(kFile3ID, file3_size);
 }
 
 }  // namespace content