FileAPI: Compare expected modification time with delta on file read

content/browser/fileapi/local_file_stream_reader_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 "storage/browser/fileapi/local_file_stream_reader.h"
 
 #include <string>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 77 matching lines @@
       const base::FilePath& path,
       int64 initial_offset,
       const base::Time& expected_modification_time) {
     return new LocalFileStreamReader(
             file_task_runner(),
             path,
             initial_offset,
             expected_modification_time);
   }
 
-  void TouchTestFile() {
-    base::Time new_modified_time =
-        test_file_modification_time() - base::TimeDelta::FromSeconds(1);
+  void TouchTestFile(base::TimeDelta delta) {
+    base::Time new_modified_time = test_file_modification_time() + delta;
     ASSERT_TRUE(base::TouchFile(test_path(),
                                 test_file_modification_time(),
                                 new_modified_time));
   }
 
   base::SingleThreadTaskRunner* file_task_runner() const {
     return file_thread_.task_runner().get();
   }
 
   base::FilePath test_dir() const { return dir_.path(); }
@@ skipping 53 matching lines @@
   net::TestInt64CompletionCallback callback;
   int64 result = reader->GetLength(callback.callback());
   if (result == net::ERR_IO_PENDING)
     result = callback.WaitForResult();
   ASSERT_EQ(kTestDataSize, result);
 }
 
 TEST_F(LocalFileStreamReaderTest, GetLengthAfterModified) {
   // Touch file so that the file's modification time becomes different
   // from what we expect.
-  TouchTestFile();
+  TouchTestFile(base::TimeDelta::FromSeconds(-1));
 
   scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 0, test_file_modification_time()));
   net::TestInt64CompletionCallback callback;
   int64 result = reader->GetLength(callback.callback());
   if (result == net::ERR_IO_PENDING)
     result = callback.WaitForResult();
   ASSERT_EQ(net::ERR_UPLOAD_FILE_CHANGED, result);
 
   // With NULL expected modification time this should work.
@@ skipping 20 matching lines @@
       CreateFileReader(test_path(), 0, test_file_modification_time()));
   int result = 0;
   std::string data;
   ReadFromReader(reader.get(), &data, kTestDataSize, &result);
   ASSERT_EQ(net::OK, result);
   ASSERT_EQ(kTestData, data);
 }
 
 TEST_F(LocalFileStreamReaderTest, ReadAfterModified) {
   // Touch file so that the file's modification time becomes different
-  // from what we expect.
-  TouchTestFile();
-
+  // from what we expect. Note that the resolution on some filesystems
+  // is 1s so we can't test with deltas less than that.
+  TouchTestFile(base::TimeDelta::FromSeconds(-1));
   scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 0, test_file_modification_time()));
   int result = 0;
   std::string data;
   ReadFromReader(reader.get(), &data, kTestDataSize, &result);
-  ASSERT_EQ(net::ERR_UPLOAD_FILE_CHANGED, result);
-  ASSERT_EQ(0U, data.size());
+  EXPECT_EQ(net::ERR_UPLOAD_FILE_CHANGED, result);
+  EXPECT_EQ(0U, data.size());
 
-  // With NULL expected modification time this should work.
+  // Due to precision loss converting int64->double->int64 (e.g. through
+  // Blink) the expected/actual time may vary by microseconds. With
+  // modification time delta < 10us this should work.
+  TouchTestFile(base::TimeDelta::FromMicroseconds(1));
+  data.clear();
+  reader.reset(CreateFileReader(test_path(), 0, test_file_modification_time()));
+  ReadFromReader(reader.get(), &data, kTestDataSize, &result);
+  EXPECT_EQ(net::OK, result);
+  EXPECT_EQ(kTestData, data);
+
+  // With matching modification times time this should work.
+  TouchTestFile(base::TimeDelta());
+  data.clear();
+  reader.reset(CreateFileReader(test_path(), 0, test_file_modification_time()));
+  ReadFromReader(reader.get(), &data, kTestDataSize, &result);
+  EXPECT_EQ(net::OK, result);
+  EXPECT_EQ(kTestData, data);
+
+  // And with NULL expected modification time this should work.
   data.clear();
   reader.reset(CreateFileReader(test_path(), 0, base::Time()));
   ReadFromReader(reader.get(), &data, kTestDataSize, &result);
-  ASSERT_EQ(net::OK, result);
-  ASSERT_EQ(kTestData, data);
+  EXPECT_EQ(net::OK, result);
+  EXPECT_EQ(kTestData, data);
 }
 
 TEST_F(LocalFileStreamReaderTest, ReadWithOffset) {
   scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 3, base::Time()));
   int result = 0;
   std::string data;
   ReadFromReader(reader.get(), &data, kTestDataSize, &result);
   ASSERT_EQ(net::OK, result);
   ASSERT_EQ(&kTestData[3], data);
 }
 
 TEST_F(LocalFileStreamReaderTest, DeleteWithUnfinishedRead) {
   scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 0, base::Time()));
 
   net::TestCompletionCallback callback;
   scoped_refptr<net::IOBufferWithSize> buf(
       new net::IOBufferWithSize(kTestDataSize));
   int rv = reader->Read(buf.get(), buf->size(), base::Bind(&NeverCalled));
   ASSERT_TRUE(rv == net::ERR_IO_PENDING || rv >= 0);
 
   // Delete immediately.
   // Should not crash; nor should NeverCalled be callback.
   reader.reset();
   EnsureFileTaskFinished();
 }
 
 }  // namespace content