net: rename BoundNetLog to NetLogWithSource

content/public/test/test_file_error_injector.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/public/test/test_file_error_injector.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 11 matching lines @@
 class ByteStreamReader;
 
 namespace {
 
 // A class that performs file operations and injects errors.
 class DownloadFileWithError: public DownloadFileImpl {
  public:
   DownloadFileWithError(std::unique_ptr<DownloadSaveInfo> save_info,
                         const base::FilePath& default_download_directory,
                         std::unique_ptr<ByteStreamReader> byte_stream,
-                        const net::BoundNetLog& bound_net_log,
+                        const net::NetLogWithSource& net_log,
                         base::WeakPtr<DownloadDestinationObserver> observer,
                         const TestFileErrorInjector::FileErrorInfo& error_info,
                         const base::Closure& ctor_callback,
                         const base::Closure& dtor_callback);
 
   ~DownloadFileWithError() override;
 
   void Initialize(const InitializeCallback& callback) override;
 
   // DownloadFile interface.
@@ skipping 48 matching lines @@
   original_callback.Run(
       overwrite_error,
       overwrite_error == DOWNLOAD_INTERRUPT_REASON_NONE ?
       path_result : base::FilePath());
 }
 
 DownloadFileWithError::DownloadFileWithError(
     std::unique_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
     std::unique_ptr<ByteStreamReader> byte_stream,
-    const net::BoundNetLog& bound_net_log,
+    const net::NetLogWithSource& net_log,
     base::WeakPtr<DownloadDestinationObserver> observer,
     const TestFileErrorInjector::FileErrorInfo& error_info,
     const base::Closure& ctor_callback,
     const base::Closure& dtor_callback)
     : DownloadFileImpl(std::move(save_info),
                        default_download_directory,
                        std::move(byte_stream),
-                       bound_net_log,
+                       net_log,
                        observer),
       error_info_(error_info),
       destruction_callback_(dtor_callback) {
   // DownloadFiles are created on the UI thread and are destroyed on the FILE
   // thread. Schedule the ConstructionCallback on the FILE thread so that if a
   // DownloadItem schedules a DownloadFile to be destroyed and creates another
   // one (as happens during download resumption), then the DestructionCallback
   // for the old DownloadFile is run before the ConstructionCallback for the
   // next DownloadFile.
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, ctor_callback);
@@ skipping 125 matching lines @@
  public:
   DownloadFileWithErrorFactory(const base::Closure& ctor_callback,
                                 const base::Closure& dtor_callback);
   ~DownloadFileWithErrorFactory() override;
 
   // DownloadFileFactory interface.
   DownloadFile* CreateFile(
       std::unique_ptr<DownloadSaveInfo> save_info,
       const base::FilePath& default_download_directory,
       std::unique_ptr<ByteStreamReader> byte_stream,
-      const net::BoundNetLog& bound_net_log,
+      const net::NetLogWithSource& net_log,
       base::WeakPtr<DownloadDestinationObserver> observer) override;
 
   bool SetError(TestFileErrorInjector::FileErrorInfo error);
 
  private:
   // Our injected error.
   TestFileErrorInjector::FileErrorInfo injected_error_;
 
   // Callback for creation and destruction.
   base::Closure construction_callback_;
   base::Closure destruction_callback_;
 };
 
 DownloadFileWithErrorFactory::DownloadFileWithErrorFactory(
     const base::Closure& ctor_callback,
     const base::Closure& dtor_callback)
     : construction_callback_(ctor_callback),
       destruction_callback_(dtor_callback) {
   injected_error_.code = TestFileErrorInjector::FILE_OPERATION_INITIALIZE;
   injected_error_.error = DOWNLOAD_INTERRUPT_REASON_NONE;
   injected_error_.operation_instance = -1;
 }
 
 DownloadFileWithErrorFactory::~DownloadFileWithErrorFactory() {}
 
 DownloadFile* DownloadFileWithErrorFactory::CreateFile(
     std::unique_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
     std::unique_ptr<ByteStreamReader> byte_stream,
-    const net::BoundNetLog& bound_net_log,
+    const net::NetLogWithSource& net_log,
     base::WeakPtr<DownloadDestinationObserver> observer) {
   return new DownloadFileWithError(std::move(save_info),
                                    default_download_directory,
                                    std::move(byte_stream),
-                                   bound_net_log,
+                                   net_log,
                                    observer,
                                    injected_error_,
                                    construction_callback_,
                                    destruction_callback_);
 }
 
 bool DownloadFileWithErrorFactory::SetError(
     TestFileErrorInjector::FileErrorInfo error) {
   injected_error_ = std::move(error);
   return true;
@@ skipping 98 matching lines @@
     case FILE_OPERATION_RENAME_ANNOTATE:
       return "RENAME_ANNOTATE";
     default:
       break;
   }
 
   return "Unknown";
 }
 
 }  // namespace content