NetLogEventParameter to Callback refactoring 11.

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.
 
 #include "content/browser/download/download_item_impl.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 241 matching lines @@
       delegate_delayed_complete_(false),
       bound_net_log_(bound_net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   delegate_->Attach();
   Init(true /* actively downloading */,
        download_net_logs::SRC_NEW_DOWNLOAD);
 
   // Link the event sources.
   bound_net_log_.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_URL_REQUEST,
-      make_scoped_refptr(new net::NetLogSourceParameter(
-          "source_dependency",
-          info.request_bound_net_log.source())));
+      info.request_bound_net_log.source().ToEventParametersCallback());
 
   info.request_bound_net_log.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_STARTED,
-      make_scoped_refptr(new net::NetLogSourceParameter(
-          "source_dependency",
-          bound_net_log_.source())));
+      bound_net_log_.source().ToEventParametersCallback());
 }
 
 // Constructing for the "Save Page As..." feature:
 DownloadItemImpl::DownloadItemImpl(Delegate* delegate,
                                    const FilePath& path,
                                    const GURL& url,
                                    bool is_otr,
                                    DownloadId download_id,
                                    const std::string& mime_type,
                                    const net::BoundNetLog& bound_net_log)
@@ skipping 120 matching lines @@
   DCHECK_EQ(DANGEROUS, GetSafetyState());
 
   UMA_HISTOGRAM_ENUMERATION("Download.DangerousDownloadValidated",
                             GetDangerType(),
                             content::DOWNLOAD_DANGER_TYPE_MAX);
 
   safety_state_ = DANGEROUS_BUT_VALIDATED;
 
   bound_net_log_.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_ITEM_SAFETY_STATE_UPDATED,
-      make_scoped_refptr(new download_net_logs::ItemCheckedParameters(
-          GetDangerType(), GetSafetyState())));
+      base::Bind(&download_net_logs::ItemCheckedCallback,
+                 GetDangerType(), GetSafetyState()));
 
   UpdateObservers();
 
   delegate_->MaybeCompleteDownload(this);
 }
 
 void DownloadItemImpl::ProgressComplete(int64 bytes_so_far,
                                         const std::string& final_hash) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 15 matching lines @@
   received_bytes_ = bytes_so_far;
 
   // If we've received more data than we were expecting (bad server info?),
   // revert to 'unknown size mode'.
   if (received_bytes_ > total_bytes_)
     total_bytes_ = 0;
 
   if (bound_net_log_.IsLoggingAllEvents()) {
     bound_net_log_.AddEvent(
         net::NetLog::TYPE_DOWNLOAD_ITEM_UPDATED,
-        make_scoped_refptr(
-            new download_net_logs::ItemUpdatedParameters(received_bytes_)));
+        net::NetLog::Int64Callback("bytes_so_far", received_bytes_));
   }
 }
 
 // Updates from the download thread may have been posted while this download
 // was being cancelled in the UI thread, so we'll accept them unless we're
 // complete.
 void DownloadItemImpl::UpdateProgress(int64 bytes_so_far,
                                       int64 bytes_per_sec,
                                       const std::string& hash_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 93 matching lines @@
   if (state_ == new_state)
     return;
 
   DownloadState old_state = state_;
   state_ = new_state;
 
   switch (state_) {
     case COMPLETE:
       bound_net_log_.AddEvent(
           net::NetLog::TYPE_DOWNLOAD_ITEM_FINISHED,
-          make_scoped_refptr(
-              new download_net_logs::ItemFinishedParameters(received_bytes_,
-                                                            hash_)));
+          base::Bind(&download_net_logs::ItemFinishedCallback,
+                     received_bytes_, &hash_));
       break;
     case INTERRUPTED:
       bound_net_log_.AddEvent(
           net::NetLog::TYPE_DOWNLOAD_ITEM_INTERRUPTED,
-          make_scoped_refptr(
-              new download_net_logs::ItemInterruptedParameters(last_reason_,
-                                                               received_bytes_,
-                                                               hash_state_)));
+          base::Bind(&download_net_logs::ItemInterruptedCallback,
+                     last_reason_, received_bytes_, &hash_state_));
       break;
     case CANCELLED:
       bound_net_log_.AddEvent(
           net::NetLog::TYPE_DOWNLOAD_ITEM_CANCELED,
-          make_scoped_refptr(
-              new download_net_logs::ItemCanceledParameters(received_bytes_,
-                                                            hash_state_)));
+          base::Bind(&download_net_logs::ItemCanceledCallback,
+                     received_bytes_, &hash_state_));
       break;
     default:
       break;
   }
 
   VLOG(20) << " " << __FUNCTION__ << "()" << " this = " << DebugString(true);
 
   UpdateObservers();
 
   bool is_done = (state_ != IN_PROGRESS);
   bool was_done = (old_state != IN_PROGRESS);
   if (is_done && !was_done)
-    bound_net_log_.EndEvent(net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE, NULL);
+    bound_net_log_.EndEvent(net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE);
 }
 
 void DownloadItemImpl::SetDangerType(content::DownloadDangerType danger_type) {
   danger_type_ = danger_type;
   // Notify observers if the safety state has changed as a result of the new
   // danger type.
   SafetyState updated_value = IsDangerous() ?
       DownloadItem::DANGEROUS : DownloadItem::SAFE;
   if (updated_value != safety_state_) {
     safety_state_ = updated_value;
     bound_net_log_.AddEvent(
         net::NetLog::TYPE_DOWNLOAD_ITEM_SAFETY_STATE_UPDATED,
-        make_scoped_refptr(new download_net_logs::ItemCheckedParameters(
-            GetDangerType(), GetSafetyState())));
+        base::Bind(&download_net_logs::ItemCheckedCallback,
+                   GetDangerType(), GetSafetyState()));
     UpdateObservers();
   }
 }
 
 void DownloadItemImpl::SetFullPath(const FilePath& new_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(20) << __FUNCTION__ << "()"
            << " new_path = \"" << new_path.value() << "\""
            << " " << DebugString(true);
   DCHECK(!new_path.empty());
   current_path_ = new_path;
 
   bound_net_log_.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_ITEM_RENAMED,
-      make_scoped_refptr(
-          new download_net_logs::ItemRenamedParameters(
-              current_path_.AsUTF8Unsafe(), new_path.AsUTF8Unsafe())));
+      base::Bind(&download_net_logs::ItemRenamedCallback,
+                 &current_path_, &new_path));
 }
 
 void DownloadItemImpl::Interrupted(int64 size,
                                    const std::string& hash_state,
                                    content::DownloadInterruptReason reason) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!IsInProgress())
     return;
 
@@ skipping 325 matching lines @@
     // Possibly has a 'download' attribute for the anchor.
     if (file_name.empty())
       file_name = suggested_filename_;
     // From the URL file name.
     if (file_name.empty())
       file_name = GetURL().ExtractFileName();
   }
 
   bound_net_log_.BeginEvent(
       net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE,
-      make_scoped_refptr(new download_net_logs::ItemActivatedParameters(
-          download_type,
-          download_id_.local(),
-          GetOriginalUrl().spec(),
-          GetURL().spec(),
-          file_name,
-          GetDangerType(),
-          GetSafetyState(),
-          received_bytes_)));
+      base::Bind(&download_net_logs::ItemActivatedCallback,
+                 this, download_type, &file_name));
 
   // If this is not an active download, end the ACTIVE event now.
   if (!active) {
     bound_net_log_.AddEvent(
         net::NetLog::TYPE_DOWNLOAD_ITEM_IN_HISTORY,
-        make_scoped_refptr(
-            new download_net_logs::ItemInHistoryParameters(db_handle_)));
+        net::NetLog::Int64Callback("db_handle", db_handle_));
 
-    bound_net_log_.EndEvent(net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE, NULL);
+    bound_net_log_.EndEvent(net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE);
   }
 
   VLOG(20) << __FUNCTION__ << "() " << DebugString(true);
 }
 
 bool DownloadItemImpl::NeedsRename() const {
   DCHECK(target_path_.DirName() == current_path_.DirName());
   return target_path_ != current_path_;
 }
 
@@ skipping 128 matching lines @@
 
 bool DownloadItemImpl::IsPersisted() const {
   return is_persisted_;
 }
 
 void DownloadItemImpl::SetDbHandle(int64 handle) {
   db_handle_ = handle;
 
   bound_net_log_.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_ITEM_IN_HISTORY,
-      make_scoped_refptr(
-          new download_net_logs::ItemInHistoryParameters(db_handle_)));
+      net::NetLog::Int64Callback("db_handle", db_handle_));
 }
 
 int64 DownloadItemImpl::GetDbHandle() const { return db_handle_; }
 bool DownloadItemImpl::IsPaused() const { return is_paused_; }
 bool DownloadItemImpl::GetOpenWhenComplete() const {
   return open_when_complete_;
 }
 void DownloadItemImpl::SetOpenWhenComplete(bool open) {
   open_when_complete_ = open;
 }
@@ skipping 54 matching lines @@
   std::map<const void*, ExternalData*>::iterator it =
       external_data_map_.find(key);
 
   if (it == external_data_map_.end()) {
     external_data_map_[key] = data;
   } else if (it->second != data) {
     delete it->second;
     it->second = data;
   }
 }