Use the user's preferred downloads directory for creating the initial download file.

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 33 matching lines @@
   BaseFileTest()
       : expect_file_survives_(false),
         expect_in_progress_(true),
         expected_error_(false),
         file_thread_(BrowserThread::FILE, &message_loop_) {
   }
 
   virtual void SetUp() {
     ResetHash();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    base_file_.reset(new BaseFile(FilePath(),
+    base_file_.reset(new BaseFile(temp_dir_.path(),
+                                  FilePath(),
                                   GURL(),
                                   GURL(),
                                   0,
                                   false,
                                   "",
                                   file_stream_,
                                   net::BoundNetLog()));
   }
 
   virtual void TearDown() {
@@ skipping 30 matching lines @@
 
   std::string GetFinalHash() {
     std::string hash;
     secure_hash_->Finish(sha256_hash_, kSha256HashLen);
     hash.assign(reinterpret_cast<const char*>(sha256_hash_),
                 sizeof(sha256_hash_));
     return hash;
   }
 
   void MakeFileWithHash() {
-    base_file_.reset(new BaseFile(FilePath(),
+    base_file_.reset(new BaseFile(temp_dir_.path(),
+                                  FilePath(),
                                   GURL(),
                                   GURL(),
                                   0,
                                   true,
                                   "",
                                   file_stream_,
                                   net::BoundNetLog()));
   }
 
   bool OpenMockFileStream() {
@@ skipping 34 matching lines @@
                   base_file_->bytes_so_far());
       }
     }
     return appended;
   }
 
   void set_expected_data(const std::string& data) { expected_data_ = data; }
 
   // Helper functions.
   // Create a file.  Returns the complete file path.
-  static FilePath CreateTestFile() {
+  FilePath CreateTestFile() {
     FilePath file_name;
     linked_ptr<net::FileStream> dummy_file_stream;
-    BaseFile file(FilePath(),
+    BaseFile file(temp_dir_.path(),
+                  FilePath(),
                   GURL(),
                   GURL(),
                   0,
                   false,
                   "",
                   dummy_file_stream,
                   net::BoundNetLog());
 
     EXPECT_EQ(net::OK, file.Initialize());
     file_name = file.full_path();
     EXPECT_NE(FilePath::StringType(), file_name.value());
 
     EXPECT_EQ(net::OK, file.AppendDataToFile(kTestData4, kTestDataLength4));
 
     // Keep the file from getting deleted when existing_file_name is deleted.
     file.Detach();
 
     return file_name;
   }
 
   // Create a file with the specified file name.
-  static void CreateFileWithName(const FilePath& file_name) {
+  void CreateFileWithName(const FilePath& file_name) {
     EXPECT_NE(FilePath::StringType(), file_name.value());
     linked_ptr<net::FileStream> dummy_file_stream;
-    BaseFile duplicate_file(file_name,
+    BaseFile duplicate_file(temp_dir_.path(),
+                            file_name,
                             GURL(),
                             GURL(),
                             0,
                             false,
                             "",
                             dummy_file_stream,
                             net::BoundNetLog());
     EXPECT_EQ(net::OK, duplicate_file.Initialize());
     // Write something into it.
     duplicate_file.AppendDataToFile(kTestData4, kTestDataLength4);
@@ skipping 200 matching lines @@
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData1));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData2));
   // Get the hash state and file name.
   std::string hash_state;
   hash_state = base_file_->GetHashState();
   // Finish the file.
   base_file_->Finish();
 
   // Create another file
   linked_ptr<net::FileStream> second_stream;
-  BaseFile second_file(FilePath(),
+  BaseFile second_file(temp_dir_.path(),
+                       FilePath(),
                        GURL(),
                        GURL(),
                        base_file_->bytes_so_far(),
                        true,
                        hash_state,
                        second_stream,
                        net::BoundNetLog());
   ASSERT_EQ(net::OK, second_file.Initialize());
   std::string data(kTestData3);
   EXPECT_EQ(net::OK, second_file.AppendDataToFile(data.data(), data.size()));
@@ skipping 62 matching lines @@
     ASSERT_TRUE(file_util::MakeFileUnwritable(test_dir));
     EXPECT_EQ(net::ERR_ACCESS_DENIED, base_file_->Rename(new_path));
   }
 
   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(),
+  base_file_.reset(new BaseFile(temp_dir_.path(),
+                                mock_file_stream_->get_path(),
                                 GURL(),
                                 GURL(),
                                 0,
                                 false,
                                 "",
                                 mock_file_stream_,
                                 net::BoundNetLog()));
   EXPECT_EQ(net::OK, base_file_->Initialize());
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData1));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData2));
@@ skipping 24 matching lines @@
 }
 
 // Create a file and append to it.
 TEST_F(BaseFileTest, AppendToBaseFile) {
   // Create a new file.
   FilePath existing_file_name = CreateTestFile();
 
   set_expected_data(kTestData4);
 
   // Use the file we've just created.
-  base_file_.reset(new BaseFile(existing_file_name,
+  base_file_.reset(new BaseFile(temp_dir_.path(),
+                                existing_file_name,
                                 GURL(),
                                 GURL(),
                                 kTestDataLength4,
                                 false,
                                 "",
                                 file_stream_,
                                 net::BoundNetLog()));
 
   EXPECT_EQ(net::OK, base_file_->Initialize());
 
@@ skipping 13 matching lines @@
   // 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,
+  base_file_.reset(new BaseFile(temp_dir_.path(),
+                                readonly_file_name,
                                 GURL(),
                                 GURL(),
                                 0,
                                 false,
                                 "",
                                 file_stream_,
                                 net::BoundNetLog()));
 
   expect_in_progress_ = false;
 
@@ skipping 52 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();
 }
+
+// Test that a temporary file is created in the default download directory.
+TEST_F(BaseFileTest, CreatedInDefaultDirectory) {
+  ASSERT_TRUE(base_file_->full_path().empty());
+  ASSERT_EQ(net::OK, base_file_->Initialize());
+  EXPECT_FALSE(base_file_->full_path().empty());
+  // The default download directory was set to be temp_dir_.path() in SetUp().
+  EXPECT_EQ(temp_dir_.path(), base_file_->full_path().DirName());
+  base_file_->Finish();
+}