net: rename BoundNetLog to NetLogWithSource

content/browser/download/base_file.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 <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
@@ skipping 10 matching lines @@
 #include "content/browser/download/quarantine.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "crypto/secure_hash.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_event_type.h"
 
 namespace content {
 
-BaseFile::BaseFile(const net::BoundNetLog& bound_net_log)
-    : bound_net_log_(bound_net_log) {}
+BaseFile::BaseFile(const net::NetLogWithSource& net_log) : net_log_(net_log) {}
 
 BaseFile::~BaseFile() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (detached_)
     Close();
   else
     Cancel();  // Will delete the file.
 }
 
 DownloadInterruptReason BaseFile::Initialize(
@@ skipping 48 matching lines @@
                               DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
 
   // TODO(phajdan.jr): get rid of this check.
   if (data_len == 0)
     return DOWNLOAD_INTERRUPT_REASON_NONE;
 
   // The Write call below is not guaranteed to write all the data.
   size_t write_count = 0;
   size_t len = data_len;
   const char* current_data = data;
-  bound_net_log_.BeginEvent(net::NetLogEventType::DOWNLOAD_FILE_WRITTEN);
+  net_log_.BeginEvent(net::NetLogEventType::DOWNLOAD_FILE_WRITTEN);
   while (len > 0) {
     write_count++;
     int write_result = file_.WriteAtCurrentPos(current_data, len);
     DCHECK_NE(0, write_result);
 
     // Report errors on file writes.
     if (write_result < 0)
       return LogSystemError("Write", logging::GetLastSystemErrorCode());
 
     // Update status.
     size_t write_size = static_cast<size_t>(write_result);
     DCHECK_LE(write_size, len);
     len -= write_size;
     current_data += write_size;
     bytes_so_far_ += write_size;
   }
-  bound_net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_WRITTEN,
-                          net::NetLog::Int64Callback("bytes", data_len));
+  net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_WRITTEN,
+                    net::NetLog::Int64Callback("bytes", data_len));
 
   RecordDownloadWriteSize(data_len);
   RecordDownloadWriteLoopCount(write_count);
 
   if (secure_hash_)
     secure_hash_->Update(data, data_len);
 
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 
 DownloadInterruptReason BaseFile::Rename(const base::FilePath& new_path) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DownloadInterruptReason rename_result = DOWNLOAD_INTERRUPT_REASON_NONE;
 
   // If the new path is same as the old one, there is no need to perform the
   // following renaming logic.
   if (new_path == full_path_)
     return DOWNLOAD_INTERRUPT_REASON_NONE;
 
   // Save the information whether the download is in progress because
   // it will be overwritten by closing the file.
   bool was_in_progress = in_progress();
 
   Close();
 
-  bound_net_log_.BeginEvent(
+  net_log_.BeginEvent(
       net::NetLogEventType::DOWNLOAD_FILE_RENAMED,
       base::Bind(&FileRenamedNetLogCallback, &full_path_, &new_path));
 
   base::CreateDirectory(new_path.DirName());
 
   // A simple rename wouldn't work here since we want the file to have
   // permissions / security descriptors that makes sense in the new directory.
   rename_result = MoveFileAndAdjustPermissions(new_path);
 
-  bound_net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_RENAMED);
+  net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_RENAMED);
 
   if (rename_result == DOWNLOAD_INTERRUPT_REASON_NONE)
     full_path_ = new_path;
 
   // Re-open the file if we were still using it regardless of the interrupt
   // reason.
   DownloadInterruptReason open_result = DOWNLOAD_INTERRUPT_REASON_NONE;
   if (was_in_progress)
     open_result = Open(std::string());
 
   return rename_result == DOWNLOAD_INTERRUPT_REASON_NONE ? open_result
                                                          : rename_result;
 }
 
 void BaseFile::Detach() {
   detached_ = true;
-  bound_net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_FILE_DETACHED);
+  net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_FILE_DETACHED);
 }
 
 void BaseFile::Cancel() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(!detached_);
 
-  bound_net_log_.AddEvent(net::NetLogEventType::CANCELLED);
+  net_log_.AddEvent(net::NetLogEventType::CANCELLED);
 
   Close();
 
   if (!full_path_.empty()) {
-    bound_net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_FILE_DELETED);
+    net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_FILE_DELETED);
     base::DeleteFile(full_path_, false);
   }
 
   Detach();
 }
 
 std::unique_ptr<crypto::SecureHash> BaseFile::Finish() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   Close();
   return std::move(secure_hash_);
@@ skipping 86 matching lines @@
   if (!file_.IsValid()) {
     file_.Initialize(full_path_,
                      base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE |
                          base::File::FLAG_READ);
     if (!file_.IsValid()) {
       return LogNetError("Open/Initialize File",
                          net::FileErrorToNetError(file_.error_details()));
     }
   }
 
-  bound_net_log_.BeginEvent(
+  net_log_.BeginEvent(
       net::NetLogEventType::DOWNLOAD_FILE_OPENED,
       base::Bind(&FileOpenedNetLogCallback, &full_path_, bytes_so_far_));
 
   if (!secure_hash_) {
     DownloadInterruptReason reason = CalculatePartialHash(hash_so_far);
     if (reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
       ClearFile();
       return reason;
     }
   }
@@ skipping 31 matching lines @@
     // theres not much we can do.  But we might in the future.
     file_.Flush();
     ClearFile();
   }
 }
 
 void BaseFile::ClearFile() {
   // This should only be called when we have a stream.
   DCHECK(file_.IsValid());
   file_.Close();
-  bound_net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_OPENED);
+  net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_OPENED);
 }
 
 DownloadInterruptReason BaseFile::LogNetError(
     const char* operation,
     net::Error error) {
-  bound_net_log_.AddEvent(
-      net::NetLogEventType::DOWNLOAD_FILE_ERROR,
-      base::Bind(&FileErrorNetLogCallback, operation, error));
+  net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_FILE_ERROR,
+                    base::Bind(&FileErrorNetLogCallback, operation, error));
   return ConvertNetErrorToInterruptReason(error, DOWNLOAD_INTERRUPT_FROM_DISK);
 }
 
 DownloadInterruptReason BaseFile::LogSystemError(
     const char* operation,
     logging::SystemErrorCode os_error) {
   // There's no direct conversion from a system error to an interrupt reason.
   base::File::Error file_error = base::File::OSErrorToFileError(os_error);
   return LogInterruptReason(
       operation, os_error,
       ConvertFileErrorToInterruptReason(file_error));
 }
 
 DownloadInterruptReason BaseFile::LogInterruptReason(
     const char* operation,
     int os_error,
     DownloadInterruptReason reason) {
   DVLOG(1) << __func__ << "() operation:" << operation
            << " os_error:" << os_error
            << " reason:" << DownloadInterruptReasonToString(reason);
-  bound_net_log_.AddEvent(
+  net_log_.AddEvent(
       net::NetLogEventType::DOWNLOAD_FILE_ERROR,
       base::Bind(&FileInterruptedNetLogCallback, operation, os_error, reason));
   return reason;
 }
 
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
 DownloadInterruptReason BaseFile::AnnotateWithSourceInformation(
     const std::string& client_guid,
     const GURL& source_url,
     const GURL& referrer_url) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(!detached_);
   DCHECK(!full_path_.empty());
 
-  bound_net_log_.BeginEvent(net::NetLogEventType::DOWNLOAD_FILE_ANNOTATED);
+  net_log_.BeginEvent(net::NetLogEventType::DOWNLOAD_FILE_ANNOTATED);
   QuarantineFileResult result =
       QuarantineFile(full_path_, source_url, referrer_url, client_guid);
-  bound_net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_ANNOTATED);
+  net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_ANNOTATED);
   switch (result) {
     case QuarantineFileResult::OK:
       return DOWNLOAD_INTERRUPT_REASON_NONE;
     case QuarantineFileResult::VIRUS_INFECTED:
       return DOWNLOAD_INTERRUPT_REASON_FILE_VIRUS_INFECTED;
     case QuarantineFileResult::SECURITY_CHECK_FAILED:
       return DOWNLOAD_INTERRUPT_REASON_FILE_SECURITY_CHECK_FAILED;
     case QuarantineFileResult::BLOCKED_BY_POLICY:
       return DOWNLOAD_INTERRUPT_REASON_FILE_BLOCKED;
     case QuarantineFileResult::ACCESS_DENIED:
@@ skipping 25 matching lines @@
 #else  // !OS_WIN && !OS_MACOSX && !OS_LINUX
 DownloadInterruptReason BaseFile::AnnotateWithSourceInformation(
     const std::string& client_guid,
     const GURL& source_url,
     const GURL& referrer_url) {
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 #endif
 
 }  // namespace content