Remove the path from PlatformFileInfo; it's cleaner just to pass it along as a

webkit/fileapi/file_system_operation_unittest.cc

 // Copyright (c) 2011 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/fileapi/file_system_operation.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_temp_dir.h"
 #include "base/message_loop.h"
@@ skipping 25 matching lines @@
       : status_(kFileOperationStatusNotSet) {
     EXPECT_TRUE(base_.CreateUniqueTempDir());
   }
 
   FileSystemOperation* operation();
 
   void set_status(int status) { status_ = status; }
   int status() const { return status_; }
   void set_info(const base::PlatformFileInfo& info) { info_ = info; }
   const base::PlatformFileInfo& info() const { return info_; }
+  void set_path(const FilePath& path) { path_ = path; }
+  const FilePath& path() const { return path_; }
   void set_entries(const std::vector<base::FileUtilProxy::Entry>& entries) {
     entries_ = entries;
   }
   const std::vector<base::FileUtilProxy::Entry>& entries() const {
     return entries_;
   }
 
  protected:
   // Common temp base for nondestructive uses.
   ScopedTempDir base_;
 
   // For post-operation status.
   int status_;
   base::PlatformFileInfo info_;
+  FilePath path_;
   std::vector<base::FileUtilProxy::Entry> entries_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperationTest);
 };
 
 class MockDispatcher : public FileSystemCallbackDispatcher {
  public:
   MockDispatcher(FileSystemOperationTest* test) : test_(test) { }
 
   virtual void DidFail(base::PlatformFileError status) {
     test_->set_status(status);
   }
 
   virtual void DidSucceed() {
     test_->set_status(kFileOperationSucceeded);
   }
 
-  virtual void DidReadMetadata(const base::PlatformFileInfo& info) {
+  virtual void DidReadMetadata(
+      const base::PlatformFileInfo& info,
+      const FilePath& platform_path) {
     test_->set_info(info);
+    test_->set_path(platform_path);
     test_->set_status(kFileOperationSucceeded);
   }
 
   virtual void DidReadDirectory(
       const std::vector<base::FileUtilProxy::Entry>& entries,
       bool /* has_more */) {
     test_->set_entries(entries);
   }
 
   virtual void DidOpenFileSystem(const std::string&, const FilePath&) {
@@ skipping 468 matching lines @@
   ASSERT_TRUE(dir.CreateUniqueTempDir());
 
   operation()->DirectoryExists(dir.path());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kFileOperationSucceeded, status());
 
   operation()->GetMetadata(dir.path());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kFileOperationSucceeded, status());
   EXPECT_TRUE(info().is_directory);
+  EXPECT_EQ(dir.path(), path());
 
   FilePath file;
   file_util::CreateTemporaryFileInDir(dir.path(), &file);
   operation()->FileExists(file);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kFileOperationSucceeded, status());
 
   operation()->GetMetadata(file);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kFileOperationSucceeded, status());
   EXPECT_FALSE(info().is_directory);
+  EXPECT_EQ(file, path());
 }
 
 TEST_F(FileSystemOperationTest, TestTypeMismatchErrors) {
   ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   operation()->FileExists(dir.path());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_FILE, status());
 
   FilePath file;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(dir.path(), &file));
   operation()->DirectoryExists(file);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY, status());
 }
 
 TEST_F(FileSystemOperationTest, TestReadDirFailure) {
-  // Path doesn't exists
-    FilePath nonexisting_dir_path(base_.path().Append(
-        FILE_PATH_LITERAL("NonExistingDir")));
+  // Path doesn't exist
+  FilePath nonexisting_dir_path(base_.path().Append(
+      FILE_PATH_LITERAL("NonExistingDir")));
   file_util::EnsureEndsWithSeparator(&nonexisting_dir_path);
   operation()->ReadDirectory(nonexisting_dir_path);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 
   // File exists.
   ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   FilePath file;
   file_util::CreateTemporaryFileInDir(dir.path(), &file);
@@ skipping 140 matching lines @@
 
   // Check that its length is now 3 and that it contains only bits of test data.
   EXPECT_TRUE(file_util::GetFileInfo(file, &info));
   EXPECT_EQ(length, info.size);
   EXPECT_EQ(length, file_util::ReadFile(file, data, length));
   for (int i = 0; i < length; ++i)
     EXPECT_EQ(test_data[i], data[i]);
 }
 
 }  // namespace fileapi