Use __func__ instead of __FUNCTION__.

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 243 matching lines @@
 }
 
 void DownloadItemImpl::RemoveObserver(Observer* observer) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   observers_.RemoveObserver(observer);
 }
 
 void DownloadItemImpl::UpdateObservers() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DVLOG(20) << __FUNCTION__ << "()";
+  DVLOG(20) << __func__ << "()";
 
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadUpdated(this));
 }
 
 void DownloadItemImpl::ValidateDangerousDownload() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!IsDone());
   DCHECK(IsDangerous());
 
-  DVLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
+  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::NetLog::TYPE_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();
 }
 
 void DownloadItemImpl::StealDangerousDownload(
     const AcquireFileCallback& callback) {
-  DVLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
+  DVLOG(20) << __func__ << "() download = " << DebugString(true);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(IsDangerous());
 
   if (download_file_) {
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&DownloadFileDetach, base::Passed(&download_file_)),
         callback);
   } else {
@@ skipping 34 matching lines @@
       return;
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
     case TARGET_RESOLVED_INTERNAL:
       NOTREACHED();
   }
 }
 
 void DownloadItemImpl::Resume() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DVLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
+  DVLOG(20) << __func__ << "() download = " << DebugString(true);
   switch (state_) {
     case CANCELLED_INTERNAL:  // Nothing to resume.
     case COMPLETE_INTERNAL:
     case COMPLETING_INTERNAL:
     case INITIAL_INTERNAL:
     case INTERRUPTED_TARGET_PENDING_INTERNAL:
     case RESUMING_INTERNAL:   // Resumption in progress.
       return;
 
     case TARGET_PENDING_INTERNAL:
@@ skipping 12 matching lines @@
       return;
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
     case TARGET_RESOLVED_INTERNAL:
       NOTREACHED();
   }
 }
 
 void DownloadItemImpl::Cancel(bool user_cancel) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DVLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
+  DVLOG(20) << __func__ << "() download = " << DebugString(true);
   InterruptAndDiscardPartialState(
       user_cancel ? DOWNLOAD_INTERRUPT_REASON_USER_CANCELED
                   : DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN);
   UpdateObservers();
 }
 
 void DownloadItemImpl::Remove() {
-  DVLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
+  DVLOG(20) << __func__ << "() download = " << DebugString(true);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   delegate_->AssertStateConsistent(this);
   InterruptAndDiscardPartialState(DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
   UpdateObservers();
   delegate_->AssertStateConsistent(this);
 
   NotifyRemoved();
   delegate_->DownloadRemoved(this);
   // We have now been deleted.
@@ skipping 345 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(AllDataSaved());
 
   // Danger type is only allowed to be set on an active download after all data
   // has been saved. This excludes all other states. In particular,
   // OnContentCheckCompleted() isn't allowed on an INTERRUPTED download since
   // such an interruption would need to happen between OnAllDataSaved() and
   // OnContentCheckCompleted() during which no disk or network activity
   // should've taken place.
   DCHECK_EQ(state_, IN_PROGRESS_INTERNAL);
-  DVLOG(20) << __FUNCTION__ << " danger_type=" << danger_type
+  DVLOG(20) << __func__ << "() danger_type=" << danger_type
             << " download=" << DebugString(true);
   SetDangerType(danger_type);
   UpdateObservers();
 }
 
 void DownloadItemImpl::SetOpenWhenComplete(bool open) {
   open_when_complete_ = open;
 }
 
 void DownloadItemImpl::SetOpened(bool opened) {
@@ skipping 198 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;
-  DVLOG(20) << __FUNCTION__ << " download=" << DebugString(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_;
 }
 
 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);
   DCHECK(!all_data_saved_);
   all_data_saved_ = true;
   SetTotalBytes(total_bytes);
   UpdateProgress(total_bytes, 0);
   SetHashState(std::move(hash_state));
   hash_state_.reset();  // No need to retain hash_state_ since we are done with
                         // the download and don't expect to receive any more
                         // data.
 
-  DVLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
+  DVLOG(20) << __func__ << "() download=" << DebugString(true);
   UpdateObservers();
 }
 
 void DownloadItemImpl::MarkAsComplete() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DCHECK(all_data_saved_);
   end_time_ = base::Time::Now();
   TransitionTo(COMPLETE_INTERNAL);
   UpdateObservers();
 }
 
 void DownloadItemImpl::DestinationUpdate(int64_t bytes_so_far,
                                          int64_t bytes_per_sec) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // If the download is in any other state we don't expect any
   // DownloadDestinationObserver callbacks. An interruption or a cancellation
   // results in a call to ReleaseDownloadFile which invalidates the weak
   // reference held by the DownloadFile and hence cuts off any pending
   // callbacks.
   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) << __FUNCTION__ << " so_far=" << bytes_so_far
+  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(
         net::NetLog::TYPE_DOWNLOAD_ITEM_UPDATED,
         net::NetLog::Int64Callback("bytes_so_far", received_bytes_));
   }
 
   UpdateObservers();
 }
 
 void DownloadItemImpl::DestinationError(
     DownloadInterruptReason reason,
     int64_t bytes_so_far,
     std::unique_ptr<crypto::SecureHash> secure_hash) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // If the download is in any other state we don't expect any
   // DownloadDestinationObserver callbacks. An interruption or a cancellation
   // results in a call to ReleaseDownloadFile which invalidates the weak
   // reference held by the DownloadFile and hence cuts off any pending
   // callbacks.
   DCHECK(state_ == TARGET_PENDING_INTERNAL || state_ == IN_PROGRESS_INTERNAL);
-  DVLOG(20) << __FUNCTION__
+  DVLOG(20) << __func__
             << "() reason:" << DownloadInterruptReasonToString(reason);
 
   // Postpone recognition of this error until after file name determination
   // has completed and the intermediate file has been renamed to simplify
   // resumption conditions.
   if (state_ == TARGET_PENDING_INTERNAL) {
     received_bytes_ = bytes_so_far;
     hash_state_ = std::move(secure_hash);
     hash_.clear();
     destination_error_ = reason;
     return;
   }
   InterruptWithPartialState(bytes_so_far, std::move(secure_hash), reason);
   UpdateObservers();
 }
 
 void DownloadItemImpl::DestinationCompleted(
     int64_t total_bytes,
     std::unique_ptr<crypto::SecureHash> secure_hash) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // If the download is in any other state we don't expect any
   // DownloadDestinationObserver callbacks. An interruption or a cancellation
   // results in a call to ReleaseDownloadFile which invalidates the weak
   // reference held by the DownloadFile and hence cuts off any pending
   // callbacks.
   DCHECK(state_ == TARGET_PENDING_INTERNAL || state_ == IN_PROGRESS_INTERNAL);
-  DVLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
+  DVLOG(20) << __func__ << "() download=" << DebugString(true);
 
   OnAllDataSaved(total_bytes, std::move(secure_hash));
   MaybeCompleteDownload();
 }
 
 // **** Download progression cascade
 
 void DownloadItemImpl::Init(bool active,
                             DownloadType download_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 19 matching lines @@
   net::NetLog::ParametersCallback 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);
   }
 
-  DVLOG(20) << __FUNCTION__ << "() " << DebugString(true);
+  DVLOG(20) << __func__ << "() " << DebugString(true);
 }
 
 // We're starting the download.
 void DownloadItemImpl::Start(
     std::unique_ptr<DownloadFile> file,
     std::unique_ptr<DownloadRequestHandleInterface> req_handle,
     const DownloadCreateInfo& new_create_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!download_file_.get());
-  DVLOG(20) << __FUNCTION__ << "() this=" << DebugString(true);
+  DVLOG(20) << __func__ << "() this=" << DebugString(true);
 
   download_file_ = std::move(file);
   request_handle_ = std::move(req_handle);
   destination_error_ = DOWNLOAD_INTERRUPT_REASON_NONE;
 
   if (state_ == CANCELLED_INTERNAL) {
     // The download was in the process of resuming when it was cancelled. Don't
     // proceed.
     ReleaseDownloadFile(true);
     if (request_handle_)
@@ skipping 62 matching lines @@
                  // Safe because we control download file lifetime.
                  base::Unretained(download_file_.get()),
                  base::Bind(&DownloadItemImpl::OnDownloadFileInitialized,
                             weak_ptr_factory_.GetWeakPtr())));
 }
 
 void DownloadItemImpl::OnDownloadFileInitialized(
     DownloadInterruptReason result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(state_, TARGET_PENDING_INTERNAL);
-  DVLOG(20) << __FUNCTION__
+  DVLOG(20) << __func__
             << "() result:" << DownloadInterruptReasonToString(result);
   if (result != DOWNLOAD_INTERRUPT_REASON_NONE) {
     // Whoops. That didn't work. Proceed as an interrupted download, but reset
     // the partial state. Currently, the partial stub cannot be recovered if the
     // download file initialization fails.
     received_bytes_ = 0;
     hash_state_.reset();
     hash_.clear();
     destination_error_ = result;
     TransitionTo(INTERRUPTED_TARGET_PENDING_INTERNAL);
   }
 
   DetermineDownloadTarget();
 }
 
 void DownloadItemImpl::DetermineDownloadTarget() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DVLOG(20) << __FUNCTION__ << "() " << DebugString(true);
+  DVLOG(20) << __func__ << "() " << DebugString(true);
 
   delegate_->DetermineDownloadTarget(
       this, base::Bind(&DownloadItemImpl::OnDownloadTargetDetermined,
                        weak_ptr_factory_.GetWeakPtr()));
 }
 
 // Called by delegate_ when the download target path has been determined.
 void DownloadItemImpl::OnDownloadTargetDetermined(
     const base::FilePath& target_path,
     TargetDisposition disposition,
     DownloadDangerType danger_type,
     const base::FilePath& intermediate_path) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(state_ == TARGET_PENDING_INTERNAL ||
          state_ == INTERRUPTED_TARGET_PENDING_INTERNAL);
 
   // If the |target_path| is empty, then we consider this download to be
   // canceled.
   if (target_path.empty()) {
     Cancel(true);
     return;
   }
 
-  DVLOG(20) << __FUNCTION__ << "() target_path:" << target_path.value()
+  DVLOG(20) << __func__ << "() target_path:" << target_path.value()
             << " disposition:" << disposition << " danger_type:" << danger_type
             << " this:" << DebugString(true);
 
   target_path_ = target_path;
   target_disposition_ = disposition;
   SetDangerType(danger_type);
 
   // This was an interrupted download that was looking for a filename. Now that
   // it has one, transition to interrupted.
   if (state_ == INTERRUPTED_TARGET_PENDING_INTERNAL) {
@@ skipping 38 matching lines @@
                  // 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_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(state_, TARGET_PENDING_INTERNAL);
-  DVLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
+  DVLOG(20) << __func__ << "() download=" << DebugString(true);
 
   TransitionTo(TARGET_RESOLVED_INTERNAL);
 
   // If the intermediate rename fails while there's also a destination_error_,
   // then the former is considered the critical error since it requires
   // discarding the partial state.
   if (DOWNLOAD_INTERRUPT_REASON_NONE != reason) {
     // TODO(asanka): Even though the rename failed, it may still be possible to
     // recover the partial state from the 'before' name.
     InterruptAndDiscardPartialState(reason);
@@ skipping 47 matching lines @@
 }
 
 // Called by MaybeCompleteDownload() when it has determined that the download
 // is ready for completion.
 void DownloadItemImpl::OnDownloadCompleting() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (state_ != IN_PROGRESS_INTERNAL)
     return;
 
-  DVLOG(20) << __FUNCTION__ << "()"
-            << " " << DebugString(true);
+  DVLOG(20) << __func__ << "() " << 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.
     Completed();
@@ skipping 23 matching lines @@
     const base::FilePath& full_path) {
   DCHECK_CURRENTLY_ON(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;
 
-  DVLOG(20) << __FUNCTION__ << "()"
-            << " full_path = \"" << full_path.value() << "\""
-            << " " << DebugString(false);
+  DVLOG(20) << __func__ << "() full_path = \"" << full_path.value() << "\" "
+            << DebugString(false);
 
   if (DOWNLOAD_INTERRUPT_REASON_NONE != reason) {
     // Failure to perform the final rename is considered fatal. TODO(asanka): It
     // may not be, in which case we should figure out whether we can recover the
     // state.
     InterruptAndDiscardPartialState(reason);
     UpdateObservers();
     return;
   }
 
@@ skipping 28 matching lines @@
 void DownloadItemImpl::DelayedDownloadOpened(bool auto_opened) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   auto_opened_ = auto_opened;
   Completed();
 }
 
 void DownloadItemImpl::Completed() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  DVLOG(20) << __FUNCTION__ << "() " << DebugString(false);
+  DVLOG(20) << __func__ << "() " << DebugString(false);
 
   DCHECK(all_data_saved_);
   end_time_ = base::Time::Now();
   TransitionTo(COMPLETE_INTERNAL);
   RecordDownloadCompleted(start_tick_, received_bytes_);
 
   if (auto_opened_) {
     // If it was already handled by the delegate, do nothing.
   } else if (GetOpenWhenComplete() ||
              ShouldOpenFileBasedOnExtension() ||
@@ skipping 15 matching lines @@
     DownloadInterruptReason reason) {
   InterruptWithPartialState(0, std::unique_ptr<crypto::SecureHash>(), reason);
 }
 
 void DownloadItemImpl::InterruptWithPartialState(
     int64_t bytes_so_far,
     std::unique_ptr<crypto::SecureHash> hash_state,
     DownloadInterruptReason reason) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_NE(DOWNLOAD_INTERRUPT_REASON_NONE, reason);
-  DVLOG(20) << __FUNCTION__
+  DVLOG(20) << __func__
             << "() reason:" << DownloadInterruptReasonToString(reason)
             << " bytes_so_far:" << bytes_so_far
             << " hash_state:" << (hash_state ? "Valid" : "Invalid")
             << " this=" << DebugString(true);
 
   // Somewhat counter-intuitively, it is possible for us to receive an
   // interrupt after we've already been interrupted.  The generation of
   // interrupts from the file thread Renames and the generation of
   // interrupts from disk writes go through two different mechanisms (driven
   // by rename requests from UI thread and by write requests from IO thread,
@@ skipping 117 matching lines @@
   }
 
   std::unique_ptr<crypto::SecureHash> clone_of_hash_state(hash_state_->Clone());
   std::vector<char> hash_value(clone_of_hash_state->GetHashLength());
   clone_of_hash_state->Finish(&hash_value.front(), hash_value.size());
   hash_.assign(hash_value.begin(), hash_value.end());
 }
 
 void DownloadItemImpl::ReleaseDownloadFile(bool destroy_file) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DVLOG(20) << __FUNCTION__ << "() destroy_file:" << destroy_file;
+  DVLOG(20) << __func__ << "() destroy_file:" << destroy_file;
 
   if (destroy_file) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         // Will be deleted at end of task execution.
         base::Bind(&DownloadFileCancel, base::Passed(&download_file_)));
     // Avoid attempting to reuse the intermediate file by clearing out
     // current_path_.
     current_path_.clear();
   } else {
@@ skipping 117 matching lines @@
       bound_net_log_.AddEvent(
           net::NetLog::TYPE_DOWNLOAD_ITEM_CANCELED,
           base::Bind(&ItemCanceledNetLogCallback, received_bytes_));
       break;
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
       NOTREACHED();
       break;
   }
 
-  DVLOG(20) << " " << __FUNCTION__ << "()"
-            << " from:" << DebugDownloadStateString(old_state)
+  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
@@ skipping 26 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_CURRENTLY_ON(BrowserThread::UI);
-  DVLOG(20) << __FUNCTION__ << "()"
-            << " new_path = \"" << new_path.value() << "\""
-            << " " << DebugString(true);
+  DVLOG(20) << __func__ << "() 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() {
-  DVLOG(20) << __FUNCTION__ << "() " << DebugString(true);
+  DVLOG(20) << __func__ << "() " << DebugString(true);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ResumeMode mode = GetResumeMode();
 
   if (mode != RESUME_MODE_IMMEDIATE_RESTART &&
       mode != RESUME_MODE_IMMEDIATE_CONTINUE) {
     return;
   }
 
   auto_resume_count_++;
 
@@ skipping 225 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