net: rename BoundNetLog to NetLogWithSource

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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 44 matching lines @@
 
   BaseFileTest()
       : expect_file_survives_(false),
         expect_in_progress_(true),
         expected_error_(DOWNLOAD_INTERRUPT_REASON_NONE),
         file_thread_(BrowserThread::FILE, &message_loop_) {
   }
 
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    base_file_.reset(new BaseFile(net::BoundNetLog()));
+    base_file_.reset(new BaseFile(net::NetLogWithSource()));
   }
 
   void TearDown() override {
     EXPECT_FALSE(base_file_->in_progress());
     if (!expected_error_) {
       EXPECT_EQ(static_cast<int64_t>(expected_data_.size()),
                 base_file_->bytes_so_far());
     }
 
     base::FilePath full_path = base_file_->full_path();
@@ skipping 37 matching lines @@
     }
     return result == DOWNLOAD_INTERRUPT_REASON_NONE;
   }
 
   void set_expected_data(const std::string& data) { expected_data_ = data; }
 
   // Helper functions.
   // Create a file.  Returns the complete file path.
   base::FilePath CreateTestFile() {
     base::FilePath file_name;
-    BaseFile file((net::BoundNetLog()));
+    BaseFile file((net::NetLogWithSource()));
 
     EXPECT_EQ(
         DOWNLOAD_INTERRUPT_REASON_NONE,
         file.Initialize(base::FilePath(), temp_dir_.GetPath(), base::File(), 0,
                         std::string(), std::unique_ptr<crypto::SecureHash>()));
     file_name = file.full_path();
     EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
               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.
   void CreateFileWithName(const base::FilePath& file_name) {
     EXPECT_NE(base::FilePath::StringType(), file_name.value());
-    BaseFile duplicate_file((net::BoundNetLog()));
+    BaseFile duplicate_file((net::NetLogWithSource()));
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
               duplicate_file.Initialize(file_name, temp_dir_.GetPath(),
                                         base::File(), 0, std::string(),
                                         std::unique_ptr<crypto::SecureHash>()));
     // Write something into it.
     duplicate_file.AppendDataToFile(kTestData4, kTestDataLength4);
     // Detach the file so it isn't deleted on destruction of |duplicate_file|.
     duplicate_file.Detach();
   }
 
@@ skipping 132 matching lines @@
   ASSERT_TRUE(AppendDataToFile(kTestData2));
   // Get the hash state and file name.
   std::unique_ptr<crypto::SecureHash> hash_state = base_file_->Finish();
 
   base::FilePath new_file_path(temp_dir_.GetPath().Append(
       base::FilePath(FILE_PATH_LITERAL("second_file"))));
 
   ASSERT_TRUE(base::CopyFile(base_file_->full_path(), new_file_path));
 
   // Create another file
-  BaseFile second_file((net::BoundNetLog()));
+  BaseFile second_file((net::NetLogWithSource()));
   ASSERT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             second_file.Initialize(new_file_path,
                                    base::FilePath(),
                                    base::File(),
                                    base_file_->bytes_so_far(),
                                    std::string(),
                                    std::move(hash_state)));
   std::string data(kTestData3);
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             second_file.AppendDataToFile(data.data(), data.size()));
@@ skipping 104 matching lines @@
 }
 
 // Test that a failed write reports an error.
 TEST_F(BaseFileTest, WriteWithError) {
   base::FilePath path;
   ASSERT_TRUE(base::CreateTemporaryFile(&path));
 
   // Pass a file handle which was opened without the WRITE flag.
   // This should result in an error when writing.
   base::File file(path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ);
-  base_file_.reset(new BaseFile(net::BoundNetLog()));
+  base_file_.reset(new BaseFile(net::NetLogWithSource()));
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             base_file_->Initialize(path, base::FilePath(), std::move(file), 0,
                                    std::string(),
                                    std::unique_ptr<crypto::SecureHash>()));
 #if defined(OS_WIN)
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED);
 #elif defined (OS_POSIX)
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
 #endif
   ASSERT_FALSE(AppendDataToFile(kTestData1));
@@ skipping 20 matching lines @@
   base_file_->Finish();
 }
 
 // Create a file and append to it.
 TEST_F(BaseFileTest, AppendToBaseFile) {
   // Create a new file.
   base::FilePath existing_file_name = CreateTestFile();
   set_expected_data(kTestData4);
 
   // Use the file we've just created.
-  base_file_.reset(new BaseFile(net::BoundNetLog()));
+  base_file_.reset(new BaseFile(net::NetLogWithSource()));
   ASSERT_EQ(
       DOWNLOAD_INTERRUPT_REASON_NONE,
       base_file_->Initialize(existing_file_name, base::FilePath(), base::File(),
                              kTestDataLength4, std::string(),
                              std::unique_ptr<crypto::SecureHash>()));
 
   const base::FilePath file_name = base_file_->full_path();
   EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
   // Write into the file.
   EXPECT_TRUE(AppendDataToFile(kTestData1));
 
   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.
   base::FilePath readonly_file_name = CreateTestFile();
 
   // Restore permissions to the file when we are done with this test.
   base::FilePermissionRestorer restore_permissions(readonly_file_name);
 
   // Make it read-only.
   EXPECT_TRUE(base::MakeFileUnwritable(readonly_file_name));
 
   // Try to overwrite it.
-  base_file_.reset(new BaseFile(net::BoundNetLog()));
+  base_file_.reset(new BaseFile(net::NetLogWithSource()));
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED,
             base_file_->Initialize(readonly_file_name, base::FilePath(),
                                    base::File(), 0, std::string(),
                                    std::unique_ptr<crypto::SecureHash>()));
 
   expect_in_progress_ = false;
 
   const base::FilePath file_name = base_file_->full_path();
   EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
@@ skipping 223 matching lines @@
 
   const char kData[] = "hello";
   const int kDataLength = static_cast<int>(arraysize(kData) - 1);
   ASSERT_EQ(kDataLength, base::WriteFile(full_path, kData, kDataLength));
   // The file that we created here should stick around when the BaseFile is
   // destroyed during TearDown.
   expect_file_survives_ = true;
 }
 
 }  // namespace content