Add test for failing rename in BaseFileTest.

content/browser/download/base_file_unittest.cc

 // Copyright (c) 2012 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/download/base_file.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 447 matching lines @@
   EXPECT_TRUE(base_file_->in_progress());
   EXPECT_EQ(net::OK, base_file_->Rename(new_path));
   EXPECT_FALSE(file_util::PathExists(initial_path));
   EXPECT_TRUE(file_util::PathExists(new_path));
 
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData2));
 
   base_file_->Finish();
 }
 
+// Test that a failed rename reports the correct error.
+TEST_F(BaseFileTest, RenameWithError) {
+  ASSERT_EQ(net::OK, base_file_->Initialize());
+
+  // TestDir is a subdirectory in |temp_dir_| that we will make read-only so
+  // that the rename will fail.
+  FilePath test_dir(temp_dir_.path().AppendASCII("TestDir"));
+  ASSERT_TRUE(file_util::CreateDirectory(test_dir));
+
+  FilePath new_path(test_dir.AppendASCII("TestFile"));
+  EXPECT_FALSE(file_util::PathExists(new_path));
+
+  {
+    file_util::PermissionRestorer restore_permissions_for(test_dir);
+    ASSERT_TRUE(file_util::MakeFileUnwritable(test_dir));
+    EXPECT_EQ(net::ERR_ACCESS_DENIED, base_file_->Rename(new_path));

[Randy Smith (Not in Mondays), 2012/07/11 17:13:17]

I'm concerned about this test, for the reasons you mentioned to me.  More
abstractly, on posix, I consider rename to be a directory operation, not a file
operation; i.e. it would be reasonable to implement it by *not* closing and
reopening the file, but instead by just doing the rename at the directory level.
 In that case, I think this test would fail. 

Maybe import the test I just added to download_file in
http://codereview.chromium.org/10689093/?

+  }
+
+  base_file_->Finish();
+}
+
 // Write data to the file multiple times.
 TEST_F(BaseFileTest, MultipleWritesWithError) {
   ASSERT_TRUE(OpenMockFileStream());
   base_file_.reset(new BaseFile(mock_file_stream_->get_path(),
                                 GURL(),
                                 GURL(),
                                 0,
                                 false,
                                 "",
                                 mock_file_stream_,
@@ skipping 55 matching lines @@
   base_file_->Finish();
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 // Create a read-only file and attempt to write to it.
 TEST_F(BaseFileTest, ReadonlyBaseFile) {
   // Create a new file.
   FilePath readonly_file_name = CreateTestFile();
 
+  // Restore permissions to the file when we are done with this test.
+  file_util::PermissionRestorer restore_permissions(readonly_file_name);
+
   // Make it read-only.
   EXPECT_TRUE(file_util::MakeFileUnwritable(readonly_file_name));
 
   // Try to overwrite it.
   base_file_.reset(new BaseFile(readonly_file_name,
                                 GURL(),
                                 GURL(),
                                 0,
                                 false,
                                 "",
@@ skipping 57 matching lines @@
   base_file_->Finish();
 }
 
 // Test that calculating speed after no delay - should not divide by 0.
 TEST_F(BaseFileTest, SpeedAfterNoElapsedTime) {
   ASSERT_EQ(net::OK, base_file_->Initialize());
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData1));
   ASSERT_EQ(0, CurrentSpeedAtTime(StartTick()));
   base_file_->Finish();
 }