[content/browser/download] Convert VLOGs to DVLOGs

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 288 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadUpdated(this));
 }
 
 void DownloadItemImpl::ValidateDangerousDownload() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!IsDone());
   DCHECK(IsDangerous());
 
-  VLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
 
   if (IsDone() || !IsDangerous())
     return;
 
   RecordDangerousDownloadAccept(GetDangerType(),
                                 GetTargetFilePath());
 
   danger_type_ = DOWNLOAD_DANGER_TYPE_USER_VALIDATED;
 
   bound_net_log_.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_ITEM_SAFETY_STATE_UPDATED,
       base::Bind(&ItemCheckedNetLogCallback, GetDangerType()));
 
   UpdateObservers();
 
   MaybeCompleteDownload();
 }
 
 void DownloadItemImpl::StealDangerousDownload(
     const AcquireFileCallback& callback) {
-  VLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(IsDangerous());
   if (download_file_) {
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&DownloadFileDetach, base::Passed(&download_file_)),
         callback);
   } else {
     callback.Run(current_path_);
@@ skipping 38 matching lines @@
       return;
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
       NOTREACHED();
   }
 }
 
 void DownloadItemImpl::Cancel(bool user_cancel) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  VLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
   if (state_ != IN_PROGRESS_INTERNAL &&
       state_ != INTERRUPTED_INTERNAL &&
       state_ != RESUMING_INTERNAL) {
     // Small downloads might be complete before this method has a chance to run.
     return;
   }
 
   if (IsDangerous()) {
     RecordDangerousDownloadDiscard(
         user_cancel ? DOWNLOAD_DISCARD_DUE_TO_USER_ACTION
@@ skipping 27 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(base::IgnoreResult(&DeleteDownloadedFile), current_path_));
     current_path_.clear();
   }
 
   TransitionTo(CANCELLED_INTERNAL, UPDATE_OBSERVERS);
 }
 
 void DownloadItemImpl::Remove() {
-  VLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   delegate_->AssertStateConsistent(this);
   Cancel(true);
   delegate_->AssertStateConsistent(this);
 
   NotifyRemoved();
   delegate_->DownloadRemoved(this);
   // We have now been deleted.
 }
@@ skipping 326 matching lines @@
   // Currently such items have null request_handle_s, where other items
   // (regular and SavePackage downloads) have actual objects off the pointer.
   if (request_handle_)
     return request_handle_->GetWebContents();
   return NULL;
 }
 
 void DownloadItemImpl::OnContentCheckCompleted(DownloadDangerType danger_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(AllDataSaved());
-  VLOG(20) << __FUNCTION__ << " danger_type=" << danger_type
-           << " download=" << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << " danger_type=" << danger_type
+            << " download=" << DebugString(true);
   SetDangerType(danger_type);
   UpdateObservers();
 }
 
 void DownloadItemImpl::SetOpenWhenComplete(bool open) {
   open_when_complete_ = open;
 }
 
 void DownloadItemImpl::SetIsTemporary(bool temporary) {
   is_temporary_ = temporary;
@@ skipping 183 matching lines @@
   // DownloadFile is created and Start() is called. The observers will be
   // notified when the download transitions to the IN_PROGRESS state.
 }
 
 void DownloadItemImpl::NotifyRemoved() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadRemoved(this));
 }
 
 void DownloadItemImpl::OnDownloadedFileRemoved() {
   file_externally_removed_ = true;
-  VLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
   UpdateObservers();
 }
 
 base::WeakPtr<DownloadDestinationObserver>
 DownloadItemImpl::DestinationObserverAsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 const net::BoundNetLog& DownloadItemImpl::GetBoundNetLog() const {
   return bound_net_log_;
 }
 
 void DownloadItemImpl::SetTotalBytes(int64 total_bytes) {
   total_bytes_ = total_bytes;
 }
 
 void DownloadItemImpl::OnAllDataSaved(const std::string& final_hash) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK_EQ(IN_PROGRESS_INTERNAL, state_);
   DCHECK(!all_data_saved_);
   all_data_saved_ = true;
-  VLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
 
   // Store final hash and null out intermediate serialized hash state.
   hash_ = final_hash;
   hash_state_ = "";
 
   UpdateObservers();
 }
 
 void DownloadItemImpl::MarkAsComplete() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(all_data_saved_);
   end_time_ = base::Time::Now();
   TransitionTo(COMPLETE_INTERNAL, UPDATE_OBSERVERS);
 }
 
 void DownloadItemImpl::DestinationUpdate(int64 bytes_so_far,
                                          int64 bytes_per_sec,
                                          const std::string& hash_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  VLOG(20) << __FUNCTION__ << " so_far=" << bytes_so_far
-           << " per_sec=" << bytes_per_sec << " download=" << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << " so_far=" << bytes_so_far
+            << " per_sec=" << bytes_per_sec << " download="
+            << DebugString(true);
 
   if (GetState() != IN_PROGRESS) {
     // Ignore if we're no longer in-progress.  This can happen if we race a
     // Cancel on the UI thread with an update on the FILE thread.
     //
     // TODO(rdsmith): Arguably we should let this go through, as this means
     // the download really did get further than we know before it was
     // cancelled.  But the gain isn't very large, and the code is more
     // fragile if it has to support in progress updates in a non-in-progress
     // state.  This issue should be readdressed when we revamp performance
@@ skipping 22 matching lines @@
   // Postpone recognition of this error until after file name determination
   // has completed and the intermediate file has been renamed to simplify
   // resumption conditions.
   if (current_path_.empty() || target_path_.empty())
     destination_error_ = reason;
   else
     Interrupt(reason);
 }
 
 void DownloadItemImpl::DestinationCompleted(const std::string& final_hash) {
-  VLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
   if (GetState() != IN_PROGRESS)
     return;
   OnAllDataSaved(final_hash);
   MaybeCompleteDownload();
 }
 
 // **** Download progression cascade
 
 void DownloadItemImpl::Init(bool active,
                             DownloadType download_type) {
@@ skipping 20 matching lines @@
   base::Callback<base::Value*(net::NetLog::LogLevel)> active_data = base::Bind(
       &ItemActivatedNetLogCallback, this, download_type, &file_name);
   if (active) {
     bound_net_log_.BeginEvent(
         net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE, active_data);
   } else {
     bound_net_log_.AddEvent(
         net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE, active_data);
   }
 
-  VLOG(20) << __FUNCTION__ << "() " << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << "() " << DebugString(true);
 }
 
 // We're starting the download.
 void DownloadItemImpl::Start(
     scoped_ptr<DownloadFile> file,
     scoped_ptr<DownloadRequestHandleInterface> req_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!download_file_.get());
   DCHECK(file.get());
   DCHECK(req_handle.get());
@@ skipping 58 matching lines @@
   }
 
   // TODO(rdsmith,asanka): We are ignoring the possibility that the download
   // has been interrupted at this point until we finish the intermediate
   // rename and set the full path.  That's dangerous, because we might race
   // with resumption, either manual (because the interrupt is visible to the
   // UI) or automatic.  If we keep the "ignore an error on download until file
   // name determination complete" semantics, we need to make sure that the
   // error is kept completely invisible until that point.
 
-  VLOG(20) << __FUNCTION__ << " " << target_path.value() << " " << disposition
-           << " " << danger_type << " " << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << " " << target_path.value() << " " << disposition
+            << " " << danger_type << " " << DebugString(true);
 
   target_path_ = target_path;
   target_disposition_ = disposition;
   SetDangerType(danger_type);
 
   // We want the intermediate and target paths to refer to the same directory so
   // that they are both on the same device and subject to same
   // space/permission/availability constraints.
   DCHECK(intermediate_path.DirName() == target_path.DirName());
 
@@ skipping 25 matching lines @@
       base::Bind(&DownloadFile::RenameAndUniquify,
                  // Safe because we control download file lifetime.
                  base::Unretained(download_file_.get()),
                  intermediate_path, callback));
 }
 
 void DownloadItemImpl::OnDownloadRenamedToIntermediateName(
     DownloadInterruptReason reason,
     const base::FilePath& full_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  VLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
 
   if (DOWNLOAD_INTERRUPT_REASON_NONE != destination_error_) {
     // Process destination error.  If both |reason| and |destination_error_|
     // refer to actual errors, we want to use the |destination_error_| as the
     // argument to the Interrupt() routine, as it happened first.
     if (reason == DOWNLOAD_INTERRUPT_REASON_NONE)
       SetFullPath(full_path);
     Interrupt(destination_error_);
     destination_error_ = DOWNLOAD_INTERRUPT_REASON_NONE;
   } else if (DOWNLOAD_INTERRUPT_REASON_NONE != reason) {
@@ skipping 41 matching lines @@
 }
 
 // Called by MaybeCompleteDownload() when it has determined that the download
 // is ready for completion.
 void DownloadItemImpl::OnDownloadCompleting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (state_ != IN_PROGRESS_INTERNAL)
     return;
 
-  VLOG(20) << __FUNCTION__ << "()"
-           << " " << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << "()"
+            << " " << DebugString(true);
   DCHECK(!GetTargetFilePath().empty());
   DCHECK(!IsDangerous());
 
   // TODO(rdsmith/benjhayden): Remove as part of SavePackage integration.
   if (is_save_package_download_) {
     // Avoid doing anything on the file thread; there's nothing we control
     // there.
     // Strictly speaking, this skips giving the embedder a chance to open
     // the download.  But on a save package download, there's no real
     // concept of opening.
@@ skipping 19 matching lines @@
     const base::FilePath& full_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!is_save_package_download_);
 
   // If a cancel or interrupt hit, we'll cancel the DownloadFile, which
   // will result in deleting the file on the file thread.  So we don't
   // care about the name having been changed.
   if (state_ != IN_PROGRESS_INTERNAL)
     return;
 
-  VLOG(20) << __FUNCTION__ << "()"
-           << " full_path = \"" << full_path.value() << "\""
-           << " " << DebugString(false);
+  DVLOG(20) << __FUNCTION__ << "()"
+            << " full_path = \"" << full_path.value() << "\""
+            << " " << DebugString(false);
 
   if (DOWNLOAD_INTERRUPT_REASON_NONE != reason) {
     Interrupt(reason);
 
     // All file errors should have resulted in in file deletion above. On
     // resumption we will need to re-do filename determination.
     DCHECK(current_path_.empty());
     return;
   }
 
@@ skipping 28 matching lines @@
 void DownloadItemImpl::DelayedDownloadOpened(bool auto_opened) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   auto_opened_ = auto_opened;
   Completed();
 }
 
 void DownloadItemImpl::Completed() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  VLOG(20) << __FUNCTION__ << "() " << DebugString(false);
+  DVLOG(20) << __FUNCTION__ << "() " << DebugString(false);
 
   DCHECK(all_data_saved_);
   end_time_ = base::Time::Now();
   TransitionTo(COMPLETE_INTERNAL, UPDATE_OBSERVERS);
   RecordDownloadCompleted(start_tick_, received_bytes_);
 
   if (auto_opened_) {
     // If it was already handled by the delegate, do nothing.
   } else if (GetOpenWhenComplete() ||
              ShouldOpenFileBasedOnExtension() ||
@@ skipping 186 matching lines @@
     case CANCELLED_INTERNAL:
       bound_net_log_.AddEvent(
           net::NetLog::TYPE_DOWNLOAD_ITEM_CANCELED,
           base::Bind(&ItemCanceledNetLogCallback, received_bytes_,
                      &hash_state_));
       break;
     default:
       break;
   }
 
-  VLOG(20) << " " << __FUNCTION__ << "()" << " this = " << DebugString(true)
-    << " " << InternalToExternalState(old_state)
-    << " " << InternalToExternalState(state_);
+  DVLOG(20) << " " << __FUNCTION__ << "()" << " this = " << DebugString(true)
+     << " " << InternalToExternalState(old_state)
+     << " " << InternalToExternalState(state_);
 
   bool is_done = (state_ != IN_PROGRESS_INTERNAL &&
                   state_ != COMPLETING_INTERNAL);
   bool was_done = (old_state != IN_PROGRESS_INTERNAL &&
                    old_state != COMPLETING_INTERNAL);
   // Termination
   if (is_done && !was_done)
     bound_net_log_.EndEvent(net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE);
 
   // Resumption
@@ skipping 25 matching lines @@
        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(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  VLOG(20) << __FUNCTION__ << "()"
-           << " new_path = \"" << new_path.value() << "\""
-           << " " << DebugString(true);
+  DVLOG(20) << __FUNCTION__ << "()"
+            << " new_path = \"" << new_path.value() << "\""
+            << " " << DebugString(true);
   DCHECK(!new_path.empty());
 
   bound_net_log_.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_ITEM_RENAMED,
       base::Bind(&ItemRenamedNetLogCallback, &current_path_, &new_path));
 
   current_path_ = new_path;
 }
 
 void DownloadItemImpl::AutoResumeIfValid() {
@@ skipping 137 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