net: rename BoundNetLog to NetLogWithSource

content/browser/download/download_item_impl.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.
 
 // File method ordering: Methods in this file are in the same order as
 // in download_item_impl.h, with the following exception: The public
 // interface Start is placed in chronological order with the other
 // (private) routines that together define a DownloadItem's state
 // transitions as the download progresses.  See "Download progression
 // cascade" later in this file.
@@ skipping 108 matching lines @@
                                    const base::Time& end_time,
                                    const std::string& etag,
                                    const std::string& last_modified,
                                    int64_t received_bytes,
                                    int64_t total_bytes,
                                    const std::string& hash,
                                    DownloadItem::DownloadState state,
                                    DownloadDangerType danger_type,
                                    DownloadInterruptReason interrupt_reason,
                                    bool opened,
-                                   const net::BoundNetLog& bound_net_log)
+                                   const net::NetLogWithSource& net_log)
     : guid_(base::ToUpperASCII(guid)),
       download_id_(download_id),
       target_path_(target_path),
       url_chain_(url_chain),
       referrer_url_(referrer_url),
       site_url_(site_url),
       tab_url_(tab_url),
       tab_referrer_url_(tab_refererr_url),
       mime_type_(mime_type),
       original_mime_type_(original_mime_type),
       total_bytes_(total_bytes),
       last_reason_(interrupt_reason),
       start_tick_(base::TimeTicks()),
       state_(ExternalToInternalState(state)),
       danger_type_(danger_type),
       start_time_(start_time),
       end_time_(end_time),
       delegate_(delegate),
       opened_(opened),
       current_path_(current_path),
       received_bytes_(received_bytes),
       all_data_saved_(state == COMPLETE),
       hash_(hash),
       last_modified_time_(last_modified),
       etag_(etag),
-      bound_net_log_(bound_net_log),
+      net_log_(net_log),
       weak_ptr_factory_(this) {
   delegate_->Attach();
   DCHECK(state_ == COMPLETE_INTERNAL || state_ == INTERRUPTED_INTERNAL ||
          state_ == CANCELLED_INTERNAL);
   DCHECK(base::IsValidGUID(guid_));
   Init(false /* not actively downloading */, SRC_HISTORY_IMPORT);
 }
 
 // Constructing for a regular download:
 DownloadItemImpl::DownloadItemImpl(DownloadItemImplDelegate* delegate,
                                    uint32_t download_id,
                                    const DownloadCreateInfo& info,
-                                   const net::BoundNetLog& bound_net_log)
+                                   const net::NetLogWithSource& net_log)
     : guid_(base::ToUpperASCII(base::GenerateGUID())),
       download_id_(download_id),
       target_disposition_((info.save_info->prompt_for_save_location)
                               ? TARGET_DISPOSITION_PROMPT
                               : TARGET_DISPOSITION_OVERWRITE),
       url_chain_(info.url_chain),
       referrer_url_(info.referrer_url),
       site_url_(info.site_url),
       tab_url_(info.tab_url),
       tab_referrer_url_(info.tab_referrer_url),
       suggested_filename_(base::UTF16ToUTF8(info.save_info->suggested_name)),
       forced_file_path_(info.save_info->file_path),
       transition_type_(info.transition_type),
       has_user_gesture_(info.has_user_gesture),
       content_disposition_(info.content_disposition),
       mime_type_(info.mime_type),
       original_mime_type_(info.original_mime_type),
       remote_address_(info.remote_address),
       total_bytes_(info.total_bytes),
       last_reason_(info.result),
       start_tick_(base::TimeTicks::Now()),
       state_(INITIAL_INTERNAL),
       start_time_(info.start_time),
       delegate_(delegate),
       is_temporary_(!info.save_info->file_path.empty()),
       last_modified_time_(info.last_modified),
       etag_(info.etag),
-      bound_net_log_(bound_net_log),
+      net_log_(net_log),
       weak_ptr_factory_(this) {
   delegate_->Attach();
   Init(true /* actively downloading */, SRC_ACTIVE_DOWNLOAD);
 
   // Link the event sources.
-  bound_net_log_.AddEvent(
+  net_log_.AddEvent(
       net::NetLogEventType::DOWNLOAD_URL_REQUEST,
-      info.request_bound_net_log.source().ToEventParametersCallback());
+      info.request_net_log.source().ToEventParametersCallback());
 
-  info.request_bound_net_log.AddEvent(
+  info.request_net_log.AddEvent(
       net::NetLogEventType::DOWNLOAD_STARTED,
-      bound_net_log_.source().ToEventParametersCallback());
+      net_log_.source().ToEventParametersCallback());
 }
 
 // Constructing for the "Save Page As..." feature:
 DownloadItemImpl::DownloadItemImpl(
     DownloadItemImplDelegate* delegate,
     uint32_t download_id,
     const base::FilePath& path,
     const GURL& url,
     const std::string& mime_type,
     std::unique_ptr<DownloadRequestHandleInterface> request_handle,
-    const net::BoundNetLog& bound_net_log)
+    const net::NetLogWithSource& net_log)
     : is_save_package_download_(true),
       request_handle_(std::move(request_handle)),
       guid_(base::ToUpperASCII(base::GenerateGUID())),
       download_id_(download_id),
       target_path_(path),
       url_chain_(1, url),
       mime_type_(mime_type),
       original_mime_type_(mime_type),
       start_tick_(base::TimeTicks::Now()),
       state_(IN_PROGRESS_INTERNAL),
       start_time_(base::Time::Now()),
       delegate_(delegate),
       current_path_(path),
-      bound_net_log_(bound_net_log),
+      net_log_(net_log),
       weak_ptr_factory_(this) {
   delegate_->Attach();
   Init(true /* actively downloading */, SRC_SAVE_PAGE_AS);
 }
 
 DownloadItemImpl::~DownloadItemImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Should always have been nuked before now, at worst in
   // DownloadManager shutdown.
@@ skipping 31 matching lines @@
   DVLOG(20) << __func__ << "() download=" << DebugString(true);
 
   if (IsDone() || !IsDangerous())
     return;
 
   RecordDangerousDownloadAccept(GetDangerType(),
                                 GetTargetFilePath());
 
   danger_type_ = DOWNLOAD_DANGER_TYPE_USER_VALIDATED;
 
-  bound_net_log_.AddEvent(
+  net_log_.AddEvent(
       net::NetLogEventType::DOWNLOAD_ITEM_SAFETY_STATE_UPDATED,
       base::Bind(&ItemCheckedNetLogCallback, GetDangerType()));
 
   UpdateObservers();  // TODO(asanka): This is potentially unsafe. The download
                       // may not be in a consistent state or around at all after
                       // invoking observers. http://crbug.com/586610
 
   MaybeCompleteDownload();
 }
 
@@ skipping 682 matching lines @@
   file_externally_removed_ = true;
   DVLOG(20) << __func__ << "() download=" << DebugString(true);
   UpdateObservers();
 }
 
 base::WeakPtr<DownloadDestinationObserver>
 DownloadItemImpl::DestinationObserverAsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-const net::BoundNetLog& DownloadItemImpl::GetBoundNetLog() const {
-  return bound_net_log_;
+const net::NetLogWithSource& DownloadItemImpl::GetNetLogWithSource() const {
+  return net_log_;
 }
 
 void DownloadItemImpl::SetTotalBytes(int64_t total_bytes) {
   total_bytes_ = total_bytes;
 }
 
 void DownloadItemImpl::OnAllDataSaved(
     int64_t total_bytes,
     std::unique_ptr<crypto::SecureHash> hash_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 30 matching lines @@
   DCHECK(state_ == TARGET_PENDING_INTERNAL || state_ == IN_PROGRESS_INTERNAL);
 
   // There must be no pending destination_error_.
   DCHECK_EQ(destination_error_, DOWNLOAD_INTERRUPT_REASON_NONE);
 
   DVLOG(20) << __func__ << "() so_far=" << bytes_so_far
             << " per_sec=" << bytes_per_sec
             << " download=" << DebugString(true);
 
   UpdateProgress(bytes_so_far, bytes_per_sec);
-  if (bound_net_log_.IsCapturing()) {
-    bound_net_log_.AddEvent(
+  if (net_log_.IsCapturing()) {
+    net_log_.AddEvent(
         net::NetLogEventType::DOWNLOAD_ITEM_UPDATED,
         net::NetLog::Int64Callback("bytes_so_far", received_bytes_));
   }
 
   UpdateObservers();
 }
 
 void DownloadItemImpl::DestinationError(
     DownloadInterruptReason reason,
     int64_t bytes_so_far,
@@ skipping 58 matching lines @@
     if (file_name.empty())
       file_name = suggested_filename_;
     // From the URL file name.
     if (file_name.empty())
       file_name = GetURL().ExtractFileName();
   }
 
   net::NetLog::ParametersCallback active_data =
       base::Bind(&ItemActivatedNetLogCallback, this, download_type, &file_name);
   if (active) {
-    bound_net_log_.BeginEvent(net::NetLogEventType::DOWNLOAD_ITEM_ACTIVE,
+    net_log_.BeginEvent(net::NetLogEventType::DOWNLOAD_ITEM_ACTIVE,
                               active_data);
   } else {
-    bound_net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_ITEM_ACTIVE,
+    net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_ITEM_ACTIVE,
                             active_data);
   }
 
   DVLOG(20) << __func__ << "() " << DebugString(true);
 }
 
 // We're starting the download.
 void DownloadItemImpl::Start(
     std::unique_ptr<DownloadFile> file,
     std::unique_ptr<DownloadRequestHandleInterface> req_handle,
@@ skipping 614 matching lines @@
       break;
 
     case COMPLETING_INTERNAL:
       DCHECK(all_data_saved_) << "All data must be saved prior to completion.";
       DCHECK(!download_file_)
           << "Download file must be released prior to completion.";
       DCHECK(!target_path_.empty()) << "Target path must be known.";
       DCHECK(current_path_ == target_path_)
           << "Current output path must match target path.";
 
-      bound_net_log_.AddEvent(
+      net_log_.AddEvent(
           net::NetLogEventType::DOWNLOAD_ITEM_COMPLETING,
           base::Bind(&ItemCompletingNetLogCallback, received_bytes_, &hash_));
       break;
 
     case COMPLETE_INTERNAL:
-      bound_net_log_.AddEvent(
+      net_log_.AddEvent(
           net::NetLogEventType::DOWNLOAD_ITEM_FINISHED,
           base::Bind(&ItemFinishedNetLogCallback, auto_opened_));
       break;
 
     case INTERRUPTED_INTERNAL:
-      bound_net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_ITEM_INTERRUPTED,
+      net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_ITEM_INTERRUPTED,
                               base::Bind(&ItemInterruptedNetLogCallback,
                                          last_reason_, received_bytes_));
       break;
 
     case RESUMING_INTERNAL:
-      bound_net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_ITEM_RESUMED,
+      net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_ITEM_RESUMED,
                               base::Bind(&ItemResumingNetLogCallback, false,
                                          last_reason_, received_bytes_));
       break;
 
     case CANCELLED_INTERNAL:
-      bound_net_log_.AddEvent(
+      net_log_.AddEvent(
           net::NetLogEventType::DOWNLOAD_ITEM_CANCELED,
           base::Bind(&ItemCanceledNetLogCallback, received_bytes_));
       break;
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
       NOTREACHED();
       break;
   }
 
   DVLOG(20) << __func__ << "() from:" << DebugDownloadStateString(old_state)
             << " to:" << DebugDownloadStateString(state_)
             << " this = " << DebugString(true);
   bool is_done =
       (state_ == COMPLETE_INTERNAL || state_ == INTERRUPTED_INTERNAL ||
        state_ == RESUMING_INTERNAL || state_ == CANCELLED_INTERNAL);
   bool was_done =
       (old_state == COMPLETE_INTERNAL || old_state == INTERRUPTED_INTERNAL ||
        old_state == RESUMING_INTERNAL || old_state == CANCELLED_INTERNAL);
 
   // Termination
   if (is_done && !was_done)
-    bound_net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_ITEM_ACTIVE);
+    net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_ITEM_ACTIVE);
 
   // Resumption
   if (was_done && !is_done) {
     std::string file_name(target_path_.BaseName().AsUTF8Unsafe());
-    bound_net_log_.BeginEvent(net::NetLogEventType::DOWNLOAD_ITEM_ACTIVE,
+    net_log_.BeginEvent(net::NetLogEventType::DOWNLOAD_ITEM_ACTIVE,
                               base::Bind(&ItemActivatedNetLogCallback, this,
                                          SRC_ACTIVE_DOWNLOAD, &file_name));
   }
 }
 
 void DownloadItemImpl::SetDangerType(DownloadDangerType danger_type) {
   if (danger_type != danger_type_) {
-    bound_net_log_.AddEvent(
+    net_log_.AddEvent(
         net::NetLogEventType::DOWNLOAD_ITEM_SAFETY_STATE_UPDATED,
         base::Bind(&ItemCheckedNetLogCallback, danger_type));
   }
   // Only record the Malicious UMA stat if it's going from {not malicious} ->
   // {malicious}.
   if ((danger_type_ == DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS ||
        danger_type_ == DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE ||
        danger_type_ == DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT ||
        danger_type_ == DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT) &&
       (danger_type == DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST ||
        danger_type == DOWNLOAD_DANGER_TYPE_DANGEROUS_URL ||
        danger_type == DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT ||
        danger_type == DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED)) {
     RecordMaliciousDownloadClassified(danger_type);
   }
   danger_type_ = danger_type;
 }
 
 void DownloadItemImpl::SetFullPath(const base::FilePath& new_path) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << __func__ << "() new_path = \"" << new_path.value() << "\" "
             << DebugString(true);
   DCHECK(!new_path.empty());
 
-  bound_net_log_.AddEvent(
+  net_log_.AddEvent(
       net::NetLogEventType::DOWNLOAD_ITEM_RENAMED,
       base::Bind(&ItemRenamedNetLogCallback, &current_path_, &new_path));
 
   current_path_ = new_path;
 }
 
 void DownloadItemImpl::AutoResumeIfValid() {
   DVLOG(20) << __func__ << "() " << DebugString(true);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ResumeMode mode = GetResumeMode();
@@ skipping 233 matching lines @@
     case RESUME_MODE_USER_CONTINUE:
       return "USER_CONTINUE";
     case RESUME_MODE_USER_RESTART:
       return "USER_RESTART";
   }
   NOTREACHED() << "Unknown resume mode " << mode;
   return "unknown";
 }
 
 }  // namespace content